[osmosis] 01/02: Add patch to support protobuf 3.0.0. (closes: #835776)
Bas Couwenberg
sebastic at debian.org
Sun Aug 28 16:17:45 UTC 2016
This is an automated email from the git hooks/post-receive script.
sebastic pushed a commit to branch master
in repository osmosis.
commit 9dbe105679f8f244172e5da36c934cc1b7c5920f
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date: Sun Aug 28 17:49:45 2016 +0200
Add patch to support protobuf 3.0.0. (closes: #835776)
---
debian/changelog | 2 +
debian/patches/protobuf-3.0.0.patch | 20435 ++++++++++++++++++++++++++++++++++
debian/patches/series | 1 +
3 files changed, 20438 insertions(+)
diff --git a/debian/changelog b/debian/changelog
index 075ecd8..2fcb157 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,6 +1,8 @@
osmosis (0.45-3) UNRELEASED; urgency=medium
* Switch to headless variant for default-jdk dependency.
+ * Add patch to support protobuf 3.0.0.
+ (closes: #835776)
-- Bas Couwenberg <sebastic at debian.org> Tue, 16 Aug 2016 11:57:24 +0200
diff --git a/debian/patches/protobuf-3.0.0.patch b/debian/patches/protobuf-3.0.0.patch
new file mode 100644
index 0000000..db24cd3
--- /dev/null
+++ b/debian/patches/protobuf-3.0.0.patch
@@ -0,0 +1,20435 @@
+Description: Add support for protobuf 3.0.0.
+ Files regenerated with osmosis-osm-binary/osmosis-protoc.sh
+Author: Bas Couwenberg <sebastic at debian.org>
+Bug-Debian: https://bugs.debian.org/835776
+Forwarded: https://github.com/openstreetmap/osmosis/pull/32
+
+--- a/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Fileformat.java
++++ b/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Fileformat.java
+@@ -13,334 +13,344 @@ public final class Fileformat {
+ com.google.protobuf.MessageLiteOrBuilder {
+
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ boolean hasRaw();
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ com.google.protobuf.ByteString getRaw();
+
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ boolean hasRawSize();
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ int getRawSize();
+
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ boolean hasZlibData();
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ com.google.protobuf.ByteString getZlibData();
+
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ boolean hasLzmaData();
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ com.google.protobuf.ByteString getLzmaData();
+
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated boolean hasOBSOLETEBzip2Data();
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated com.google.protobuf.ByteString getOBSOLETEBzip2Data();
+ }
+ /**
+ * Protobuf type {@code OSMPBF.Blob}
+ */
+- public static final class Blob extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class Blob extends
++ com.google.protobuf.GeneratedMessageLite<
++ Blob, Blob.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.Blob)
+ BlobOrBuilder {
+- // Use Blob.newBuilder() to construct.
+- private Blob(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private Blob(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final Blob defaultInstance;
+- public static Blob getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public Blob getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private Blob(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- bitField0_ |= 0x00000001;
+- raw_ = input.readBytes();
+- break;
+- }
+- case 16: {
+- bitField0_ |= 0x00000002;
+- rawSize_ = input.readInt32();
+- break;
+- }
+- case 26: {
+- bitField0_ |= 0x00000004;
+- zlibData_ = input.readBytes();
+- break;
+- }
+- case 34: {
+- bitField0_ |= 0x00000008;
+- lzmaData_ = input.readBytes();
+- break;
+- }
+- case 42: {
+- bitField0_ |= 0x00000010;
+- oBSOLETEBzip2Data_ = input.readBytes();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<Blob> PARSER =
+- new com.google.protobuf.AbstractParser<Blob>() {
+- public Blob parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new Blob(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<Blob> getParserForType() {
+- return PARSER;
++ private Blob() {
++ raw_ = com.google.protobuf.ByteString.EMPTY;
++ zlibData_ = com.google.protobuf.ByteString.EMPTY;
++ lzmaData_ = com.google.protobuf.ByteString.EMPTY;
++ oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
+ }
+-
+ private int bitField0_;
+ public static final int RAW_FIELD_NUMBER = 1;
+ private com.google.protobuf.ByteString raw_;
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public boolean hasRaw() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public com.google.protobuf.ByteString getRaw() {
+ return raw_;
+ }
++ /**
++ * <pre>
++ * No compression
++ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
++ */
++ private void setRaw(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000001;
++ raw_ = value;
++ }
++ /**
++ * <pre>
++ * No compression
++ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
++ */
++ private void clearRaw() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ raw_ = getDefaultInstance().getRaw();
++ }
+
+ public static final int RAW_SIZE_FIELD_NUMBER = 2;
+ private int rawSize_;
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public boolean hasRawSize() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public int getRawSize() {
+ return rawSize_;
+ }
++ /**
++ * <pre>
++ * When compressed, the uncompressed size
++ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
++ */
++ private void setRawSize(int value) {
++ bitField0_ |= 0x00000002;
++ rawSize_ = value;
++ }
++ /**
++ * <pre>
++ * When compressed, the uncompressed size
++ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
++ */
++ private void clearRawSize() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ rawSize_ = 0;
++ }
+
+ public static final int ZLIB_DATA_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString zlibData_;
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public boolean hasZlibData() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public com.google.protobuf.ByteString getZlibData() {
+ return zlibData_;
+ }
++ /**
++ * <pre>
++ * Possible compressed versions of the data.
++ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
++ */
++ private void setZlibData(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000004;
++ zlibData_ = value;
++ }
++ /**
++ * <pre>
++ * Possible compressed versions of the data.
++ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
++ */
++ private void clearZlibData() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ zlibData_ = getDefaultInstance().getZlibData();
++ }
+
+ public static final int LZMA_DATA_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString lzmaData_;
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public boolean hasLzmaData() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public com.google.protobuf.ByteString getLzmaData() {
+ return lzmaData_;
+ }
++ /**
++ * <pre>
++ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
++ */
++ private void setLzmaData(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000008;
++ lzmaData_ = value;
++ }
++ /**
++ * <pre>
++ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
++ */
++ private void clearLzmaData() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ lzmaData_ = getDefaultInstance().getLzmaData();
++ }
+
+ public static final int OBSOLETE_BZIP2_DATA_FIELD_NUMBER = 5;
+ private com.google.protobuf.ByteString oBSOLETEBzip2Data_;
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
+ return oBSOLETEBzip2Data_;
+ }
+-
+- private void initFields() {
+- raw_ = com.google.protobuf.ByteString.EMPTY;
+- rawSize_ = 0;
+- zlibData_ = com.google.protobuf.ByteString.EMPTY;
+- lzmaData_ = com.google.protobuf.ByteString.EMPTY;
+- oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
++ /**
++ * <pre>
++ * Formerly used for bzip2 compressed data. Depreciated in 2010.
++ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++ */
++ private void setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000010;
++ oBSOLETEBzip2Data_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * Formerly used for bzip2 compressed data. Depreciated in 2010.
++ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++ */
++ private void clearOBSOLETEBzip2Data() {
++ bitField0_ = (bitField0_ & ~0x00000010);
++ oBSOLETEBzip2Data_ = getDefaultInstance().getOBSOLETEBzip2Data();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, raw_);
+ }
+@@ -356,10 +366,9 @@ public final class Fileformat {
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeBytes(5, oBSOLETEBzip2Data_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -385,463 +394,448 @@ public final class Fileformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(5, oBSOLETEBzip2Data_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Fileformat.Blob prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.Blob}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Fileformat.Blob, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Fileformat.Blob, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.Blob)
+ org.openstreetmap.osmosis.osmbinary.Fileformat.BlobOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- raw_ = com.google.protobuf.ByteString.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- rawSize_ = 0;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- zlibData_ = com.google.protobuf.ByteString.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- lzmaData_ = com.google.protobuf.ByteString.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob build() {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.Blob result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.Blob result = new org.openstreetmap.osmosis.osmbinary.Fileformat.Blob(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.raw_ = raw_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.rawSize_ = rawSize_;
+- if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.zlibData_ = zlibData_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.lzmaData_ = lzmaData_;
+- if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+- to_bitField0_ |= 0x00000010;
+- }
+- result.oBSOLETEBzip2Data_ = oBSOLETEBzip2Data_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Fileformat.Blob other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.getDefaultInstance()) return this;
+- if (other.hasRaw()) {
+- setRaw(other.getRaw());
+- }
+- if (other.hasRawSize()) {
+- setRawSize(other.getRawSize());
+- }
+- if (other.hasZlibData()) {
+- setZlibData(other.getZlibData());
+- }
+- if (other.hasLzmaData()) {
+- setLzmaData(other.getLzmaData());
+- }
+- if (other.hasOBSOLETEBzip2Data()) {
+- setOBSOLETEBzip2Data(other.getOBSOLETEBzip2Data());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Fileformat.Blob) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+-
+- private com.google.protobuf.ByteString raw_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public boolean hasRaw() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasRaw();
+ }
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public com.google.protobuf.ByteString getRaw() {
+- return raw_;
++ return instance.getRaw();
+ }
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public Builder setRaw(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000001;
+- raw_ = value;
+-
++ copyOnWrite();
++ instance.setRaw(value);
+ return this;
+ }
+ /**
+- * <code>optional bytes raw = 1;</code>
+- *
+ * <pre>
+ * No compression
+ * </pre>
++ *
++ * <code>optional bytes raw = 1;</code>
+ */
+ public Builder clearRaw() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- raw_ = getDefaultInstance().getRaw();
+-
++ copyOnWrite();
++ instance.clearRaw();
+ return this;
+ }
+
+- private int rawSize_ ;
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public boolean hasRawSize() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasRawSize();
+ }
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public int getRawSize() {
+- return rawSize_;
++ return instance.getRawSize();
+ }
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public Builder setRawSize(int value) {
+- bitField0_ |= 0x00000002;
+- rawSize_ = value;
+-
++ copyOnWrite();
++ instance.setRawSize(value);
+ return this;
+ }
+ /**
+- * <code>optional int32 raw_size = 2;</code>
+- *
+ * <pre>
+ * When compressed, the uncompressed size
+ * </pre>
++ *
++ * <code>optional int32 raw_size = 2;</code>
+ */
+ public Builder clearRawSize() {
+- bitField0_ = (bitField0_ & ~0x00000002);
+- rawSize_ = 0;
+-
++ copyOnWrite();
++ instance.clearRawSize();
+ return this;
+ }
+
+- private com.google.protobuf.ByteString zlibData_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public boolean hasZlibData() {
+- return ((bitField0_ & 0x00000004) == 0x00000004);
++ return instance.hasZlibData();
+ }
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public com.google.protobuf.ByteString getZlibData() {
+- return zlibData_;
++ return instance.getZlibData();
+ }
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public Builder setZlibData(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000004;
+- zlibData_ = value;
+-
++ copyOnWrite();
++ instance.setZlibData(value);
+ return this;
+ }
+ /**
+- * <code>optional bytes zlib_data = 3;</code>
+- *
+ * <pre>
+ * Possible compressed versions of the data.
+ * </pre>
++ *
++ * <code>optional bytes zlib_data = 3;</code>
+ */
+ public Builder clearZlibData() {
+- bitField0_ = (bitField0_ & ~0x00000004);
+- zlibData_ = getDefaultInstance().getZlibData();
+-
++ copyOnWrite();
++ instance.clearZlibData();
+ return this;
+ }
+
+- private com.google.protobuf.ByteString lzmaData_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public boolean hasLzmaData() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasLzmaData();
+ }
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public com.google.protobuf.ByteString getLzmaData() {
+- return lzmaData_;
++ return instance.getLzmaData();
+ }
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public Builder setLzmaData(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000008;
+- lzmaData_ = value;
+-
++ copyOnWrite();
++ instance.setLzmaData(value);
+ return this;
+ }
+ /**
+- * <code>optional bytes lzma_data = 4;</code>
+- *
+ * <pre>
+ * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+ * </pre>
++ *
++ * <code>optional bytes lzma_data = 4;</code>
+ */
+ public Builder clearLzmaData() {
+- bitField0_ = (bitField0_ & ~0x00000008);
+- lzmaData_ = getDefaultInstance().getLzmaData();
+-
++ copyOnWrite();
++ instance.clearLzmaData();
+ return this;
+ }
+
+- private com.google.protobuf.ByteString oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
+- return ((bitField0_ & 0x00000010) == 0x00000010);
++ return instance.hasOBSOLETEBzip2Data();
+ }
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
+- return oBSOLETEBzip2Data_;
++ return instance.getOBSOLETEBzip2Data();
+ }
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public Builder setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000010;
+- oBSOLETEBzip2Data_ = value;
+-
++ copyOnWrite();
++ instance.setOBSOLETEBzip2Data(value);
+ return this;
+ }
+ /**
+- * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+- *
+ * <pre>
+ * Formerly used for bzip2 compressed data. Depreciated in 2010.
+ * </pre>
++ *
++ * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
+ */
+ @java.lang.Deprecated public Builder clearOBSOLETEBzip2Data() {
+- bitField0_ = (bitField0_ & ~0x00000010);
+- oBSOLETEBzip2Data_ = getDefaultInstance().getOBSOLETEBzip2Data();
+-
++ copyOnWrite();
++ instance.clearOBSOLETEBzip2Data();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.Blob)
+ }
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Fileformat.Blob();
++ }
++ case IS_INITIALIZED: {
++ return DEFAULT_INSTANCE;
++ }
++ case MAKE_IMMUTABLE: {
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Fileformat.Blob other = (org.openstreetmap.osmosis.osmbinary.Fileformat.Blob) arg1;
++ raw_ = visitor.visitByteString(
++ hasRaw(), raw_,
++ other.hasRaw(), other.raw_);
++ rawSize_ = visitor.visitInt(
++ hasRawSize(), rawSize_,
++ other.hasRawSize(), other.rawSize_);
++ zlibData_ = visitor.visitByteString(
++ hasZlibData(), zlibData_,
++ other.hasZlibData(), other.zlibData_);
++ lzmaData_ = visitor.visitByteString(
++ hasLzmaData(), lzmaData_,
++ other.hasLzmaData(), other.lzmaData_);
++ oBSOLETEBzip2Data_ = visitor.visitByteString(
++ hasOBSOLETEBzip2Data(), oBSOLETEBzip2Data_,
++ other.hasOBSOLETEBzip2Data(), other.oBSOLETEBzip2Data_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ bitField0_ |= 0x00000001;
++ raw_ = input.readBytes();
++ break;
++ }
++ case 16: {
++ bitField0_ |= 0x00000002;
++ rawSize_ = input.readInt32();
++ break;
++ }
++ case 26: {
++ bitField0_ |= 0x00000004;
++ zlibData_ = input.readBytes();
++ break;
++ }
++ case 34: {
++ bitField0_ |= 0x00000008;
++ lzmaData_ = input.readBytes();
++ break;
++ }
++ case 42: {
++ bitField0_ |= 0x00000010;
++ oBSOLETEBzip2Data_ = input.readBytes();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.Blob)
++ private static final org.openstreetmap.osmosis.osmbinary.Fileformat.Blob DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new Blob(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new Blob();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.Blob)
++ public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<Blob> PARSER;
++
++ public static com.google.protobuf.Parser<Blob> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface BlobHeaderOrBuilder extends
+@@ -883,105 +877,18 @@ public final class Fileformat {
+ /**
+ * Protobuf type {@code OSMPBF.BlobHeader}
+ */
+- public static final class BlobHeader extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class BlobHeader extends
++ com.google.protobuf.GeneratedMessageLite<
++ BlobHeader, BlobHeader.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.BlobHeader)
+ BlobHeaderOrBuilder {
+- // Use BlobHeader.newBuilder() to construct.
+- private BlobHeader(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private BlobHeader(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final BlobHeader defaultInstance;
+- public static BlobHeader getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public BlobHeader getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private BlobHeader(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- bitField0_ |= 0x00000001;
+- type_ = bs;
+- break;
+- }
+- case 18: {
+- bitField0_ |= 0x00000002;
+- indexdata_ = input.readBytes();
+- break;
+- }
+- case 24: {
+- bitField0_ |= 0x00000004;
+- datasize_ = input.readInt32();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<BlobHeader> PARSER =
+- new com.google.protobuf.AbstractParser<BlobHeader>() {
+- public BlobHeader parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new BlobHeader(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<BlobHeader> getParserForType() {
+- return PARSER;
++ private BlobHeader() {
++ type_ = "";
++ indexdata_ = com.google.protobuf.ByteString.EMPTY;
+ }
+-
+ private int bitField0_;
+ public static final int TYPE_FIELD_NUMBER = 1;
+- private java.lang.Object type_;
++ private java.lang.String type_;
+ /**
+ * <code>required string type = 1;</code>
+ */
+@@ -992,34 +899,43 @@ public final class Fileformat {
+ * <code>required string type = 1;</code>
+ */
+ public java.lang.String getType() {
+- java.lang.Object ref = type_;
+- if (ref instanceof java.lang.String) {
+- return (java.lang.String) ref;
+- } else {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- type_ = s;
+- }
+- return s;
+- }
++ return type_;
+ }
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getTypeBytes() {
+- java.lang.Object ref = type_;
+- if (ref instanceof java.lang.String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- type_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return com.google.protobuf.ByteString.copyFromUtf8(type_);
++ }
++ /**
++ * <code>required string type = 1;</code>
++ */
++ private void setType(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000001;
++ type_ = value;
++ }
++ /**
++ * <code>required string type = 1;</code>
++ */
++ private void clearType() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ type_ = getDefaultInstance().getType();
++ }
++ /**
++ * <code>required string type = 1;</code>
++ */
++ private void setTypeBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000001;
++ type_ = value.toStringUtf8();
+ }
+
+ public static final int INDEXDATA_FIELD_NUMBER = 2;
+@@ -1036,6 +952,23 @@ public final class Fileformat {
+ public com.google.protobuf.ByteString getIndexdata() {
+ return indexdata_;
+ }
++ /**
++ * <code>optional bytes indexdata = 2;</code>
++ */
++ private void setIndexdata(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000002;
++ indexdata_ = value;
++ }
++ /**
++ * <code>optional bytes indexdata = 2;</code>
++ */
++ private void clearIndexdata() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ indexdata_ = getDefaultInstance().getIndexdata();
++ }
+
+ public static final int DATASIZE_FIELD_NUMBER = 3;
+ private int datasize_;
+@@ -1051,35 +984,25 @@ public final class Fileformat {
+ public int getDatasize() {
+ return datasize_;
+ }
+-
+- private void initFields() {
+- type_ = "";
+- indexdata_ = com.google.protobuf.ByteString.EMPTY;
+- datasize_ = 0;
++ /**
++ * <code>required int32 datasize = 3;</code>
++ */
++ private void setDatasize(int value) {
++ bitField0_ |= 0x00000004;
++ datasize_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasType()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasDatasize()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <code>required int32 datasize = 3;</code>
++ */
++ private void clearDatasize() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ datasize_ = 0;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- output.writeBytes(1, getTypeBytes());
++ output.writeString(1, getType());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, indexdata_);
+@@ -1087,10 +1010,9 @@ public final class Fileformat {
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeInt32(3, datasize_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -1098,7 +1020,7 @@ public final class Fileformat {
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeBytesSize(1, getTypeBytes());
++ .computeStringSize(1, getType());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+@@ -1108,254 +1030,127 @@ public final class Fileformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt32Size(3, datasize_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.BlobHeader}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.BlobHeader)
+ org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeaderOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- type_ = "";
+- bitField0_ = (bitField0_ & ~0x00000001);
+- indexdata_ = com.google.protobuf.ByteString.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- datasize_ = 0;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.getDefaultInstance();
++ super(DEFAULT_INSTANCE);
+ }
+
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader build() {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader result = new org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.type_ = type_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.indexdata_ = indexdata_;
+- if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.datasize_ = datasize_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.getDefaultInstance()) return this;
+- if (other.hasType()) {
+- bitField0_ |= 0x00000001;
+- type_ = other.type_;
+-
+- }
+- if (other.hasIndexdata()) {
+- setIndexdata(other.getIndexdata());
+- }
+- if (other.hasDatasize()) {
+- setDatasize(other.getDatasize());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+
+- public final boolean isInitialized() {
+- if (!hasType()) {
+-
+- return false;
+- }
+- if (!hasDatasize()) {
+-
+- return false;
+- }
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+-
+- private java.lang.Object type_ = "";
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public boolean hasType() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasType();
+ }
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public java.lang.String getType() {
+- java.lang.Object ref = type_;
+- if (!(ref instanceof java.lang.String)) {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- type_ = s;
+- }
+- return s;
+- } else {
+- return (java.lang.String) ref;
+- }
++ return instance.getType();
+ }
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getTypeBytes() {
+- java.lang.Object ref = type_;
+- if (ref instanceof String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- type_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return instance.getTypeBytes();
+ }
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public Builder setType(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000001;
+- type_ = value;
+-
++ copyOnWrite();
++ instance.setType(value);
+ return this;
+ }
+ /**
+ * <code>required string type = 1;</code>
+ */
+ public Builder clearType() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- type_ = getDefaultInstance().getType();
+-
++ copyOnWrite();
++ instance.clearType();
+ return this;
+ }
+ /**
+@@ -1363,91 +1158,204 @@ public final class Fileformat {
+ */
+ public Builder setTypeBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000001;
+- type_ = value;
+-
++ copyOnWrite();
++ instance.setTypeBytes(value);
+ return this;
+ }
+
+- private com.google.protobuf.ByteString indexdata_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes indexdata = 2;</code>
+ */
+ public boolean hasIndexdata() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasIndexdata();
+ }
+ /**
+ * <code>optional bytes indexdata = 2;</code>
+ */
+ public com.google.protobuf.ByteString getIndexdata() {
+- return indexdata_;
++ return instance.getIndexdata();
+ }
+ /**
+ * <code>optional bytes indexdata = 2;</code>
+ */
+ public Builder setIndexdata(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000002;
+- indexdata_ = value;
+-
++ copyOnWrite();
++ instance.setIndexdata(value);
+ return this;
+ }
+ /**
+ * <code>optional bytes indexdata = 2;</code>
+ */
+ public Builder clearIndexdata() {
+- bitField0_ = (bitField0_ & ~0x00000002);
+- indexdata_ = getDefaultInstance().getIndexdata();
+-
++ copyOnWrite();
++ instance.clearIndexdata();
+ return this;
+ }
+
+- private int datasize_ ;
+ /**
+ * <code>required int32 datasize = 3;</code>
+ */
+ public boolean hasDatasize() {
+- return ((bitField0_ & 0x00000004) == 0x00000004);
++ return instance.hasDatasize();
+ }
+ /**
+ * <code>required int32 datasize = 3;</code>
+ */
+ public int getDatasize() {
+- return datasize_;
++ return instance.getDatasize();
+ }
+ /**
+ * <code>required int32 datasize = 3;</code>
+ */
+ public Builder setDatasize(int value) {
+- bitField0_ |= 0x00000004;
+- datasize_ = value;
+-
++ copyOnWrite();
++ instance.setDatasize(value);
+ return this;
+ }
+ /**
+ * <code>required int32 datasize = 3;</code>
+ */
+ public Builder clearDatasize() {
+- bitField0_ = (bitField0_ & ~0x00000004);
+- datasize_ = 0;
+-
++ copyOnWrite();
++ instance.clearDatasize();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.BlobHeader)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasType()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasDatasize()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
+
+- static {
+- defaultInstance = new BlobHeader(true);
+- defaultInstance.initFields();
++ }
++ case MAKE_IMMUTABLE: {
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader other = (org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader) arg1;
++ type_ = visitor.visitString(
++ hasType(), type_,
++ other.hasType(), other.type_);
++ indexdata_ = visitor.visitByteString(
++ hasIndexdata(), indexdata_,
++ other.hasIndexdata(), other.indexdata_);
++ datasize_ = visitor.visitInt(
++ hasDatasize(), datasize_,
++ other.hasDatasize(), other.datasize_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ String s = input.readString();
++ bitField0_ |= 0x00000001;
++ type_ = s;
++ break;
++ }
++ case 18: {
++ bitField0_ |= 0x00000002;
++ indexdata_ = input.readBytes();
++ break;
++ }
++ case 24: {
++ bitField0_ |= 0x00000004;
++ datasize_ = input.readInt32();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
+ }
+
++
+ // @@protoc_insertion_point(class_scope:OSMPBF.BlobHeader)
++ private static final org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader DEFAULT_INSTANCE;
++ static {
++ DEFAULT_INSTANCE = new BlobHeader();
++ DEFAULT_INSTANCE.makeImmutable();
++ }
++
++ public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<BlobHeader> PARSER;
++
++ public static com.google.protobuf.Parser<BlobHeader> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+
+--- a/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Osmformat.java
++++ b/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Osmformat.java
+@@ -22,36 +22,36 @@ public final class Osmformat {
+ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox();
+
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+- com.google.protobuf.ProtocolStringList
++ java.util.List<String>
+ getRequiredFeaturesList();
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ int getRequiredFeaturesCount();
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ java.lang.String getRequiredFeatures(int index);
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ com.google.protobuf.ByteString
+ getRequiredFeaturesBytes(int index);
+@@ -59,7 +59,7 @@ public final class Osmformat {
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+- com.google.protobuf.ProtocolStringList
++ java.util.List<String>
+ getOptionalFeaturesList();
+ /**
+ * <code>repeated string optional_features = 5;</code>
+@@ -90,91 +90,91 @@ public final class Osmformat {
+ getWritingprogramBytes();
+
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ boolean hasSource();
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ java.lang.String getSource();
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ com.google.protobuf.ByteString
+ getSourceBytes();
+
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ boolean hasOsmosisReplicationTimestamp();
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ long getOsmosisReplicationTimestamp();
+
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ boolean hasOsmosisReplicationSequenceNumber();
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ long getOsmosisReplicationSequenceNumber();
+
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ boolean hasOsmosisReplicationBaseUrl();
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ java.lang.String getOsmosisReplicationBaseUrl();
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ com.google.protobuf.ByteString
+ getOsmosisReplicationBaseUrlBytes();
+@@ -182,151 +182,18 @@ public final class Osmformat {
+ /**
+ * Protobuf type {@code OSMPBF.HeaderBlock}
+ */
+- public static final class HeaderBlock extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class HeaderBlock extends
++ com.google.protobuf.GeneratedMessageLite<
++ HeaderBlock, HeaderBlock.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.HeaderBlock)
+ HeaderBlockOrBuilder {
+- // Use HeaderBlock.newBuilder() to construct.
+- private HeaderBlock(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private HeaderBlock(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final HeaderBlock defaultInstance;
+- public static HeaderBlock getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public HeaderBlock getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private HeaderBlock(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- subBuilder = bbox_.toBuilder();
+- }
+- bbox_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(bbox_);
+- bbox_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000001;
+- break;
+- }
+- case 34: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- requiredFeatures_ = new com.google.protobuf.LazyStringArrayList();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- requiredFeatures_.add(bs);
+- break;
+- }
+- case 42: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- optionalFeatures_ = new com.google.protobuf.LazyStringArrayList();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- optionalFeatures_.add(bs);
+- break;
+- }
+- case 130: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- bitField0_ |= 0x00000002;
+- writingprogram_ = bs;
+- break;
+- }
+- case 138: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- bitField0_ |= 0x00000004;
+- source_ = bs;
+- break;
+- }
+- case 256: {
+- bitField0_ |= 0x00000008;
+- osmosisReplicationTimestamp_ = input.readInt64();
+- break;
+- }
+- case 264: {
+- bitField0_ |= 0x00000010;
+- osmosisReplicationSequenceNumber_ = input.readInt64();
+- break;
+- }
+- case 274: {
+- com.google.protobuf.ByteString bs = input.readBytes();
+- bitField0_ |= 0x00000020;
+- osmosisReplicationBaseUrl_ = bs;
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- requiredFeatures_ = requiredFeatures_.getUnmodifiableView();
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- optionalFeatures_ = optionalFeatures_.getUnmodifiableView();
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<HeaderBlock> PARSER =
+- new com.google.protobuf.AbstractParser<HeaderBlock>() {
+- public HeaderBlock parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new HeaderBlock(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<HeaderBlock> getParserForType() {
+- return PARSER;
++ private HeaderBlock() {
++ requiredFeatures_ = com.google.protobuf.GeneratedMessageLite.emptyProtobufList();
++ optionalFeatures_ = com.google.protobuf.GeneratedMessageLite.emptyProtobufList();
++ writingprogram_ = "";
++ source_ = "";
++ osmosisReplicationBaseUrl_ = "";
+ }
+-
+ private int bitField0_;
+ public static final int BBOX_FIELD_NUMBER = 1;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox bbox_;
+@@ -340,61 +207,171 @@ public final class Osmformat {
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox() {
+- return bbox_;
++ return bbox_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance() : bbox_;
++ }
++ /**
++ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++ */
++ private void setBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bbox_ = value;
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++ */
++ private void setBbox(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder builderForValue) {
++ bbox_ = builderForValue.build();
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++ */
++ private void mergeBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
++ if (bbox_ != null &&
++ bbox_ != org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance()) {
++ bbox_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.newBuilder(bbox_).mergeFrom(value).buildPartial();
++ } else {
++ bbox_ = value;
++ }
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++ */
++ private void clearBbox() { bbox_ = null;
++ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+
+ public static final int REQUIRED_FEATURES_FIELD_NUMBER = 4;
+- private com.google.protobuf.LazyStringList requiredFeatures_;
++ private com.google.protobuf.Internal.ProtobufList<String> requiredFeatures_;
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+- public com.google.protobuf.ProtocolStringList
+- getRequiredFeaturesList() {
++ public java.util.List<String> getRequiredFeaturesList() {
+ return requiredFeatures_;
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public int getRequiredFeaturesCount() {
+ return requiredFeatures_.size();
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public java.lang.String getRequiredFeatures(int index) {
+ return requiredFeatures_.get(index);
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public com.google.protobuf.ByteString
+ getRequiredFeaturesBytes(int index) {
+- return requiredFeatures_.getByteString(index);
++ return com.google.protobuf.ByteString.copyFromUtf8(
++ requiredFeatures_.get(index));
++ }
++ private void ensureRequiredFeaturesIsMutable() {
++ if (!requiredFeatures_.isModifiable()) {
++ requiredFeatures_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(requiredFeatures_);
++ }
++ }
++ /**
++ * <pre>
++ * Additional tags to aid in parsing this dataset
++ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
++ */
++ private void setRequiredFeatures(
++ int index, java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRequiredFeaturesIsMutable();
++ requiredFeatures_.set(index, value);
++ }
++ /**
++ * <pre>
++ * Additional tags to aid in parsing this dataset
++ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
++ */
++ private void addRequiredFeatures(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRequiredFeaturesIsMutable();
++ requiredFeatures_.add(value);
++ }
++ /**
++ * <pre>
++ * Additional tags to aid in parsing this dataset
++ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
++ */
++ private void addAllRequiredFeatures(
++ java.lang.Iterable<java.lang.String> values) {
++ ensureRequiredFeaturesIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, requiredFeatures_);
++ }
++ /**
++ * <pre>
++ * Additional tags to aid in parsing this dataset
++ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
++ */
++ private void clearRequiredFeatures() {
++ requiredFeatures_ = com.google.protobuf.GeneratedMessageLite.emptyProtobufList();
++ }
++ /**
++ * <pre>
++ * Additional tags to aid in parsing this dataset
++ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
++ */
++ private void addRequiredFeaturesBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRequiredFeaturesIsMutable();
++ requiredFeatures_.add(value.toStringUtf8());
+ }
+
+ public static final int OPTIONAL_FEATURES_FIELD_NUMBER = 5;
+- private com.google.protobuf.LazyStringList optionalFeatures_;
++ private com.google.protobuf.Internal.ProtobufList<String> optionalFeatures_;
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+- public com.google.protobuf.ProtocolStringList
+- getOptionalFeaturesList() {
++ public java.util.List<String> getOptionalFeaturesList() {
+ return optionalFeatures_;
+ }
+ /**
+@@ -414,11 +391,66 @@ public final class Osmformat {
+ */
+ public com.google.protobuf.ByteString
+ getOptionalFeaturesBytes(int index) {
+- return optionalFeatures_.getByteString(index);
++ return com.google.protobuf.ByteString.copyFromUtf8(
++ optionalFeatures_.get(index));
++ }
++ private void ensureOptionalFeaturesIsMutable() {
++ if (!optionalFeatures_.isModifiable()) {
++ optionalFeatures_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(optionalFeatures_);
++ }
++ }
++ /**
++ * <code>repeated string optional_features = 5;</code>
++ */
++ private void setOptionalFeatures(
++ int index, java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureOptionalFeaturesIsMutable();
++ optionalFeatures_.set(index, value);
++ }
++ /**
++ * <code>repeated string optional_features = 5;</code>
++ */
++ private void addOptionalFeatures(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureOptionalFeaturesIsMutable();
++ optionalFeatures_.add(value);
++ }
++ /**
++ * <code>repeated string optional_features = 5;</code>
++ */
++ private void addAllOptionalFeatures(
++ java.lang.Iterable<java.lang.String> values) {
++ ensureOptionalFeaturesIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, optionalFeatures_);
++ }
++ /**
++ * <code>repeated string optional_features = 5;</code>
++ */
++ private void clearOptionalFeatures() {
++ optionalFeatures_ = com.google.protobuf.GeneratedMessageLite.emptyProtobufList();
++ }
++ /**
++ * <code>repeated string optional_features = 5;</code>
++ */
++ private void addOptionalFeaturesBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureOptionalFeaturesIsMutable();
++ optionalFeatures_.add(value.toStringUtf8());
+ }
+
+ public static final int WRITINGPROGRAM_FIELD_NUMBER = 16;
+- private java.lang.Object writingprogram_;
++ private java.lang.String writingprogram_;
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+@@ -429,237 +461,309 @@ public final class Osmformat {
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public java.lang.String getWritingprogram() {
+- java.lang.Object ref = writingprogram_;
+- if (ref instanceof java.lang.String) {
+- return (java.lang.String) ref;
+- } else {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- writingprogram_ = s;
+- }
+- return s;
+- }
++ return writingprogram_;
+ }
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public com.google.protobuf.ByteString
+ getWritingprogramBytes() {
+- java.lang.Object ref = writingprogram_;
+- if (ref instanceof java.lang.String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- writingprogram_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return com.google.protobuf.ByteString.copyFromUtf8(writingprogram_);
++ }
++ /**
++ * <code>optional string writingprogram = 16;</code>
++ */
++ private void setWritingprogram(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000002;
++ writingprogram_ = value;
++ }
++ /**
++ * <code>optional string writingprogram = 16;</code>
++ */
++ private void clearWritingprogram() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ writingprogram_ = getDefaultInstance().getWritingprogram();
++ }
++ /**
++ * <code>optional string writingprogram = 16;</code>
++ */
++ private void setWritingprogramBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000002;
++ writingprogram_ = value.toStringUtf8();
+ }
+
+ public static final int SOURCE_FIELD_NUMBER = 17;
+- private java.lang.Object source_;
++ private java.lang.String source_;
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public boolean hasSource() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public java.lang.String getSource() {
+- java.lang.Object ref = source_;
+- if (ref instanceof java.lang.String) {
+- return (java.lang.String) ref;
+- } else {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- source_ = s;
+- }
+- return s;
+- }
++ return source_;
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public com.google.protobuf.ByteString
+ getSourceBytes() {
+- java.lang.Object ref = source_;
+- if (ref instanceof java.lang.String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- source_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return com.google.protobuf.ByteString.copyFromUtf8(source_);
+ }
+-
+- public static final int OSMOSIS_REPLICATION_TIMESTAMP_FIELD_NUMBER = 32;
+- private long osmosisReplicationTimestamp_;
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+- * replication timestamp, expressed in seconds since the epoch,
+- * otherwise the same value as in the "timestamp=..." field
+- * in the state.txt file used by Osmosis
++ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+- public boolean hasOsmosisReplicationTimestamp() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ private void setSource(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000004;
++ source_ = value;
+ }
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+- * replication timestamp, expressed in seconds since the epoch,
+- * otherwise the same value as in the "timestamp=..." field
+- * in the state.txt file used by Osmosis
++ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+- public long getOsmosisReplicationTimestamp() {
++ private void clearSource() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ source_ = getDefaultInstance().getSource();
++ }
++ /**
++ * <pre>
++ * From the bbox field.
++ * </pre>
++ *
++ * <code>optional string source = 17;</code>
++ */
++ private void setSourceBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000004;
++ source_ = value.toStringUtf8();
++ }
++
++ public static final int OSMOSIS_REPLICATION_TIMESTAMP_FIELD_NUMBER = 32;
++ private long osmosisReplicationTimestamp_;
++ /**
++ * <pre>
++ * replication timestamp, expressed in seconds since the epoch,
++ * otherwise the same value as in the "timestamp=..." field
++ * in the state.txt file used by Osmosis
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++ */
++ public boolean hasOsmosisReplicationTimestamp() {
++ return ((bitField0_ & 0x00000008) == 0x00000008);
++ }
++ /**
++ * <pre>
++ * replication timestamp, expressed in seconds since the epoch,
++ * otherwise the same value as in the "timestamp=..." field
++ * in the state.txt file used by Osmosis
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++ */
++ public long getOsmosisReplicationTimestamp() {
+ return osmosisReplicationTimestamp_;
+ }
++ /**
++ * <pre>
++ * replication timestamp, expressed in seconds since the epoch,
++ * otherwise the same value as in the "timestamp=..." field
++ * in the state.txt file used by Osmosis
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++ */
++ private void setOsmosisReplicationTimestamp(long value) {
++ bitField0_ |= 0x00000008;
++ osmosisReplicationTimestamp_ = value;
++ }
++ /**
++ * <pre>
++ * replication timestamp, expressed in seconds since the epoch,
++ * otherwise the same value as in the "timestamp=..." field
++ * in the state.txt file used by Osmosis
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++ */
++ private void clearOsmosisReplicationTimestamp() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ osmosisReplicationTimestamp_ = 0L;
++ }
+
+ public static final int OSMOSIS_REPLICATION_SEQUENCE_NUMBER_FIELD_NUMBER = 33;
+ private long osmosisReplicationSequenceNumber_;
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public boolean hasOsmosisReplicationSequenceNumber() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public long getOsmosisReplicationSequenceNumber() {
+ return osmosisReplicationSequenceNumber_;
+ }
++ /**
++ * <pre>
++ * replication sequence number (sequenceNumber in state.txt)
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++ */
++ private void setOsmosisReplicationSequenceNumber(long value) {
++ bitField0_ |= 0x00000010;
++ osmosisReplicationSequenceNumber_ = value;
++ }
++ /**
++ * <pre>
++ * replication sequence number (sequenceNumber in state.txt)
++ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++ */
++ private void clearOsmosisReplicationSequenceNumber() {
++ bitField0_ = (bitField0_ & ~0x00000010);
++ osmosisReplicationSequenceNumber_ = 0L;
++ }
+
+ public static final int OSMOSIS_REPLICATION_BASE_URL_FIELD_NUMBER = 34;
+- private java.lang.Object osmosisReplicationBaseUrl_;
++ private java.lang.String osmosisReplicationBaseUrl_;
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public boolean hasOsmosisReplicationBaseUrl() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public java.lang.String getOsmosisReplicationBaseUrl() {
+- java.lang.Object ref = osmosisReplicationBaseUrl_;
+- if (ref instanceof java.lang.String) {
+- return (java.lang.String) ref;
+- } else {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- osmosisReplicationBaseUrl_ = s;
+- }
+- return s;
+- }
++ return osmosisReplicationBaseUrl_;
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public com.google.protobuf.ByteString
+ getOsmosisReplicationBaseUrlBytes() {
+- java.lang.Object ref = osmosisReplicationBaseUrl_;
+- if (ref instanceof java.lang.String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- osmosisReplicationBaseUrl_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return com.google.protobuf.ByteString.copyFromUtf8(osmosisReplicationBaseUrl_);
+ }
+-
+- private void initFields() {
+- bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+- requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- writingprogram_ = "";
+- source_ = "";
+- osmosisReplicationTimestamp_ = 0L;
+- osmosisReplicationSequenceNumber_ = 0L;
+- osmosisReplicationBaseUrl_ = "";
++ /**
++ * <pre>
++ * replication base URL (from Osmosis' configuration.txt file)
++ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
++ */
++ private void setOsmosisReplicationBaseUrl(
++ java.lang.String value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000020;
++ osmosisReplicationBaseUrl_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (hasBbox()) {
+- if (!getBbox().isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * replication base URL (from Osmosis' configuration.txt file)
++ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
++ */
++ private void clearOsmosisReplicationBaseUrl() {
++ bitField0_ = (bitField0_ & ~0x00000020);
++ osmosisReplicationBaseUrl_ = getDefaultInstance().getOsmosisReplicationBaseUrl();
++ }
++ /**
++ * <pre>
++ * replication base URL (from Osmosis' configuration.txt file)
++ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
++ */
++ private void setOsmosisReplicationBaseUrlBytes(
++ com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ bitField0_ |= 0x00000020;
++ osmosisReplicationBaseUrl_ = value.toStringUtf8();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- output.writeMessage(1, bbox_);
++ output.writeMessage(1, getBbox());
+ }
+ for (int i = 0; i < requiredFeatures_.size(); i++) {
+- output.writeBytes(4, requiredFeatures_.getByteString(i));
++ output.writeString(4, requiredFeatures_.get(i));
+ }
+ for (int i = 0; i < optionalFeatures_.size(); i++) {
+- output.writeBytes(5, optionalFeatures_.getByteString(i));
++ output.writeString(5, optionalFeatures_.get(i));
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- output.writeBytes(16, getWritingprogramBytes());
++ output.writeString(16, getWritingprogram());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- output.writeBytes(17, getSourceBytes());
++ output.writeString(17, getSource());
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeInt64(32, osmosisReplicationTimestamp_);
+@@ -668,12 +772,11 @@ public final class Osmformat {
+ output.writeInt64(33, osmosisReplicationSequenceNumber_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+- output.writeBytes(34, getOsmosisReplicationBaseUrlBytes());
++ output.writeString(34, getOsmosisReplicationBaseUrl());
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -681,13 +784,13 @@ public final class Osmformat {
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(1, bbox_);
++ .computeMessageSize(1, getBbox());
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < requiredFeatures_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeBytesSizeNoTag(requiredFeatures_.getByteString(i));
++ .computeStringSizeNoTag(requiredFeatures_.get(i));
+ }
+ size += dataSize;
+ size += 1 * getRequiredFeaturesList().size();
+@@ -696,18 +799,18 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < optionalFeatures_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeBytesSizeNoTag(optionalFeatures_.getByteString(i));
++ .computeStringSizeNoTag(optionalFeatures_.get(i));
+ }
+ size += dataSize;
+ size += 1 * getOptionalFeaturesList().size();
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeBytesSize(16, getWritingprogramBytes());
++ .computeStringSize(16, getWritingprogram());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeBytesSize(17, getSourceBytes());
++ .computeStringSize(17, getSource());
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+@@ -719,492 +822,282 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeBytesSize(34, getOsmosisReplicationBaseUrlBytes());
++ .computeStringSize(34, getOsmosisReplicationBaseUrl());
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.HeaderBlock}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.HeaderBlock)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlockOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- writingprogram_ = "";
+- bitField0_ = (bitField0_ & ~0x00000008);
+- source_ = "";
+- bitField0_ = (bitField0_ & ~0x00000010);
+- osmosisReplicationTimestamp_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- osmosisReplicationSequenceNumber_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000040);
+- osmosisReplicationBaseUrl_ = "";
+- bitField0_ = (bitField0_ & ~0x00000080);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock result = new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.bbox_ = bbox_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- requiredFeatures_ = requiredFeatures_.getUnmodifiableView();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.requiredFeatures_ = requiredFeatures_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- optionalFeatures_ = optionalFeatures_.getUnmodifiableView();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.optionalFeatures_ = optionalFeatures_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.writingprogram_ = writingprogram_;
+- if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.source_ = source_;
+- if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.osmosisReplicationTimestamp_ = osmosisReplicationTimestamp_;
+- if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+- to_bitField0_ |= 0x00000010;
+- }
+- result.osmosisReplicationSequenceNumber_ = osmosisReplicationSequenceNumber_;
+- if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+- to_bitField0_ |= 0x00000020;
+- }
+- result.osmosisReplicationBaseUrl_ = osmosisReplicationBaseUrl_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.getDefaultInstance()) return this;
+- if (other.hasBbox()) {
+- mergeBbox(other.getBbox());
+- }
+- if (!other.requiredFeatures_.isEmpty()) {
+- if (requiredFeatures_.isEmpty()) {
+- requiredFeatures_ = other.requiredFeatures_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensureRequiredFeaturesIsMutable();
+- requiredFeatures_.addAll(other.requiredFeatures_);
+- }
+-
+- }
+- if (!other.optionalFeatures_.isEmpty()) {
+- if (optionalFeatures_.isEmpty()) {
+- optionalFeatures_ = other.optionalFeatures_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureOptionalFeaturesIsMutable();
+- optionalFeatures_.addAll(other.optionalFeatures_);
+- }
+-
+- }
+- if (other.hasWritingprogram()) {
+- bitField0_ |= 0x00000008;
+- writingprogram_ = other.writingprogram_;
+-
+- }
+- if (other.hasSource()) {
+- bitField0_ |= 0x00000010;
+- source_ = other.source_;
+-
+- }
+- if (other.hasOsmosisReplicationTimestamp()) {
+- setOsmosisReplicationTimestamp(other.getOsmosisReplicationTimestamp());
+- }
+- if (other.hasOsmosisReplicationSequenceNumber()) {
+- setOsmosisReplicationSequenceNumber(other.getOsmosisReplicationSequenceNumber());
+- }
+- if (other.hasOsmosisReplicationBaseUrl()) {
+- bitField0_ |= 0x00000080;
+- osmosisReplicationBaseUrl_ = other.osmosisReplicationBaseUrl_;
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (hasBbox()) {
+- if (!getBbox().isInitialized()) {
+-
+- return false;
+- }
+- }
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public boolean hasBbox() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasBbox();
+ }
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox() {
+- return bbox_;
++ return instance.getBbox();
+ }
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public Builder setBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bbox_ = value;
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.setBbox(value);
+ return this;
+- }
++ }
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public Builder setBbox(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder builderForValue) {
+- bbox_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.setBbox(builderForValue);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+ public Builder mergeBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
+- if (((bitField0_ & 0x00000001) == 0x00000001) &&
+- bbox_ != org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance()) {
+- bbox_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.newBuilder(bbox_).mergeFrom(value).buildPartial();
+- } else {
+- bbox_ = value;
+- }
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.mergeBbox(value);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
+ */
+- public Builder clearBbox() {
+- bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000001);
++ public Builder clearBbox() { copyOnWrite();
++ instance.clearBbox();
+ return this;
+ }
+
+- private com.google.protobuf.LazyStringList requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- private void ensureRequiredFeaturesIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- requiredFeatures_ = new com.google.protobuf.LazyStringArrayList(requiredFeatures_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+- public com.google.protobuf.ProtocolStringList
++ public java.util.List<String>
+ getRequiredFeaturesList() {
+- return requiredFeatures_.getUnmodifiableView();
++ return java.util.Collections.unmodifiableList(
++ instance.getRequiredFeaturesList());
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public int getRequiredFeaturesCount() {
+- return requiredFeatures_.size();
++ return instance.getRequiredFeaturesCount();
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public java.lang.String getRequiredFeatures(int index) {
+- return requiredFeatures_.get(index);
++ return instance.getRequiredFeatures(index);
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public com.google.protobuf.ByteString
+ getRequiredFeaturesBytes(int index) {
+- return requiredFeatures_.getByteString(index);
++ return instance.getRequiredFeaturesBytes(index);
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public Builder setRequiredFeatures(
+ int index, java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRequiredFeaturesIsMutable();
+- requiredFeatures_.set(index, value);
+-
++ copyOnWrite();
++ instance.setRequiredFeatures(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public Builder addRequiredFeatures(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRequiredFeaturesIsMutable();
+- requiredFeatures_.add(value);
+-
++ copyOnWrite();
++ instance.addRequiredFeatures(value);
+ return this;
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public Builder addAllRequiredFeatures(
+ java.lang.Iterable<java.lang.String> values) {
+- ensureRequiredFeaturesIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, requiredFeatures_);
+-
++ copyOnWrite();
++ instance.addAllRequiredFeatures(values);
+ return this;
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public Builder clearRequiredFeatures() {
+- requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearRequiredFeatures();
+ return this;
+ }
+ /**
+- * <code>repeated string required_features = 4;</code>
+- *
+ * <pre>
+ * Additional tags to aid in parsing this dataset
+ * </pre>
++ *
++ * <code>repeated string required_features = 4;</code>
+ */
+ public Builder addRequiredFeaturesBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRequiredFeaturesIsMutable();
+- requiredFeatures_.add(value);
+-
++ copyOnWrite();
++ instance.addRequiredFeaturesBytes(value);
+ return this;
+ }
+
+- private com.google.protobuf.LazyStringList optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- private void ensureOptionalFeaturesIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- optionalFeatures_ = new com.google.protobuf.LazyStringArrayList(optionalFeatures_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+- public com.google.protobuf.ProtocolStringList
++ public java.util.List<String>
+ getOptionalFeaturesList() {
+- return optionalFeatures_.getUnmodifiableView();
++ return java.util.Collections.unmodifiableList(
++ instance.getOptionalFeaturesList());
+ }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+ public int getOptionalFeaturesCount() {
+- return optionalFeatures_.size();
++ return instance.getOptionalFeaturesCount();
+ }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+ public java.lang.String getOptionalFeatures(int index) {
+- return optionalFeatures_.get(index);
++ return instance.getOptionalFeatures(index);
+ }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+ public com.google.protobuf.ByteString
+ getOptionalFeaturesBytes(int index) {
+- return optionalFeatures_.getByteString(index);
++ return instance.getOptionalFeaturesBytes(index);
+ }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+ public Builder setOptionalFeatures(
+ int index, java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureOptionalFeaturesIsMutable();
+- optionalFeatures_.set(index, value);
+-
++ copyOnWrite();
++ instance.setOptionalFeatures(index, value);
+ return this;
+ }
+ /**
+@@ -1212,12 +1105,8 @@ public final class Osmformat {
+ */
+ public Builder addOptionalFeatures(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureOptionalFeaturesIsMutable();
+- optionalFeatures_.add(value);
+-
++ copyOnWrite();
++ instance.addOptionalFeatures(value);
+ return this;
+ }
+ /**
+@@ -1225,19 +1114,16 @@ public final class Osmformat {
+ */
+ public Builder addAllOptionalFeatures(
+ java.lang.Iterable<java.lang.String> values) {
+- ensureOptionalFeaturesIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, optionalFeatures_);
+-
++ copyOnWrite();
++ instance.addAllOptionalFeatures(values);
+ return this;
+ }
+ /**
+ * <code>repeated string optional_features = 5;</code>
+ */
+ public Builder clearOptionalFeatures() {
+- optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearOptionalFeatures();
+ return this;
+ }
+ /**
+@@ -1245,75 +1131,45 @@ public final class Osmformat {
+ */
+ public Builder addOptionalFeaturesBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureOptionalFeaturesIsMutable();
+- optionalFeatures_.add(value);
+-
++ copyOnWrite();
++ instance.addOptionalFeaturesBytes(value);
+ return this;
+ }
+
+- private java.lang.Object writingprogram_ = "";
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public boolean hasWritingprogram() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasWritingprogram();
+ }
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public java.lang.String getWritingprogram() {
+- java.lang.Object ref = writingprogram_;
+- if (!(ref instanceof java.lang.String)) {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- writingprogram_ = s;
+- }
+- return s;
+- } else {
+- return (java.lang.String) ref;
+- }
++ return instance.getWritingprogram();
+ }
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public com.google.protobuf.ByteString
+ getWritingprogramBytes() {
+- java.lang.Object ref = writingprogram_;
+- if (ref instanceof String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- writingprogram_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return instance.getWritingprogramBytes();
+ }
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public Builder setWritingprogram(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000008;
+- writingprogram_ = value;
+-
++ copyOnWrite();
++ instance.setWritingprogram(value);
+ return this;
+ }
+ /**
+ * <code>optional string writingprogram = 16;</code>
+ */
+ public Builder clearWritingprogram() {
+- bitField0_ = (bitField0_ & ~0x00000008);
+- writingprogram_ = getDefaultInstance().getWritingprogram();
+-
++ copyOnWrite();
++ instance.clearWritingprogram();
+ return this;
+ }
+ /**
+@@ -1321,328 +1177,434 @@ public final class Osmformat {
+ */
+ public Builder setWritingprogramBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000008;
+- writingprogram_ = value;
+-
++ copyOnWrite();
++ instance.setWritingprogramBytes(value);
+ return this;
+ }
+
+- private java.lang.Object source_ = "";
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
+- */
++ *
++ * <code>optional string source = 17;</code>
++ */
+ public boolean hasSource() {
+- return ((bitField0_ & 0x00000010) == 0x00000010);
++ return instance.hasSource();
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public java.lang.String getSource() {
+- java.lang.Object ref = source_;
+- if (!(ref instanceof java.lang.String)) {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- source_ = s;
+- }
+- return s;
+- } else {
+- return (java.lang.String) ref;
+- }
++ return instance.getSource();
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public com.google.protobuf.ByteString
+ getSourceBytes() {
+- java.lang.Object ref = source_;
+- if (ref instanceof String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- source_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return instance.getSourceBytes();
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public Builder setSource(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000010;
+- source_ = value;
+-
++ copyOnWrite();
++ instance.setSource(value);
+ return this;
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public Builder clearSource() {
+- bitField0_ = (bitField0_ & ~0x00000010);
+- source_ = getDefaultInstance().getSource();
+-
++ copyOnWrite();
++ instance.clearSource();
+ return this;
+ }
+ /**
+- * <code>optional string source = 17;</code>
+- *
+ * <pre>
+ * From the bbox field.
+ * </pre>
++ *
++ * <code>optional string source = 17;</code>
+ */
+ public Builder setSourceBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000010;
+- source_ = value;
+-
++ copyOnWrite();
++ instance.setSourceBytes(value);
+ return this;
+ }
+
+- private long osmosisReplicationTimestamp_ ;
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ public boolean hasOsmosisReplicationTimestamp() {
+- return ((bitField0_ & 0x00000020) == 0x00000020);
++ return instance.hasOsmosisReplicationTimestamp();
+ }
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ public long getOsmosisReplicationTimestamp() {
+- return osmosisReplicationTimestamp_;
++ return instance.getOsmosisReplicationTimestamp();
+ }
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ public Builder setOsmosisReplicationTimestamp(long value) {
+- bitField0_ |= 0x00000020;
+- osmosisReplicationTimestamp_ = value;
+-
++ copyOnWrite();
++ instance.setOsmosisReplicationTimestamp(value);
+ return this;
+ }
+ /**
+- * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+- *
+ * <pre>
+ * replication timestamp, expressed in seconds since the epoch,
+ * otherwise the same value as in the "timestamp=..." field
+ * in the state.txt file used by Osmosis
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_timestamp = 32;</code>
+ */
+ public Builder clearOsmosisReplicationTimestamp() {
+- bitField0_ = (bitField0_ & ~0x00000020);
+- osmosisReplicationTimestamp_ = 0L;
+-
++ copyOnWrite();
++ instance.clearOsmosisReplicationTimestamp();
+ return this;
+ }
+
+- private long osmosisReplicationSequenceNumber_ ;
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public boolean hasOsmosisReplicationSequenceNumber() {
+- return ((bitField0_ & 0x00000040) == 0x00000040);
++ return instance.hasOsmosisReplicationSequenceNumber();
+ }
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public long getOsmosisReplicationSequenceNumber() {
+- return osmosisReplicationSequenceNumber_;
++ return instance.getOsmosisReplicationSequenceNumber();
+ }
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public Builder setOsmosisReplicationSequenceNumber(long value) {
+- bitField0_ |= 0x00000040;
+- osmosisReplicationSequenceNumber_ = value;
+-
++ copyOnWrite();
++ instance.setOsmosisReplicationSequenceNumber(value);
+ return this;
+ }
+ /**
+- * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+- *
+ * <pre>
+ * replication sequence number (sequenceNumber in state.txt)
+ * </pre>
++ *
++ * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
+ */
+ public Builder clearOsmosisReplicationSequenceNumber() {
+- bitField0_ = (bitField0_ & ~0x00000040);
+- osmosisReplicationSequenceNumber_ = 0L;
+-
++ copyOnWrite();
++ instance.clearOsmosisReplicationSequenceNumber();
+ return this;
+ }
+
+- private java.lang.Object osmosisReplicationBaseUrl_ = "";
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public boolean hasOsmosisReplicationBaseUrl() {
+- return ((bitField0_ & 0x00000080) == 0x00000080);
++ return instance.hasOsmosisReplicationBaseUrl();
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public java.lang.String getOsmosisReplicationBaseUrl() {
+- java.lang.Object ref = osmosisReplicationBaseUrl_;
+- if (!(ref instanceof java.lang.String)) {
+- com.google.protobuf.ByteString bs =
+- (com.google.protobuf.ByteString) ref;
+- java.lang.String s = bs.toStringUtf8();
+- if (bs.isValidUtf8()) {
+- osmosisReplicationBaseUrl_ = s;
+- }
+- return s;
+- } else {
+- return (java.lang.String) ref;
+- }
++ return instance.getOsmosisReplicationBaseUrl();
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public com.google.protobuf.ByteString
+ getOsmosisReplicationBaseUrlBytes() {
+- java.lang.Object ref = osmosisReplicationBaseUrl_;
+- if (ref instanceof String) {
+- com.google.protobuf.ByteString b =
+- com.google.protobuf.ByteString.copyFromUtf8(
+- (java.lang.String) ref);
+- osmosisReplicationBaseUrl_ = b;
+- return b;
+- } else {
+- return (com.google.protobuf.ByteString) ref;
+- }
++ return instance.getOsmosisReplicationBaseUrlBytes();
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public Builder setOsmosisReplicationBaseUrl(
+ java.lang.String value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000080;
+- osmosisReplicationBaseUrl_ = value;
+-
++ copyOnWrite();
++ instance.setOsmosisReplicationBaseUrl(value);
+ return this;
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public Builder clearOsmosisReplicationBaseUrl() {
+- bitField0_ = (bitField0_ & ~0x00000080);
+- osmosisReplicationBaseUrl_ = getDefaultInstance().getOsmosisReplicationBaseUrl();
+-
++ copyOnWrite();
++ instance.clearOsmosisReplicationBaseUrl();
+ return this;
+ }
+ /**
+- * <code>optional string osmosis_replication_base_url = 34;</code>
+- *
+ * <pre>
+ * replication base URL (from Osmosis' configuration.txt file)
+ * </pre>
++ *
++ * <code>optional string osmosis_replication_base_url = 34;</code>
+ */
+ public Builder setOsmosisReplicationBaseUrlBytes(
+ com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- bitField0_ |= 0x00000080;
+- osmosisReplicationBaseUrl_ = value;
+-
++ copyOnWrite();
++ instance.setOsmosisReplicationBaseUrlBytes(value);
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.HeaderBlock)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (hasBbox()) {
++ if (!getBbox().isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ requiredFeatures_.makeImmutable();
++ optionalFeatures_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock other = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock) arg1;
++ bbox_ = visitor.visitMessage(bbox_, other.bbox_);
++ requiredFeatures_= visitor.visitList(requiredFeatures_, other.requiredFeatures_);
++ optionalFeatures_= visitor.visitList(optionalFeatures_, other.optionalFeatures_);
++ writingprogram_ = visitor.visitString(
++ hasWritingprogram(), writingprogram_,
++ other.hasWritingprogram(), other.writingprogram_);
++ source_ = visitor.visitString(
++ hasSource(), source_,
++ other.hasSource(), other.source_);
++ osmosisReplicationTimestamp_ = visitor.visitLong(
++ hasOsmosisReplicationTimestamp(), osmosisReplicationTimestamp_,
++ other.hasOsmosisReplicationTimestamp(), other.osmosisReplicationTimestamp_);
++ osmosisReplicationSequenceNumber_ = visitor.visitLong(
++ hasOsmosisReplicationSequenceNumber(), osmosisReplicationSequenceNumber_,
++ other.hasOsmosisReplicationSequenceNumber(), other.osmosisReplicationSequenceNumber_);
++ osmosisReplicationBaseUrl_ = visitor.visitString(
++ hasOsmosisReplicationBaseUrl(), osmosisReplicationBaseUrl_,
++ other.hasOsmosisReplicationBaseUrl(), other.osmosisReplicationBaseUrl_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000001) == 0x00000001)) {
++ subBuilder = bbox_.toBuilder();
++ }
++ bbox_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(bbox_);
++ bbox_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000001;
++ break;
++ }
++ case 34: {
++ String s = input.readString();
++ if (!requiredFeatures_.isModifiable()) {
++ requiredFeatures_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(requiredFeatures_);
++ }
++ requiredFeatures_.add(s);
++ break;
++ }
++ case 42: {
++ String s = input.readString();
++ if (!optionalFeatures_.isModifiable()) {
++ optionalFeatures_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(optionalFeatures_);
++ }
++ optionalFeatures_.add(s);
++ break;
++ }
++ case 130: {
++ String s = input.readString();
++ bitField0_ |= 0x00000002;
++ writingprogram_ = s;
++ break;
++ }
++ case 138: {
++ String s = input.readString();
++ bitField0_ |= 0x00000004;
++ source_ = s;
++ break;
++ }
++ case 256: {
++ bitField0_ |= 0x00000008;
++ osmosisReplicationTimestamp_ = input.readInt64();
++ break;
++ }
++ case 264: {
++ bitField0_ |= 0x00000010;
++ osmosisReplicationSequenceNumber_ = input.readInt64();
++ break;
++ }
++ case 274: {
++ String s = input.readString();
++ bitField0_ |= 0x00000020;
++ osmosisReplicationBaseUrl_ = s;
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
+
++ // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBlock)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new HeaderBlock(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new HeaderBlock();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBlock)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<HeaderBlock> PARSER;
++
++ public static com.google.protobuf.Parser<HeaderBlock> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface HeaderBBoxOrBuilder extends
+@@ -1688,106 +1650,13 @@ public final class Osmformat {
+ /**
+ * Protobuf type {@code OSMPBF.HeaderBBox}
+ */
+- public static final class HeaderBBox extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class HeaderBBox extends
++ com.google.protobuf.GeneratedMessageLite<
++ HeaderBBox, HeaderBBox.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.HeaderBBox)
+ HeaderBBoxOrBuilder {
+- // Use HeaderBBox.newBuilder() to construct.
+- private HeaderBBox(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private HeaderBBox(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final HeaderBBox defaultInstance;
+- public static HeaderBBox getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public HeaderBBox getDefaultInstanceForType() {
+- return defaultInstance;
++ private HeaderBBox() {
+ }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private HeaderBBox(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- left_ = input.readSInt64();
+- break;
+- }
+- case 16: {
+- bitField0_ |= 0x00000002;
+- right_ = input.readSInt64();
+- break;
+- }
+- case 24: {
+- bitField0_ |= 0x00000004;
+- top_ = input.readSInt64();
+- break;
+- }
+- case 32: {
+- bitField0_ |= 0x00000008;
+- bottom_ = input.readSInt64();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<HeaderBBox> PARSER =
+- new com.google.protobuf.AbstractParser<HeaderBBox>() {
+- public HeaderBBox parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new HeaderBBox(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<HeaderBBox> getParserForType() {
+- return PARSER;
+- }
+-
+ private int bitField0_;
+ public static final int LEFT_FIELD_NUMBER = 1;
+ private long left_;
+@@ -1803,6 +1672,20 @@ public final class Osmformat {
+ public long getLeft() {
+ return left_;
+ }
++ /**
++ * <code>required sint64 left = 1;</code>
++ */
++ private void setLeft(long value) {
++ bitField0_ |= 0x00000001;
++ left_ = value;
++ }
++ /**
++ * <code>required sint64 left = 1;</code>
++ */
++ private void clearLeft() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ left_ = 0L;
++ }
+
+ public static final int RIGHT_FIELD_NUMBER = 2;
+ private long right_;
+@@ -1818,6 +1701,20 @@ public final class Osmformat {
+ public long getRight() {
+ return right_;
+ }
++ /**
++ * <code>required sint64 right = 2;</code>
++ */
++ private void setRight(long value) {
++ bitField0_ |= 0x00000002;
++ right_ = value;
++ }
++ /**
++ * <code>required sint64 right = 2;</code>
++ */
++ private void clearRight() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ right_ = 0L;
++ }
+
+ public static final int TOP_FIELD_NUMBER = 3;
+ private long top_;
+@@ -1833,6 +1730,20 @@ public final class Osmformat {
+ public long getTop() {
+ return top_;
+ }
++ /**
++ * <code>required sint64 top = 3;</code>
++ */
++ private void setTop(long value) {
++ bitField0_ |= 0x00000004;
++ top_ = value;
++ }
++ /**
++ * <code>required sint64 top = 3;</code>
++ */
++ private void clearTop() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ top_ = 0L;
++ }
+
+ public static final int BOTTOM_FIELD_NUMBER = 4;
+ private long bottom_;
+@@ -1848,42 +1759,23 @@ public final class Osmformat {
+ public long getBottom() {
+ return bottom_;
+ }
+-
+- private void initFields() {
+- left_ = 0L;
+- right_ = 0L;
+- top_ = 0L;
+- bottom_ = 0L;
++ /**
++ * <code>required sint64 bottom = 4;</code>
++ */
++ private void setBottom(long value) {
++ bitField0_ |= 0x00000008;
++ bottom_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasLeft()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasRight()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasTop()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasBottom()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <code>required sint64 bottom = 4;</code>
++ */
++ private void clearBottom() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ bottom_ = 0L;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeSInt64(1, left_);
+ }
+@@ -1896,10 +1788,9 @@ public final class Osmformat {
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeSInt64(4, bottom_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -1921,346 +1812,363 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeSInt64Size(4, bottom_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.HeaderBBox}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.HeaderBBox)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBoxOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- left_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- right_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- top_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- bottom_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
++ super(DEFAULT_INSTANCE);
+ }
+
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox result = new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.left_ = left_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.right_ = right_;
+- if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.top_ = top_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.bottom_ = bottom_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance()) return this;
+- if (other.hasLeft()) {
+- setLeft(other.getLeft());
+- }
+- if (other.hasRight()) {
+- setRight(other.getRight());
+- }
+- if (other.hasTop()) {
+- setTop(other.getTop());
+- }
+- if (other.hasBottom()) {
+- setBottom(other.getBottom());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasLeft()) {
+-
+- return false;
+- }
+- if (!hasRight()) {
+-
+- return false;
+- }
+- if (!hasTop()) {
+-
+- return false;
+- }
+- if (!hasBottom()) {
+-
+- return false;
+- }
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private long left_ ;
+ /**
+ * <code>required sint64 left = 1;</code>
+ */
+ public boolean hasLeft() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasLeft();
+ }
+ /**
+ * <code>required sint64 left = 1;</code>
+ */
+ public long getLeft() {
+- return left_;
++ return instance.getLeft();
+ }
+ /**
+ * <code>required sint64 left = 1;</code>
+ */
+ public Builder setLeft(long value) {
+- bitField0_ |= 0x00000001;
+- left_ = value;
+-
++ copyOnWrite();
++ instance.setLeft(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 left = 1;</code>
+ */
+ public Builder clearLeft() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- left_ = 0L;
+-
++ copyOnWrite();
++ instance.clearLeft();
+ return this;
+ }
+
+- private long right_ ;
+ /**
+ * <code>required sint64 right = 2;</code>
+ */
+ public boolean hasRight() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasRight();
+ }
+ /**
+ * <code>required sint64 right = 2;</code>
+ */
+ public long getRight() {
+- return right_;
++ return instance.getRight();
+ }
+ /**
+ * <code>required sint64 right = 2;</code>
+ */
+ public Builder setRight(long value) {
+- bitField0_ |= 0x00000002;
+- right_ = value;
+-
++ copyOnWrite();
++ instance.setRight(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 right = 2;</code>
+ */
+ public Builder clearRight() {
+- bitField0_ = (bitField0_ & ~0x00000002);
+- right_ = 0L;
+-
++ copyOnWrite();
++ instance.clearRight();
+ return this;
+ }
+
+- private long top_ ;
+ /**
+ * <code>required sint64 top = 3;</code>
+ */
+ public boolean hasTop() {
+- return ((bitField0_ & 0x00000004) == 0x00000004);
++ return instance.hasTop();
+ }
+ /**
+ * <code>required sint64 top = 3;</code>
+ */
+ public long getTop() {
+- return top_;
++ return instance.getTop();
+ }
+ /**
+ * <code>required sint64 top = 3;</code>
+ */
+ public Builder setTop(long value) {
+- bitField0_ |= 0x00000004;
+- top_ = value;
+-
++ copyOnWrite();
++ instance.setTop(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 top = 3;</code>
+ */
+ public Builder clearTop() {
+- bitField0_ = (bitField0_ & ~0x00000004);
+- top_ = 0L;
+-
++ copyOnWrite();
++ instance.clearTop();
+ return this;
+ }
+
+- private long bottom_ ;
+ /**
+ * <code>required sint64 bottom = 4;</code>
+ */
+ public boolean hasBottom() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasBottom();
+ }
+ /**
+ * <code>required sint64 bottom = 4;</code>
+ */
+ public long getBottom() {
+- return bottom_;
++ return instance.getBottom();
+ }
+ /**
+ * <code>required sint64 bottom = 4;</code>
+ */
+ public Builder setBottom(long value) {
+- bitField0_ |= 0x00000008;
+- bottom_ = value;
+-
++ copyOnWrite();
++ instance.setBottom(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 bottom = 4;</code>
+ */
+ public Builder clearBottom() {
+- bitField0_ = (bitField0_ & ~0x00000008);
+- bottom_ = 0L;
+-
++ copyOnWrite();
++ instance.clearBottom();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.HeaderBBox)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasLeft()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasRight()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasTop()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasBottom()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox other = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox) arg1;
++ left_ = visitor.visitLong(
++ hasLeft(), left_,
++ other.hasLeft(), other.left_);
++ right_ = visitor.visitLong(
++ hasRight(), right_,
++ other.hasRight(), other.right_);
++ top_ = visitor.visitLong(
++ hasTop(), top_,
++ other.hasTop(), other.top_);
++ bottom_ = visitor.visitLong(
++ hasBottom(), bottom_,
++ other.hasBottom(), other.bottom_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ left_ = input.readSInt64();
++ break;
++ }
++ case 16: {
++ bitField0_ |= 0x00000002;
++ right_ = input.readSInt64();
++ break;
++ }
++ case 24: {
++ bitField0_ |= 0x00000004;
++ top_ = input.readSInt64();
++ break;
++ }
++ case 32: {
++ bitField0_ |= 0x00000008;
++ bottom_ = input.readSInt64();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBBox)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new HeaderBBox(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new HeaderBBox();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBBox)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<HeaderBBox> PARSER;
++
++ public static com.google.protobuf.Parser<HeaderBBox> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface PrimitiveBlockOrBuilder extends
+@@ -2291,36 +2199,36 @@ public final class Osmformat {
+ int getPrimitivegroupCount();
+
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ boolean hasGranularity();
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ int getGranularity();
+
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
+- */
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
++ */
+ boolean hasLatOffset();
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ long getLatOffset();
+
+@@ -2334,149 +2242,35 @@ public final class Osmformat {
+ long getLonOffset();
+
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ boolean hasDateGranularity();
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ int getDateGranularity();
+ }
+ /**
+ * Protobuf type {@code OSMPBF.PrimitiveBlock}
+ */
+- public static final class PrimitiveBlock extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class PrimitiveBlock extends
++ com.google.protobuf.GeneratedMessageLite<
++ PrimitiveBlock, PrimitiveBlock.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.PrimitiveBlock)
+ PrimitiveBlockOrBuilder {
+- // Use PrimitiveBlock.newBuilder() to construct.
+- private PrimitiveBlock(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private PrimitiveBlock(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final PrimitiveBlock defaultInstance;
+- public static PrimitiveBlock getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public PrimitiveBlock getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private PrimitiveBlock(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- subBuilder = stringtable_.toBuilder();
+- }
+- stringtable_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(stringtable_);
+- stringtable_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000001;
+- break;
+- }
+- case 18: {
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- primitivegroup_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- primitivegroup_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.PARSER, extensionRegistry));
+- break;
+- }
+- case 136: {
+- bitField0_ |= 0x00000002;
+- granularity_ = input.readInt32();
+- break;
+- }
+- case 144: {
+- bitField0_ |= 0x00000010;
+- dateGranularity_ = input.readInt32();
+- break;
+- }
+- case 152: {
+- bitField0_ |= 0x00000004;
+- latOffset_ = input.readInt64();
+- break;
+- }
+- case 160: {
+- bitField0_ |= 0x00000008;
+- lonOffset_ = input.readInt64();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- primitivegroup_ = java.util.Collections.unmodifiableList(primitivegroup_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<PrimitiveBlock> PARSER =
+- new com.google.protobuf.AbstractParser<PrimitiveBlock>() {
+- public PrimitiveBlock parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new PrimitiveBlock(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<PrimitiveBlock> getParserForType() {
+- return PARSER;
++ private PrimitiveBlock() {
++ primitivegroup_ = emptyProtobufList();
++ granularity_ = 100;
++ dateGranularity_ = 1000;
+ }
+-
+ private int bitField0_;
+ public static final int STRINGTABLE_FIELD_NUMBER = 1;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable stringtable_;
+@@ -2490,11 +2284,48 @@ public final class Osmformat {
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable() {
+- return stringtable_;
++ return stringtable_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance() : stringtable_;
++ }
++ /**
++ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++ */
++ private void setStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ stringtable_ = value;
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++ */
++ private void setStringtable(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder builderForValue) {
++ stringtable_ = builderForValue.build();
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++ */
++ private void mergeStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
++ if (stringtable_ != null &&
++ stringtable_ != org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance()) {
++ stringtable_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.newBuilder(stringtable_).mergeFrom(value).buildPartial();
++ } else {
++ stringtable_ = value;
++ }
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++ */
++ private void clearStringtable() { stringtable_ = null;
++ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+
+ public static final int PRIMITIVEGROUP_FIELD_NUMBER = 2;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_;
++ private com.google.protobuf.Internal.ProtobufList<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_;
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+@@ -2527,52 +2358,181 @@ public final class Osmformat {
+ int index) {
+ return primitivegroup_.get(index);
+ }
++ private void ensurePrimitivegroupIsMutable() {
++ if (!primitivegroup_.isModifiable()) {
++ primitivegroup_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(primitivegroup_);
++ }
++ }
++
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void setPrimitivegroup(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.set(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void setPrimitivegroup(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.set(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void addPrimitivegroup(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.add(value);
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void addPrimitivegroup(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.add(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void addPrimitivegroup(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.add(builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void addPrimitivegroup(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.add(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void addAllPrimitivegroup(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> values) {
++ ensurePrimitivegroupIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, primitivegroup_);
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void clearPrimitivegroup() {
++ primitivegroup_ = emptyProtobufList();
++ }
++ /**
++ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++ */
++ private void removePrimitivegroup(int index) {
++ ensurePrimitivegroupIsMutable();
++ primitivegroup_.remove(index);
++ }
+
+ public static final int GRANULARITY_FIELD_NUMBER = 17;
+ private int granularity_;
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public boolean hasGranularity() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public int getGranularity() {
+ return granularity_;
+ }
++ /**
++ * <pre>
++ * Granularity, units of nanodegrees, used to store coordinates in this block
++ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
++ */
++ private void setGranularity(int value) {
++ bitField0_ |= 0x00000002;
++ granularity_ = value;
++ }
++ /**
++ * <pre>
++ * Granularity, units of nanodegrees, used to store coordinates in this block
++ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
++ */
++ private void clearGranularity() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ granularity_ = 100;
++ }
+
+ public static final int LAT_OFFSET_FIELD_NUMBER = 19;
+ private long latOffset_;
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public boolean hasLatOffset() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public long getLatOffset() {
+ return latOffset_;
+ }
++ /**
++ * <pre>
++ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
++ */
++ private void setLatOffset(long value) {
++ bitField0_ |= 0x00000004;
++ latOffset_ = value;
++ }
++ /**
++ * <pre>
++ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
++ */
++ private void clearLatOffset() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ latOffset_ = 0L;
++ }
+
+ public static final int LON_OFFSET_FIELD_NUMBER = 20;
+ private long lonOffset_;
+@@ -2588,63 +2548,70 @@ public final class Osmformat {
+ public long getLonOffset() {
+ return lonOffset_;
+ }
++ /**
++ * <code>optional int64 lon_offset = 20 [default = 0];</code>
++ */
++ private void setLonOffset(long value) {
++ bitField0_ |= 0x00000008;
++ lonOffset_ = value;
++ }
++ /**
++ * <code>optional int64 lon_offset = 20 [default = 0];</code>
++ */
++ private void clearLonOffset() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ lonOffset_ = 0L;
++ }
+
+ public static final int DATE_GRANULARITY_FIELD_NUMBER = 18;
+ private int dateGranularity_;
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public boolean hasDateGranularity() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public int getDateGranularity() {
+ return dateGranularity_;
+ }
+-
+- private void initFields() {
+- stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+- primitivegroup_ = java.util.Collections.emptyList();
+- granularity_ = 100;
+- latOffset_ = 0L;
+- lonOffset_ = 0L;
+- dateGranularity_ = 1000;
++ /**
++ * <pre>
++ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++ */
++ private void setDateGranularity(int value) {
++ bitField0_ |= 0x00000010;
++ dateGranularity_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasStringtable()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- for (int i = 0; i < getPrimitivegroupCount(); i++) {
+- if (!getPrimitivegroup(i).isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++ */
++ private void clearDateGranularity() {
++ bitField0_ = (bitField0_ & ~0x00000010);
++ dateGranularity_ = 1000;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- output.writeMessage(1, stringtable_);
++ output.writeMessage(1, getStringtable());
+ }
+ for (int i = 0; i < primitivegroup_.size(); i++) {
+ output.writeMessage(2, primitivegroup_.get(i));
+@@ -2661,10 +2628,9 @@ public final class Osmformat {
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeInt64(20, lonOffset_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -2672,7 +2638,7 @@ public final class Osmformat {
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(1, stringtable_);
++ .computeMessageSize(1, getStringtable());
+ }
+ for (int i = 0; i < primitivegroup_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+@@ -2694,327 +2660,163 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt64Size(20, lonOffset_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.PrimitiveBlock}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.PrimitiveBlock)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlockOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
++ super(DEFAULT_INSTANCE);
+ }
+
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- primitivegroup_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- granularity_ = 100;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- latOffset_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- lonOffset_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- dateGranularity_ = 1000;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock result = new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.stringtable_ = stringtable_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- primitivegroup_ = java.util.Collections.unmodifiableList(primitivegroup_);
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.primitivegroup_ = primitivegroup_;
+- if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.granularity_ = granularity_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.latOffset_ = latOffset_;
+- if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.lonOffset_ = lonOffset_;
+- if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+- to_bitField0_ |= 0x00000010;
+- }
+- result.dateGranularity_ = dateGranularity_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.getDefaultInstance()) return this;
+- if (other.hasStringtable()) {
+- mergeStringtable(other.getStringtable());
+- }
+- if (!other.primitivegroup_.isEmpty()) {
+- if (primitivegroup_.isEmpty()) {
+- primitivegroup_ = other.primitivegroup_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.addAll(other.primitivegroup_);
+- }
+-
+- }
+- if (other.hasGranularity()) {
+- setGranularity(other.getGranularity());
+- }
+- if (other.hasLatOffset()) {
+- setLatOffset(other.getLatOffset());
+- }
+- if (other.hasLonOffset()) {
+- setLonOffset(other.getLonOffset());
+- }
+- if (other.hasDateGranularity()) {
+- setDateGranularity(other.getDateGranularity());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasStringtable()) {
+-
+- return false;
+- }
+- for (int i = 0; i < getPrimitivegroupCount(); i++) {
+- if (!getPrimitivegroup(i).isInitialized()) {
+-
+- return false;
+- }
+- }
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public boolean hasStringtable() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasStringtable();
+ }
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable() {
+- return stringtable_;
++ return instance.getStringtable();
+ }
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public Builder setStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- stringtable_ = value;
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.setStringtable(value);
+ return this;
+- }
++ }
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public Builder setStringtable(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder builderForValue) {
+- stringtable_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.setStringtable(builderForValue);
+ return this;
+ }
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+ public Builder mergeStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
+- if (((bitField0_ & 0x00000001) == 0x00000001) &&
+- stringtable_ != org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance()) {
+- stringtable_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.newBuilder(stringtable_).mergeFrom(value).buildPartial();
+- } else {
+- stringtable_ = value;
+- }
+-
+- bitField0_ |= 0x00000001;
++ copyOnWrite();
++ instance.mergeStringtable(value);
+ return this;
+ }
+ /**
+ * <code>required .OSMPBF.StringTable stringtable = 1;</code>
+ */
+- public Builder clearStringtable() {
+- stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000001);
++ public Builder clearStringtable() { copyOnWrite();
++ instance.clearStringtable();
+ return this;
+ }
+
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_ =
+- java.util.Collections.emptyList();
+- private void ensurePrimitivegroupIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- primitivegroup_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup>(primitivegroup_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+-
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> getPrimitivegroupList() {
+- return java.util.Collections.unmodifiableList(primitivegroup_);
++ return java.util.Collections.unmodifiableList(
++ instance.getPrimitivegroupList());
+ }
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public int getPrimitivegroupCount() {
+- return primitivegroup_.size();
+- }
+- /**
++ return instance.getPrimitivegroupCount();
++ }/**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getPrimitivegroup(int index) {
+- return primitivegroup_.get(index);
++ return instance.getPrimitivegroup(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public Builder setPrimitivegroup(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.set(index, value);
+-
++ copyOnWrite();
++ instance.setPrimitivegroup(index, value);
+ return this;
+ }
+ /**
+@@ -3022,21 +2824,16 @@ public final class Osmformat {
+ */
+ public Builder setPrimitivegroup(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.set(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.setPrimitivegroup(index, builderForValue);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public Builder addPrimitivegroup(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.add(value);
+-
++ copyOnWrite();
++ instance.addPrimitivegroup(value);
+ return this;
+ }
+ /**
+@@ -3044,12 +2841,8 @@ public final class Osmformat {
+ */
+ public Builder addPrimitivegroup(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.add(index, value);
+-
++ copyOnWrite();
++ instance.addPrimitivegroup(index, value);
+ return this;
+ }
+ /**
+@@ -3057,9 +2850,8 @@ public final class Osmformat {
+ */
+ public Builder addPrimitivegroup(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.add(builderForValue.build());
+-
++ copyOnWrite();
++ instance.addPrimitivegroup(builderForValue);
+ return this;
+ }
+ /**
+@@ -3067,9 +2859,8 @@ public final class Osmformat {
+ */
+ public Builder addPrimitivegroup(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.add(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.addPrimitivegroup(index, builderForValue);
+ return this;
+ }
+ /**
+@@ -3077,216 +2868,360 @@ public final class Osmformat {
+ */
+ public Builder addAllPrimitivegroup(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> values) {
+- ensurePrimitivegroupIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, primitivegroup_);
+-
++ copyOnWrite();
++ instance.addAllPrimitivegroup(values);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public Builder clearPrimitivegroup() {
+- primitivegroup_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearPrimitivegroup();
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
+ */
+ public Builder removePrimitivegroup(int index) {
+- ensurePrimitivegroupIsMutable();
+- primitivegroup_.remove(index);
+-
++ copyOnWrite();
++ instance.removePrimitivegroup(index);
+ return this;
+ }
+
+- private int granularity_ = 100;
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public boolean hasGranularity() {
+- return ((bitField0_ & 0x00000004) == 0x00000004);
++ return instance.hasGranularity();
+ }
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public int getGranularity() {
+- return granularity_;
++ return instance.getGranularity();
+ }
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public Builder setGranularity(int value) {
+- bitField0_ |= 0x00000004;
+- granularity_ = value;
+-
++ copyOnWrite();
++ instance.setGranularity(value);
+ return this;
+ }
+ /**
+- * <code>optional int32 granularity = 17 [default = 100];</code>
+- *
+ * <pre>
+ * Granularity, units of nanodegrees, used to store coordinates in this block
+ * </pre>
++ *
++ * <code>optional int32 granularity = 17 [default = 100];</code>
+ */
+ public Builder clearGranularity() {
+- bitField0_ = (bitField0_ & ~0x00000004);
+- granularity_ = 100;
+-
++ copyOnWrite();
++ instance.clearGranularity();
+ return this;
+ }
+
+- private long latOffset_ ;
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public boolean hasLatOffset() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasLatOffset();
+ }
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public long getLatOffset() {
+- return latOffset_;
++ return instance.getLatOffset();
+ }
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public Builder setLatOffset(long value) {
+- bitField0_ |= 0x00000008;
+- latOffset_ = value;
+-
++ copyOnWrite();
++ instance.setLatOffset(value);
+ return this;
+ }
+ /**
+- * <code>optional int64 lat_offset = 19 [default = 0];</code>
+- *
+ * <pre>
+ * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+ * </pre>
++ *
++ * <code>optional int64 lat_offset = 19 [default = 0];</code>
+ */
+ public Builder clearLatOffset() {
+- bitField0_ = (bitField0_ & ~0x00000008);
+- latOffset_ = 0L;
+-
++ copyOnWrite();
++ instance.clearLatOffset();
+ return this;
+ }
+
+- private long lonOffset_ ;
+ /**
+ * <code>optional int64 lon_offset = 20 [default = 0];</code>
+ */
+ public boolean hasLonOffset() {
+- return ((bitField0_ & 0x00000010) == 0x00000010);
++ return instance.hasLonOffset();
+ }
+ /**
+ * <code>optional int64 lon_offset = 20 [default = 0];</code>
+ */
+ public long getLonOffset() {
+- return lonOffset_;
++ return instance.getLonOffset();
+ }
+ /**
+ * <code>optional int64 lon_offset = 20 [default = 0];</code>
+ */
+ public Builder setLonOffset(long value) {
+- bitField0_ |= 0x00000010;
+- lonOffset_ = value;
+-
++ copyOnWrite();
++ instance.setLonOffset(value);
+ return this;
+ }
+ /**
+ * <code>optional int64 lon_offset = 20 [default = 0];</code>
+ */
+ public Builder clearLonOffset() {
+- bitField0_ = (bitField0_ & ~0x00000010);
+- lonOffset_ = 0L;
+-
++ copyOnWrite();
++ instance.clearLonOffset();
+ return this;
+ }
+
+- private int dateGranularity_ = 1000;
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public boolean hasDateGranularity() {
+- return ((bitField0_ & 0x00000020) == 0x00000020);
++ return instance.hasDateGranularity();
+ }
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public int getDateGranularity() {
+- return dateGranularity_;
++ return instance.getDateGranularity();
+ }
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public Builder setDateGranularity(int value) {
+- bitField0_ |= 0x00000020;
+- dateGranularity_ = value;
+-
++ copyOnWrite();
++ instance.setDateGranularity(value);
+ return this;
+ }
+ /**
+- * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+- *
+ * <pre>
+ * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+ * </pre>
++ *
++ * <code>optional int32 date_granularity = 18 [default = 1000];</code>
+ */
+ public Builder clearDateGranularity() {
+- bitField0_ = (bitField0_ & ~0x00000020);
+- dateGranularity_ = 1000;
+-
++ copyOnWrite();
++ instance.clearDateGranularity();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.PrimitiveBlock)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasStringtable()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ for (int i = 0; i < getPrimitivegroupCount(); i++) {
++ if (!getPrimitivegroup(i).isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ primitivegroup_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock other = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock) arg1;
++ stringtable_ = visitor.visitMessage(stringtable_, other.stringtable_);
++ primitivegroup_= visitor.visitList(primitivegroup_, other.primitivegroup_);
++ granularity_ = visitor.visitInt(
++ hasGranularity(), granularity_,
++ other.hasGranularity(), other.granularity_);
++ latOffset_ = visitor.visitLong(
++ hasLatOffset(), latOffset_,
++ other.hasLatOffset(), other.latOffset_);
++ lonOffset_ = visitor.visitLong(
++ hasLonOffset(), lonOffset_,
++ other.hasLonOffset(), other.lonOffset_);
++ dateGranularity_ = visitor.visitInt(
++ hasDateGranularity(), dateGranularity_,
++ other.hasDateGranularity(), other.dateGranularity_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000001) == 0x00000001)) {
++ subBuilder = stringtable_.toBuilder();
++ }
++ stringtable_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(stringtable_);
++ stringtable_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000001;
++ break;
++ }
++ case 18: {
++ if (!primitivegroup_.isModifiable()) {
++ primitivegroup_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(primitivegroup_);
++ }
++ primitivegroup_.add(
++ input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.parser(), extensionRegistry));
++ break;
++ }
++ case 136: {
++ bitField0_ |= 0x00000002;
++ granularity_ = input.readInt32();
++ break;
++ }
++ case 144: {
++ bitField0_ |= 0x00000010;
++ dateGranularity_ = input.readInt32();
++ break;
++ }
++ case 152: {
++ bitField0_ |= 0x00000004;
++ latOffset_ = input.readInt64();
++ break;
++ }
++ case 160: {
++ bitField0_ |= 0x00000008;
++ lonOffset_ = input.readInt64();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveBlock)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new PrimitiveBlock(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new PrimitiveBlock();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveBlock)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<PrimitiveBlock> PARSER;
++
++ public static com.google.protobuf.Parser<PrimitiveBlock> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface PrimitiveGroupOrBuilder extends
+@@ -3359,152 +3294,26 @@ public final class Osmformat {
+ int getChangesetsCount();
+ }
+ /**
+- * Protobuf type {@code OSMPBF.PrimitiveGroup}
+- *
+ * <pre>
+ * Group of OSMPrimitives. All primitives in a group must be the same type.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.PrimitiveGroup}
+ */
+- public static final class PrimitiveGroup extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class PrimitiveGroup extends
++ com.google.protobuf.GeneratedMessageLite<
++ PrimitiveGroup, PrimitiveGroup.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.PrimitiveGroup)
+ PrimitiveGroupOrBuilder {
+- // Use PrimitiveGroup.newBuilder() to construct.
+- private PrimitiveGroup(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private PrimitiveGroup(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final PrimitiveGroup defaultInstance;
+- public static PrimitiveGroup getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public PrimitiveGroup getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private PrimitiveGroup(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- nodes_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Node>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- nodes_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Node.PARSER, extensionRegistry));
+- break;
+- }
+- case 18: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- subBuilder = dense_.toBuilder();
+- }
+- dense_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(dense_);
+- dense_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000001;
+- break;
+- }
+- case 26: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- ways_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Way>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- ways_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Way.PARSER, extensionRegistry));
+- break;
+- }
+- case 34: {
+- if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- relations_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation>();
+- mutable_bitField0_ |= 0x00000008;
+- }
+- relations_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.PARSER, extensionRegistry));
+- break;
+- }
+- case 42: {
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- changesets_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- changesets_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.PARSER, extensionRegistry));
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- nodes_ = java.util.Collections.unmodifiableList(nodes_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- ways_ = java.util.Collections.unmodifiableList(ways_);
+- }
+- if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- relations_ = java.util.Collections.unmodifiableList(relations_);
+- }
+- if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- changesets_ = java.util.Collections.unmodifiableList(changesets_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<PrimitiveGroup> PARSER =
+- new com.google.protobuf.AbstractParser<PrimitiveGroup>() {
+- public PrimitiveGroup parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new PrimitiveGroup(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<PrimitiveGroup> getParserForType() {
+- return PARSER;
++ private PrimitiveGroup() {
++ nodes_ = emptyProtobufList();
++ ways_ = emptyProtobufList();
++ relations_ = emptyProtobufList();
++ changesets_ = emptyProtobufList();
+ }
+-
+ private int bitField0_;
+ public static final int NODES_FIELD_NUMBER = 1;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> nodes_;
++ private com.google.protobuf.Internal.ProtobufList<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> nodes_;
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+@@ -3537,6 +3346,91 @@ public final class Osmformat {
+ int index) {
+ return nodes_.get(index);
+ }
++ private void ensureNodesIsMutable() {
++ if (!nodes_.isModifiable()) {
++ nodes_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(nodes_);
++ }
++ }
++
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void setNodes(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureNodesIsMutable();
++ nodes_.set(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void setNodes(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
++ ensureNodesIsMutable();
++ nodes_.set(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void addNodes(org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureNodesIsMutable();
++ nodes_.add(value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void addNodes(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureNodesIsMutable();
++ nodes_.add(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void addNodes(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
++ ensureNodesIsMutable();
++ nodes_.add(builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void addNodes(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
++ ensureNodesIsMutable();
++ nodes_.add(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void addAllNodes(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Node> values) {
++ ensureNodesIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, nodes_);
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void clearNodes() {
++ nodes_ = emptyProtobufList();
++ }
++ /**
++ * <code>repeated .OSMPBF.Node nodes = 1;</code>
++ */
++ private void removeNodes(int index) {
++ ensureNodesIsMutable();
++ nodes_.remove(index);
++ }
+
+ public static final int DENSE_FIELD_NUMBER = 2;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes dense_;
+@@ -3550,11 +3444,48 @@ public final class Osmformat {
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDense() {
+- return dense_;
++ return dense_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance() : dense_;
++ }
++ /**
++ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++ */
++ private void setDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ dense_ = value;
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++ */
++ private void setDense(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder builderForValue) {
++ dense_ = builderForValue.build();
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++ */
++ private void mergeDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
++ if (dense_ != null &&
++ dense_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance()) {
++ dense_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.newBuilder(dense_).mergeFrom(value).buildPartial();
++ } else {
++ dense_ = value;
++ }
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++ */
++ private void clearDense() { dense_ = null;
++ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+
+ public static final int WAYS_FIELD_NUMBER = 3;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> ways_;
++ private com.google.protobuf.Internal.ProtobufList<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> ways_;
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+@@ -3587,9 +3518,94 @@ public final class Osmformat {
+ int index) {
+ return ways_.get(index);
+ }
++ private void ensureWaysIsMutable() {
++ if (!ways_.isModifiable()) {
++ ways_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(ways_);
++ }
++ }
++
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void setWays(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureWaysIsMutable();
++ ways_.set(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void setWays(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
++ ensureWaysIsMutable();
++ ways_.set(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void addWays(org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureWaysIsMutable();
++ ways_.add(value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void addWays(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureWaysIsMutable();
++ ways_.add(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void addWays(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
++ ensureWaysIsMutable();
++ ways_.add(builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void addWays(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
++ ensureWaysIsMutable();
++ ways_.add(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void addAllWays(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Way> values) {
++ ensureWaysIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, ways_);
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void clearWays() {
++ ways_ = emptyProtobufList();
++ }
++ /**
++ * <code>repeated .OSMPBF.Way ways = 3;</code>
++ */
++ private void removeWays(int index) {
++ ensureWaysIsMutable();
++ ways_.remove(index);
++ }
+
+ public static final int RELATIONS_FIELD_NUMBER = 4;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> relations_;
++ private com.google.protobuf.Internal.ProtobufList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> relations_;
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+@@ -3622,91 +3638,219 @@ public final class Osmformat {
+ int index) {
+ return relations_.get(index);
+ }
++ private void ensureRelationsIsMutable() {
++ if (!relations_.isModifiable()) {
++ relations_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(relations_);
++ }
++ }
+
+- public static final int CHANGESETS_FIELD_NUMBER = 5;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> changesets_;
+ /**
+- * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+- public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> getChangesetsList() {
+- return changesets_;
++ private void setRelations(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRelationsIsMutable();
++ relations_.set(index, value);
+ }
+ /**
+- * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+- public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder>
+- getChangesetsOrBuilderList() {
+- return changesets_;
++ private void setRelations(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
++ ensureRelationsIsMutable();
++ relations_.set(index, builderForValue.build());
+ }
+ /**
+- * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+- public int getChangesetsCount() {
+- return changesets_.size();
++ private void addRelations(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRelationsIsMutable();
++ relations_.add(value);
+ }
+ /**
+- * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index) {
+- return changesets_.get(index);
++ private void addRelations(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureRelationsIsMutable();
++ relations_.add(index, value);
+ }
+ /**
+- * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder getChangesetsOrBuilder(
+- int index) {
+- return changesets_.get(index);
++ private void addRelations(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
++ ensureRelationsIsMutable();
++ relations_.add(builderForValue.build());
+ }
+-
+- private void initFields() {
+- nodes_ = java.util.Collections.emptyList();
+- dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+- ways_ = java.util.Collections.emptyList();
+- relations_ = java.util.Collections.emptyList();
+- changesets_ = java.util.Collections.emptyList();
++ /**
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
++ */
++ private void addRelations(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
++ ensureRelationsIsMutable();
++ relations_.add(index, builderForValue.build());
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- for (int i = 0; i < getNodesCount(); i++) {
+- if (!getNodes(i).isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- }
+- for (int i = 0; i < getWaysCount(); i++) {
+- if (!getWays(i).isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- }
+- for (int i = 0; i < getRelationsCount(); i++) {
+- if (!getRelations(i).isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
++ /**
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
++ */
++ private void addAllRelations(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> values) {
++ ensureRelationsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, relations_);
++ }
++ /**
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
++ */
++ private void clearRelations() {
++ relations_ = emptyProtobufList();
++ }
++ /**
++ * <code>repeated .OSMPBF.Relation relations = 4;</code>
++ */
++ private void removeRelations(int index) {
++ ensureRelationsIsMutable();
++ relations_.remove(index);
++ }
++
++ public static final int CHANGESETS_FIELD_NUMBER = 5;
++ private com.google.protobuf.Internal.ProtobufList<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> changesets_;
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> getChangesetsList() {
++ return changesets_;
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder>
++ getChangesetsOrBuilderList() {
++ return changesets_;
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ public int getChangesetsCount() {
++ return changesets_.size();
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index) {
++ return changesets_.get(index);
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder getChangesetsOrBuilder(
++ int index) {
++ return changesets_.get(index);
++ }
++ private void ensureChangesetsIsMutable() {
++ if (!changesets_.isModifiable()) {
++ changesets_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(changesets_);
++ }
++ }
++
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void setChangesets(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
++ if (value == null) {
++ throw new NullPointerException();
+ }
+- for (int i = 0; i < getChangesetsCount(); i++) {
+- if (!getChangesets(i).isInitialized()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
++ ensureChangesetsIsMutable();
++ changesets_.set(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void setChangesets(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
++ ensureChangesetsIsMutable();
++ changesets_.set(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void addChangesets(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureChangesetsIsMutable();
++ changesets_.add(value);
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void addChangesets(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
++ if (value == null) {
++ throw new NullPointerException();
+ }
+- memoizedIsInitialized = 1;
+- return true;
++ ensureChangesetsIsMutable();
++ changesets_.add(index, value);
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void addChangesets(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
++ ensureChangesetsIsMutable();
++ changesets_.add(builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void addChangesets(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
++ ensureChangesetsIsMutable();
++ changesets_.add(index, builderForValue.build());
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void addAllChangesets(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> values) {
++ ensureChangesetsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, changesets_);
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void clearChangesets() {
++ changesets_ = emptyProtobufList();
++ }
++ /**
++ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++ */
++ private void removeChangesets(int index) {
++ ensureChangesetsIsMutable();
++ changesets_.remove(index);
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ for (int i = 0; i < nodes_.size(); i++) {
+ output.writeMessage(1, nodes_.get(i));
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- output.writeMessage(2, dense_);
++ output.writeMessage(2, getDense());
+ }
+ for (int i = 0; i < ways_.size(); i++) {
+ output.writeMessage(3, ways_.get(i));
+@@ -3717,10 +3861,9 @@ public final class Osmformat {
+ for (int i = 0; i < changesets_.size(); i++) {
+ output.writeMessage(5, changesets_.get(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -3732,7 +3875,7 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(2, dense_);
++ .computeMessageSize(2, getDense());
+ }
+ for (int i = 0; i < ways_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+@@ -3746,300 +3889,122 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(5, changesets_.get(i));
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+- * Protobuf type {@code OSMPBF.PrimitiveGroup}
+- *
+ * <pre>
+ * Group of OSMPrimitives. All primitives in a group must be the same type.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.PrimitiveGroup}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.PrimitiveGroup)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroupOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- nodes_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- ways_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- relations_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- changesets_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup result = new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- nodes_ = java.util.Collections.unmodifiableList(nodes_);
+- bitField0_ = (bitField0_ & ~0x00000001);
+- }
+- result.nodes_ = nodes_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.dense_ = dense_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- ways_ = java.util.Collections.unmodifiableList(ways_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.ways_ = ways_;
+- if (((bitField0_ & 0x00000008) == 0x00000008)) {
+- relations_ = java.util.Collections.unmodifiableList(relations_);
+- bitField0_ = (bitField0_ & ~0x00000008);
+- }
+- result.relations_ = relations_;
+- if (((bitField0_ & 0x00000010) == 0x00000010)) {
+- changesets_ = java.util.Collections.unmodifiableList(changesets_);
+- bitField0_ = (bitField0_ & ~0x00000010);
+- }
+- result.changesets_ = changesets_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.getDefaultInstance()) return this;
+- if (!other.nodes_.isEmpty()) {
+- if (nodes_.isEmpty()) {
+- nodes_ = other.nodes_;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- } else {
+- ensureNodesIsMutable();
+- nodes_.addAll(other.nodes_);
+- }
+-
+- }
+- if (other.hasDense()) {
+- mergeDense(other.getDense());
+- }
+- if (!other.ways_.isEmpty()) {
+- if (ways_.isEmpty()) {
+- ways_ = other.ways_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureWaysIsMutable();
+- ways_.addAll(other.ways_);
+- }
+-
+- }
+- if (!other.relations_.isEmpty()) {
+- if (relations_.isEmpty()) {
+- relations_ = other.relations_;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- } else {
+- ensureRelationsIsMutable();
+- relations_.addAll(other.relations_);
+- }
+-
+- }
+- if (!other.changesets_.isEmpty()) {
+- if (changesets_.isEmpty()) {
+- changesets_ = other.changesets_;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- } else {
+- ensureChangesetsIsMutable();
+- changesets_.addAll(other.changesets_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- for (int i = 0; i < getNodesCount(); i++) {
+- if (!getNodes(i).isInitialized()) {
+-
+- return false;
+- }
+- }
+- for (int i = 0; i < getWaysCount(); i++) {
+- if (!getWays(i).isInitialized()) {
+-
+- return false;
+- }
+- }
+- for (int i = 0; i < getRelationsCount(); i++) {
+- if (!getRelations(i).isInitialized()) {
+-
+- return false;
+- }
+- }
+- for (int i = 0; i < getChangesetsCount(); i++) {
+- if (!getChangesets(i).isInitialized()) {
+-
+- return false;
+- }
+- }
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+-
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> nodes_ =
+- java.util.Collections.emptyList();
+- private void ensureNodesIsMutable() {
+- if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+- nodes_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Node>(nodes_);
+- bitField0_ |= 0x00000001;
+- }
+- }
+
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> getNodesList() {
+- return java.util.Collections.unmodifiableList(nodes_);
++ return java.util.Collections.unmodifiableList(
++ instance.getNodesList());
+ }
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public int getNodesCount() {
+- return nodes_.size();
+- }
+- /**
++ return instance.getNodesCount();
++ }/**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Node getNodes(int index) {
+- return nodes_.get(index);
++ return instance.getNodes(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public Builder setNodes(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureNodesIsMutable();
+- nodes_.set(index, value);
+-
++ copyOnWrite();
++ instance.setNodes(index, value);
+ return this;
+ }
+ /**
+@@ -4047,21 +4012,16 @@ public final class Osmformat {
+ */
+ public Builder setNodes(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+- ensureNodesIsMutable();
+- nodes_.set(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.setNodes(index, builderForValue);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public Builder addNodes(org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureNodesIsMutable();
+- nodes_.add(value);
+-
++ copyOnWrite();
++ instance.addNodes(value);
+ return this;
+ }
+ /**
+@@ -4069,12 +4029,8 @@ public final class Osmformat {
+ */
+ public Builder addNodes(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureNodesIsMutable();
+- nodes_.add(index, value);
+-
++ copyOnWrite();
++ instance.addNodes(index, value);
+ return this;
+ }
+ /**
+@@ -4082,9 +4038,8 @@ public final class Osmformat {
+ */
+ public Builder addNodes(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+- ensureNodesIsMutable();
+- nodes_.add(builderForValue.build());
+-
++ copyOnWrite();
++ instance.addNodes(builderForValue);
+ return this;
+ }
+ /**
+@@ -4092,9 +4047,8 @@ public final class Osmformat {
+ */
+ public Builder addNodes(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+- ensureNodesIsMutable();
+- nodes_.add(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.addNodes(index, builderForValue);
+ return this;
+ }
+ /**
+@@ -4102,129 +4056,97 @@ public final class Osmformat {
+ */
+ public Builder addAllNodes(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Node> values) {
+- ensureNodesIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, nodes_);
+-
++ copyOnWrite();
++ instance.addAllNodes(values);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public Builder clearNodes() {
+- nodes_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+-
++ copyOnWrite();
++ instance.clearNodes();
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Node nodes = 1;</code>
+ */
+ public Builder removeNodes(int index) {
+- ensureNodesIsMutable();
+- nodes_.remove(index);
+-
++ copyOnWrite();
++ instance.removeNodes(index);
+ return this;
+ }
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public boolean hasDense() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasDense();
+ }
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDense() {
+- return dense_;
++ return instance.getDense();
+ }
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public Builder setDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- dense_ = value;
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.setDense(value);
+ return this;
+- }
++ }
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public Builder setDense(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder builderForValue) {
+- dense_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.setDense(builderForValue);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+ public Builder mergeDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
+- if (((bitField0_ & 0x00000002) == 0x00000002) &&
+- dense_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance()) {
+- dense_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.newBuilder(dense_).mergeFrom(value).buildPartial();
+- } else {
+- dense_ = value;
+- }
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.mergeDense(value);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
+ */
+- public Builder clearDense() {
+- dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000002);
++ public Builder clearDense() { copyOnWrite();
++ instance.clearDense();
+ return this;
+ }
+
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> ways_ =
+- java.util.Collections.emptyList();
+- private void ensureWaysIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- ways_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Way>(ways_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+-
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> getWaysList() {
+- return java.util.Collections.unmodifiableList(ways_);
++ return java.util.Collections.unmodifiableList(
++ instance.getWaysList());
+ }
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public int getWaysCount() {
+- return ways_.size();
+- }
+- /**
++ return instance.getWaysCount();
++ }/**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Way getWays(int index) {
+- return ways_.get(index);
++ return instance.getWays(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public Builder setWays(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureWaysIsMutable();
+- ways_.set(index, value);
+-
++ copyOnWrite();
++ instance.setWays(index, value);
+ return this;
+ }
+ /**
+@@ -4232,21 +4154,16 @@ public final class Osmformat {
+ */
+ public Builder setWays(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+- ensureWaysIsMutable();
+- ways_.set(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.setWays(index, builderForValue);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public Builder addWays(org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureWaysIsMutable();
+- ways_.add(value);
+-
++ copyOnWrite();
++ instance.addWays(value);
+ return this;
+ }
+ /**
+@@ -4254,12 +4171,8 @@ public final class Osmformat {
+ */
+ public Builder addWays(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureWaysIsMutable();
+- ways_.add(index, value);
+-
++ copyOnWrite();
++ instance.addWays(index, value);
+ return this;
+ }
+ /**
+@@ -4267,9 +4180,8 @@ public final class Osmformat {
+ */
+ public Builder addWays(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+- ensureWaysIsMutable();
+- ways_.add(builderForValue.build());
+-
++ copyOnWrite();
++ instance.addWays(builderForValue);
+ return this;
+ }
+ /**
+@@ -4277,9 +4189,8 @@ public final class Osmformat {
+ */
+ public Builder addWays(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+- ensureWaysIsMutable();
+- ways_.add(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.addWays(index, builderForValue);
+ return this;
+ }
+ /**
+@@ -4287,69 +4198,52 @@ public final class Osmformat {
+ */
+ public Builder addAllWays(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Way> values) {
+- ensureWaysIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, ways_);
+-
++ copyOnWrite();
++ instance.addAllWays(values);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public Builder clearWays() {
+- ways_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearWays();
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Way ways = 3;</code>
+ */
+ public Builder removeWays(int index) {
+- ensureWaysIsMutable();
+- ways_.remove(index);
+-
++ copyOnWrite();
++ instance.removeWays(index);
+ return this;
+ }
+
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> relations_ =
+- java.util.Collections.emptyList();
+- private void ensureRelationsIsMutable() {
+- if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+- relations_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation>(relations_);
+- bitField0_ |= 0x00000008;
+- }
+- }
+-
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> getRelationsList() {
+- return java.util.Collections.unmodifiableList(relations_);
++ return java.util.Collections.unmodifiableList(
++ instance.getRelationsList());
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public int getRelationsCount() {
+- return relations_.size();
+- }
+- /**
++ return instance.getRelationsCount();
++ }/**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getRelations(int index) {
+- return relations_.get(index);
++ return instance.getRelations(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public Builder setRelations(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRelationsIsMutable();
+- relations_.set(index, value);
+-
++ copyOnWrite();
++ instance.setRelations(index, value);
+ return this;
+ }
+ /**
+@@ -4357,21 +4251,16 @@ public final class Osmformat {
+ */
+ public Builder setRelations(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+- ensureRelationsIsMutable();
+- relations_.set(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.setRelations(index, builderForValue);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public Builder addRelations(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRelationsIsMutable();
+- relations_.add(value);
+-
++ copyOnWrite();
++ instance.addRelations(value);
+ return this;
+ }
+ /**
+@@ -4379,12 +4268,8 @@ public final class Osmformat {
+ */
+ public Builder addRelations(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureRelationsIsMutable();
+- relations_.add(index, value);
+-
++ copyOnWrite();
++ instance.addRelations(index, value);
+ return this;
+ }
+ /**
+@@ -4392,9 +4277,8 @@ public final class Osmformat {
+ */
+ public Builder addRelations(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+- ensureRelationsIsMutable();
+- relations_.add(builderForValue.build());
+-
++ copyOnWrite();
++ instance.addRelations(builderForValue);
+ return this;
+ }
+ /**
+@@ -4402,9 +4286,8 @@ public final class Osmformat {
+ */
+ public Builder addRelations(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+- ensureRelationsIsMutable();
+- relations_.add(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.addRelations(index, builderForValue);
+ return this;
+ }
+ /**
+@@ -4412,69 +4295,52 @@ public final class Osmformat {
+ */
+ public Builder addAllRelations(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> values) {
+- ensureRelationsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, relations_);
+-
++ copyOnWrite();
++ instance.addAllRelations(values);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public Builder clearRelations() {
+- relations_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+-
++ copyOnWrite();
++ instance.clearRelations();
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation relations = 4;</code>
+ */
+ public Builder removeRelations(int index) {
+- ensureRelationsIsMutable();
+- relations_.remove(index);
+-
++ copyOnWrite();
++ instance.removeRelations(index);
+ return this;
+ }
+
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> changesets_ =
+- java.util.Collections.emptyList();
+- private void ensureChangesetsIsMutable() {
+- if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+- changesets_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet>(changesets_);
+- bitField0_ |= 0x00000010;
+- }
+- }
+-
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> getChangesetsList() {
+- return java.util.Collections.unmodifiableList(changesets_);
++ return java.util.Collections.unmodifiableList(
++ instance.getChangesetsList());
+ }
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public int getChangesetsCount() {
+- return changesets_.size();
+- }
+- /**
++ return instance.getChangesetsCount();
++ }/**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index) {
+- return changesets_.get(index);
++ return instance.getChangesets(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public Builder setChangesets(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureChangesetsIsMutable();
+- changesets_.set(index, value);
+-
++ copyOnWrite();
++ instance.setChangesets(index, value);
+ return this;
+ }
+ /**
+@@ -4482,21 +4348,16 @@ public final class Osmformat {
+ */
+ public Builder setChangesets(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+- ensureChangesetsIsMutable();
+- changesets_.set(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.setChangesets(index, builderForValue);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public Builder addChangesets(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureChangesetsIsMutable();
+- changesets_.add(value);
+-
++ copyOnWrite();
++ instance.addChangesets(value);
+ return this;
+ }
+ /**
+@@ -4504,12 +4365,8 @@ public final class Osmformat {
+ */
+ public Builder addChangesets(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureChangesetsIsMutable();
+- changesets_.add(index, value);
+-
++ copyOnWrite();
++ instance.addChangesets(index, value);
+ return this;
+ }
+ /**
+@@ -4517,9 +4374,8 @@ public final class Osmformat {
+ */
+ public Builder addChangesets(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+- ensureChangesetsIsMutable();
+- changesets_.add(builderForValue.build());
+-
++ copyOnWrite();
++ instance.addChangesets(builderForValue);
+ return this;
+ }
+ /**
+@@ -4527,9 +4383,8 @@ public final class Osmformat {
+ */
+ public Builder addChangesets(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+- ensureChangesetsIsMutable();
+- changesets_.add(index, builderForValue.build());
+-
++ copyOnWrite();
++ instance.addChangesets(index, builderForValue);
+ return this;
+ }
+ /**
+@@ -4537,40 +4392,215 @@ public final class Osmformat {
+ */
+ public Builder addAllChangesets(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> values) {
+- ensureChangesetsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, changesets_);
+-
++ copyOnWrite();
++ instance.addAllChangesets(values);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public Builder clearChangesets() {
+- changesets_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+-
++ copyOnWrite();
++ instance.clearChangesets();
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
+ */
+ public Builder removeChangesets(int index) {
+- ensureChangesetsIsMutable();
+- changesets_.remove(index);
+-
++ copyOnWrite();
++ instance.removeChangesets(index);
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.PrimitiveGroup)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ for (int i = 0; i < getNodesCount(); i++) {
++ if (!getNodes(i).isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ for (int i = 0; i < getWaysCount(); i++) {
++ if (!getWays(i).isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ for (int i = 0; i < getRelationsCount(); i++) {
++ if (!getRelations(i).isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ for (int i = 0; i < getChangesetsCount(); i++) {
++ if (!getChangesets(i).isInitialized()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ nodes_.makeImmutable();
++ ways_.makeImmutable();
++ relations_.makeImmutable();
++ changesets_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup other = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup) arg1;
++ nodes_= visitor.visitList(nodes_, other.nodes_);
++ dense_ = visitor.visitMessage(dense_, other.dense_);
++ ways_= visitor.visitList(ways_, other.ways_);
++ relations_= visitor.visitList(relations_, other.relations_);
++ changesets_= visitor.visitList(changesets_, other.changesets_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ if (!nodes_.isModifiable()) {
++ nodes_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(nodes_);
++ }
++ nodes_.add(
++ input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Node.parser(), extensionRegistry));
++ break;
++ }
++ case 18: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000001) == 0x00000001)) {
++ subBuilder = dense_.toBuilder();
++ }
++ dense_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(dense_);
++ dense_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000001;
++ break;
++ }
++ case 26: {
++ if (!ways_.isModifiable()) {
++ ways_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(ways_);
++ }
++ ways_.add(
++ input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Way.parser(), extensionRegistry));
++ break;
++ }
++ case 34: {
++ if (!relations_.isModifiable()) {
++ relations_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(relations_);
++ }
++ relations_.add(
++ input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.parser(), extensionRegistry));
++ break;
++ }
++ case 42: {
++ if (!changesets_.isModifiable()) {
++ changesets_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(changesets_);
++ }
++ changesets_.add(
++ input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.parser(), extensionRegistry));
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveGroup)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new PrimitiveGroup(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new PrimitiveGroup();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveGroup)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<PrimitiveGroup> PARSER;
++
++ public static com.google.protobuf.Parser<PrimitiveGroup> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface StringTableOrBuilder extends
+@@ -4591,107 +4621,24 @@ public final class Osmformat {
+ com.google.protobuf.ByteString getS(int index);
+ }
+ /**
+- * Protobuf type {@code OSMPBF.StringTable}
+- *
+ * <pre>
+ ** String table, contains the common strings in each block.
+ *Note that we reserve index '0' as a delimiter, so the entry at that
+ *index in the table is ALWAYS blank and unused.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.StringTable}
+ */
+- public static final class StringTable extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class StringTable extends
++ com.google.protobuf.GeneratedMessageLite<
++ StringTable, StringTable.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.StringTable)
+ StringTableOrBuilder {
+- // Use StringTable.newBuilder() to construct.
+- private StringTable(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private StringTable(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final StringTable defaultInstance;
+- public static StringTable getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public StringTable getDefaultInstanceForType() {
+- return defaultInstance;
++ private StringTable() {
++ s_ = emptyProtobufList();
+ }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private StringTable(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 10: {
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- s_ = new java.util.ArrayList<com.google.protobuf.ByteString>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- s_.add(input.readBytes());
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- s_ = java.util.Collections.unmodifiableList(s_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<StringTable> PARSER =
+- new com.google.protobuf.AbstractParser<StringTable>() {
+- public StringTable parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new StringTable(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<StringTable> getParserForType() {
+- return PARSER;
+- }
+-
+ public static final int S_FIELD_NUMBER = 1;
+- private java.util.List<com.google.protobuf.ByteString> s_;
++ private com.google.protobuf.Internal.ProtobufList<com.google.protobuf.ByteString> s_;
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+@@ -4711,30 +4658,57 @@ public final class Osmformat {
+ public com.google.protobuf.ByteString getS(int index) {
+ return s_.get(index);
+ }
+-
+- private void initFields() {
+- s_ = java.util.Collections.emptyList();
++ private void ensureSIsMutable() {
++ if (!s_.isModifiable()) {
++ s_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(s_);
++ }
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <code>repeated bytes s = 1;</code>
++ */
++ private void setS(
++ int index, com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureSIsMutable();
++ s_.set(index, value);
++ }
++ /**
++ * <code>repeated bytes s = 1;</code>
++ */
++ private void addS(com.google.protobuf.ByteString value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureSIsMutable();
++ s_.add(value);
++ }
++ /**
++ * <code>repeated bytes s = 1;</code>
++ */
++ private void addAllS(
++ java.lang.Iterable<? extends com.google.protobuf.ByteString> values) {
++ ensureSIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, s_);
++ }
++ /**
++ * <code>repeated bytes s = 1;</code>
++ */
++ private void clearS() {
++ s_ = emptyProtobufList();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ for (int i = 0; i < s_.size(); i++) {
+ output.writeBytes(1, s_.get(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -4749,227 +4723,134 @@ public final class Osmformat {
+ size += dataSize;
+ size += 1 * getSList().size();
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+- * Protobuf type {@code OSMPBF.StringTable}
+- *
+ * <pre>
+ ** String table, contains the common strings in each block.
+ *Note that we reserve index '0' as a delimiter, so the entry at that
+ *index in the table is ALWAYS blank and unused.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.StringTable}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.StringTable)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTableOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- s_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable result = new org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable(this);
+- int from_bitField0_ = bitField0_;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- s_ = java.util.Collections.unmodifiableList(s_);
+- bitField0_ = (bitField0_ & ~0x00000001);
+- }
+- result.s_ = s_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance()) return this;
+- if (!other.s_.isEmpty()) {
+- if (s_.isEmpty()) {
+- s_ = other.s_;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- } else {
+- ensureSIsMutable();
+- s_.addAll(other.s_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private java.util.List<com.google.protobuf.ByteString> s_ = java.util.Collections.emptyList();
+- private void ensureSIsMutable() {
+- if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+- s_ = new java.util.ArrayList<com.google.protobuf.ByteString>(s_);
+- bitField0_ |= 0x00000001;
+- }
+- }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public java.util.List<com.google.protobuf.ByteString>
+ getSList() {
+- return java.util.Collections.unmodifiableList(s_);
++ return java.util.Collections.unmodifiableList(
++ instance.getSList());
+ }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public int getSCount() {
+- return s_.size();
++ return instance.getSCount();
+ }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public com.google.protobuf.ByteString getS(int index) {
+- return s_.get(index);
++ return instance.getS(index);
+ }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public Builder setS(
+ int index, com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureSIsMutable();
+- s_.set(index, value);
+-
++ copyOnWrite();
++ instance.setS(index, value);
+ return this;
+ }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public Builder addS(com.google.protobuf.ByteString value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureSIsMutable();
+- s_.add(value);
+-
++ copyOnWrite();
++ instance.addS(value);
+ return this;
+ }
+ /**
+@@ -4977,31 +4858,118 @@ public final class Osmformat {
+ */
+ public Builder addAllS(
+ java.lang.Iterable<? extends com.google.protobuf.ByteString> values) {
+- ensureSIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, s_);
+-
++ copyOnWrite();
++ instance.addAllS(values);
+ return this;
+ }
+ /**
+ * <code>repeated bytes s = 1;</code>
+ */
+ public Builder clearS() {
+- s_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+-
++ copyOnWrite();
++ instance.clearS();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.StringTable)
+ }
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable();
++ }
++ case IS_INITIALIZED: {
++ return DEFAULT_INSTANCE;
++ }
++ case MAKE_IMMUTABLE: {
++ s_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable other = (org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable) arg1;
++ s_= visitor.visitList(s_, other.s_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 10: {
++ if (!s_.isModifiable()) {
++ s_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(s_);
++ }
++ s_.add(input.readBytes());
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.StringTable)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new StringTable(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new StringTable();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.StringTable)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<StringTable> PARSER;
++
++ public static com.google.protobuf.Parser<StringTable> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface InfoOrBuilder extends
+@@ -5045,25 +5013,23 @@ public final class Osmformat {
+ int getUid();
+
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ boolean hasUserSid();
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ int getUserSid();
+
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5074,11 +5040,11 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ boolean hasVisible();
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5089,126 +5055,26 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ boolean getVisible();
+ }
+ /**
+- * Protobuf type {@code OSMPBF.Info}
+- *
+ * <pre>
+ * Optional metadata that may be included into each primitive.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.Info}
+ */
+- public static final class Info extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class Info extends
++ com.google.protobuf.GeneratedMessageLite<
++ Info, Info.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.Info)
+ InfoOrBuilder {
+- // Use Info.newBuilder() to construct.
+- private Info(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private Info(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final Info defaultInstance;
+- public static Info getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public Info getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private Info(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- version_ = input.readInt32();
+- break;
+- }
+- case 16: {
+- bitField0_ |= 0x00000002;
+- timestamp_ = input.readInt64();
+- break;
+- }
+- case 24: {
+- bitField0_ |= 0x00000004;
+- changeset_ = input.readInt64();
+- break;
+- }
+- case 32: {
+- bitField0_ |= 0x00000008;
+- uid_ = input.readInt32();
+- break;
+- }
+- case 40: {
+- bitField0_ |= 0x00000010;
+- userSid_ = input.readUInt32();
+- break;
+- }
+- case 48: {
+- bitField0_ |= 0x00000020;
+- visible_ = input.readBool();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<Info> PARSER =
+- new com.google.protobuf.AbstractParser<Info>() {
+- public Info parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new Info(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<Info> getParserForType() {
+- return PARSER;
++ private Info() {
++ version_ = -1;
+ }
+-
+ private int bitField0_;
+ public static final int VERSION_FIELD_NUMBER = 1;
+ private int version_;
+@@ -5224,6 +5090,20 @@ public final class Osmformat {
+ public int getVersion() {
+ return version_;
+ }
++ /**
++ * <code>optional int32 version = 1 [default = -1];</code>
++ */
++ private void setVersion(int value) {
++ bitField0_ |= 0x00000001;
++ version_ = value;
++ }
++ /**
++ * <code>optional int32 version = 1 [default = -1];</code>
++ */
++ private void clearVersion() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ version_ = -1;
++ }
+
+ public static final int TIMESTAMP_FIELD_NUMBER = 2;
+ private long timestamp_;
+@@ -5239,6 +5119,20 @@ public final class Osmformat {
+ public long getTimestamp() {
+ return timestamp_;
+ }
++ /**
++ * <code>optional int64 timestamp = 2;</code>
++ */
++ private void setTimestamp(long value) {
++ bitField0_ |= 0x00000002;
++ timestamp_ = value;
++ }
++ /**
++ * <code>optional int64 timestamp = 2;</code>
++ */
++ private void clearTimestamp() {
++ bitField0_ = (bitField0_ & ~0x00000002);
++ timestamp_ = 0L;
++ }
+
+ public static final int CHANGESET_FIELD_NUMBER = 3;
+ private long changeset_;
+@@ -5254,6 +5148,20 @@ public final class Osmformat {
+ public long getChangeset() {
+ return changeset_;
+ }
++ /**
++ * <code>optional int64 changeset = 3;</code>
++ */
++ private void setChangeset(long value) {
++ bitField0_ |= 0x00000004;
++ changeset_ = value;
++ }
++ /**
++ * <code>optional int64 changeset = 3;</code>
++ */
++ private void clearChangeset() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ changeset_ = 0L;
++ }
+
+ public static final int UID_FIELD_NUMBER = 4;
+ private int uid_;
+@@ -5269,35 +5177,69 @@ public final class Osmformat {
+ public int getUid() {
+ return uid_;
+ }
++ /**
++ * <code>optional int32 uid = 4;</code>
++ */
++ private void setUid(int value) {
++ bitField0_ |= 0x00000008;
++ uid_ = value;
++ }
++ /**
++ * <code>optional int32 uid = 4;</code>
++ */
++ private void clearUid() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ uid_ = 0;
++ }
+
+ public static final int USER_SID_FIELD_NUMBER = 5;
+ private int userSid_;
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public boolean hasUserSid() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public int getUserSid() {
+ return userSid_;
+ }
++ /**
++ * <pre>
++ * String IDs
++ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
++ */
++ private void setUserSid(int value) {
++ bitField0_ |= 0x00000010;
++ userSid_ = value;
++ }
++ /**
++ * <pre>
++ * String IDs
++ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
++ */
++ private void clearUserSid() {
++ bitField0_ = (bitField0_ & ~0x00000010);
++ userSid_ = 0;
++ }
+
+ public static final int VISIBLE_FIELD_NUMBER = 6;
+ private boolean visible_;
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5308,13 +5250,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public boolean hasVisible() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5325,32 +5267,51 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public boolean getVisible() {
+ return visible_;
+ }
+-
+- private void initFields() {
+- version_ = -1;
+- timestamp_ = 0L;
+- changeset_ = 0L;
+- uid_ = 0;
+- userSid_ = 0;
+- visible_ = false;
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
++ */
++ private void setVisible(boolean value) {
++ bitField0_ |= 0x00000020;
++ visible_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
++ */
++ private void clearVisible() {
++ bitField0_ = (bitField0_ & ~0x00000020);
++ visible_ = false;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeInt32(1, version_);
+ }
+@@ -5369,10 +5330,9 @@ public final class Osmformat {
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ output.writeBool(6, visible_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -5402,395 +5362,259 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBoolSize(6, visible_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Info prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+- * Protobuf type {@code OSMPBF.Info}
+- *
+ * <pre>
+ * Optional metadata that may be included into each primitive.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.Info}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.Info)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.InfoOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
++ super(DEFAULT_INSTANCE);
+ }
+
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+
+- public Builder clear() {
+- super.clear();
+- version_ = -1;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- timestamp_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- changeset_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- uid_ = 0;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- userSid_ = 0;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- visible_ = false;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Info build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Info buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Info(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.version_ = version_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.timestamp_ = timestamp_;
+- if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.changeset_ = changeset_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.uid_ = uid_;
+- if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+- to_bitField0_ |= 0x00000010;
+- }
+- result.userSid_ = userSid_;
+- if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+- to_bitField0_ |= 0x00000020;
+- }
+- result.visible_ = visible_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Info other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) return this;
+- if (other.hasVersion()) {
+- setVersion(other.getVersion());
+- }
+- if (other.hasTimestamp()) {
+- setTimestamp(other.getTimestamp());
+- }
+- if (other.hasChangeset()) {
+- setChangeset(other.getChangeset());
+- }
+- if (other.hasUid()) {
+- setUid(other.getUid());
+- }
+- if (other.hasUserSid()) {
+- setUserSid(other.getUserSid());
+- }
+- if (other.hasVisible()) {
+- setVisible(other.getVisible());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Info) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+-
+- private int version_ = -1;
+- /**
+- * <code>optional int32 version = 1 [default = -1];</code>
+- */
+- public boolean hasVersion() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ /**
++ * <code>optional int32 version = 1 [default = -1];</code>
++ */
++ public boolean hasVersion() {
++ return instance.hasVersion();
+ }
+ /**
+ * <code>optional int32 version = 1 [default = -1];</code>
+ */
+ public int getVersion() {
+- return version_;
++ return instance.getVersion();
+ }
+ /**
+ * <code>optional int32 version = 1 [default = -1];</code>
+ */
+ public Builder setVersion(int value) {
+- bitField0_ |= 0x00000001;
+- version_ = value;
+-
++ copyOnWrite();
++ instance.setVersion(value);
+ return this;
+ }
+ /**
+ * <code>optional int32 version = 1 [default = -1];</code>
+ */
+ public Builder clearVersion() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- version_ = -1;
+-
++ copyOnWrite();
++ instance.clearVersion();
+ return this;
+ }
+
+- private long timestamp_ ;
+ /**
+ * <code>optional int64 timestamp = 2;</code>
+ */
+ public boolean hasTimestamp() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasTimestamp();
+ }
+ /**
+ * <code>optional int64 timestamp = 2;</code>
+ */
+ public long getTimestamp() {
+- return timestamp_;
++ return instance.getTimestamp();
+ }
+ /**
+ * <code>optional int64 timestamp = 2;</code>
+ */
+ public Builder setTimestamp(long value) {
+- bitField0_ |= 0x00000002;
+- timestamp_ = value;
+-
++ copyOnWrite();
++ instance.setTimestamp(value);
+ return this;
+ }
+ /**
+ * <code>optional int64 timestamp = 2;</code>
+ */
+ public Builder clearTimestamp() {
+- bitField0_ = (bitField0_ & ~0x00000002);
+- timestamp_ = 0L;
+-
++ copyOnWrite();
++ instance.clearTimestamp();
+ return this;
+ }
+
+- private long changeset_ ;
+ /**
+ * <code>optional int64 changeset = 3;</code>
+ */
+ public boolean hasChangeset() {
+- return ((bitField0_ & 0x00000004) == 0x00000004);
++ return instance.hasChangeset();
+ }
+ /**
+ * <code>optional int64 changeset = 3;</code>
+ */
+ public long getChangeset() {
+- return changeset_;
++ return instance.getChangeset();
+ }
+ /**
+ * <code>optional int64 changeset = 3;</code>
+ */
+ public Builder setChangeset(long value) {
+- bitField0_ |= 0x00000004;
+- changeset_ = value;
+-
++ copyOnWrite();
++ instance.setChangeset(value);
+ return this;
+ }
+ /**
+ * <code>optional int64 changeset = 3;</code>
+ */
+ public Builder clearChangeset() {
+- bitField0_ = (bitField0_ & ~0x00000004);
+- changeset_ = 0L;
+-
++ copyOnWrite();
++ instance.clearChangeset();
+ return this;
+ }
+
+- private int uid_ ;
+ /**
+ * <code>optional int32 uid = 4;</code>
+ */
+ public boolean hasUid() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasUid();
+ }
+ /**
+ * <code>optional int32 uid = 4;</code>
+ */
+ public int getUid() {
+- return uid_;
++ return instance.getUid();
+ }
+ /**
+ * <code>optional int32 uid = 4;</code>
+ */
+ public Builder setUid(int value) {
+- bitField0_ |= 0x00000008;
+- uid_ = value;
+-
++ copyOnWrite();
++ instance.setUid(value);
+ return this;
+ }
+ /**
+ * <code>optional int32 uid = 4;</code>
+ */
+ public Builder clearUid() {
+- bitField0_ = (bitField0_ & ~0x00000008);
+- uid_ = 0;
+-
++ copyOnWrite();
++ instance.clearUid();
+ return this;
+ }
+
+- private int userSid_ ;
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public boolean hasUserSid() {
+- return ((bitField0_ & 0x00000010) == 0x00000010);
++ return instance.hasUserSid();
+ }
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public int getUserSid() {
+- return userSid_;
++ return instance.getUserSid();
+ }
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public Builder setUserSid(int value) {
+- bitField0_ |= 0x00000010;
+- userSid_ = value;
+-
++ copyOnWrite();
++ instance.setUserSid(value);
+ return this;
+ }
+ /**
+- * <code>optional uint32 user_sid = 5;</code>
+- *
+ * <pre>
+ * String IDs
+ * </pre>
++ *
++ * <code>optional uint32 user_sid = 5;</code>
+ */
+ public Builder clearUserSid() {
+- bitField0_ = (bitField0_ & ~0x00000010);
+- userSid_ = 0;
+-
++ copyOnWrite();
++ instance.clearUserSid();
+ return this;
+ }
+
+- private boolean visible_ ;
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5801,13 +5625,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public boolean hasVisible() {
+- return ((bitField0_ & 0x00000020) == 0x00000020);
++ return instance.hasVisible();
+ }
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5818,13 +5642,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public boolean getVisible() {
+- return visible_;
++ return instance.getVisible();
+ }
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5835,16 +5659,15 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public Builder setVisible(boolean value) {
+- bitField0_ |= 0x00000020;
+- visible_ = value;
+-
++ copyOnWrite();
++ instance.setVisible(value);
+ return this;
+ }
+ /**
+- * <code>optional bool visible = 6;</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -5855,23 +5678,153 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>optional bool visible = 6;</code>
+ */
+ public Builder clearVisible() {
+- bitField0_ = (bitField0_ & ~0x00000020);
+- visible_ = false;
+-
++ copyOnWrite();
++ instance.clearVisible();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.Info)
+ }
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.Info();
++ }
++ case IS_INITIALIZED: {
++ return DEFAULT_INSTANCE;
++ }
++ case MAKE_IMMUTABLE: {
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info other = (org.openstreetmap.osmosis.osmbinary.Osmformat.Info) arg1;
++ version_ = visitor.visitInt(
++ hasVersion(), version_,
++ other.hasVersion(), other.version_);
++ timestamp_ = visitor.visitLong(
++ hasTimestamp(), timestamp_,
++ other.hasTimestamp(), other.timestamp_);
++ changeset_ = visitor.visitLong(
++ hasChangeset(), changeset_,
++ other.hasChangeset(), other.changeset_);
++ uid_ = visitor.visitInt(
++ hasUid(), uid_,
++ other.hasUid(), other.uid_);
++ userSid_ = visitor.visitInt(
++ hasUserSid(), userSid_,
++ other.hasUserSid(), other.userSid_);
++ visible_ = visitor.visitBoolean(
++ hasVisible(), visible_,
++ other.hasVisible(), other.visible_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ version_ = input.readInt32();
++ break;
++ }
++ case 16: {
++ bitField0_ |= 0x00000002;
++ timestamp_ = input.readInt64();
++ break;
++ }
++ case 24: {
++ bitField0_ |= 0x00000004;
++ changeset_ = input.readInt64();
++ break;
++ }
++ case 32: {
++ bitField0_ |= 0x00000008;
++ uid_ = input.readInt32();
++ break;
++ }
++ case 40: {
++ bitField0_ |= 0x00000010;
++ userSid_ = input.readUInt32();
++ break;
++ }
++ case 48: {
++ bitField0_ |= 0x00000020;
++ visible_ = input.readBool();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.Info.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
+
++ // @@protoc_insertion_point(class_scope:OSMPBF.Info)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.Info DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new Info(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new Info();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.Info)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<Info> PARSER;
++
++ public static com.google.protobuf.Parser<Info> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface DenseInfoOrBuilder extends
+@@ -5892,108 +5845,106 @@ public final class Osmformat {
+ int getVersion(int index);
+
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getTimestampList();
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ int getTimestampCount();
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ long getTimestamp(int index);
+
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getChangesetList();
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ int getChangesetCount();
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ long getChangeset(int index);
+
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getUidList();
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ int getUidCount();
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ int getUid(int index);
+
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getUserSidList();
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ int getUserSidCount();
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ int getUserSid(int index);
+
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6004,11 +5955,11 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ java.util.List<java.lang.Boolean> getVisibleList();
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6019,11 +5970,11 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ int getVisibleCount();
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6034,242 +5985,33 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ boolean getVisible(int index);
+ }
+ /**
+- * Protobuf type {@code OSMPBF.DenseInfo}
+- *
+ * <pre>
+ ** Optional metadata that may be included into each primitive. Special dense format used in DenseNodes.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.DenseInfo}
+ */
+- public static final class DenseInfo extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class DenseInfo extends
++ com.google.protobuf.GeneratedMessageLite<
++ DenseInfo, DenseInfo.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.DenseInfo)
+ DenseInfoOrBuilder {
+- // Use DenseInfo.newBuilder() to construct.
+- private DenseInfo(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private DenseInfo(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final DenseInfo defaultInstance;
+- public static DenseInfo getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public DenseInfo getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private DenseInfo(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- version_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- version_.add(input.readInt32());
+- break;
+- }
+- case 10: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
+- version_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- version_.add(input.readInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 16: {
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- timestamp_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- timestamp_.add(input.readSInt64());
+- break;
+- }
+- case 18: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
+- timestamp_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- timestamp_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 24: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- changeset_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- changeset_.add(input.readSInt64());
+- break;
+- }
+- case 26: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+- changeset_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- changeset_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 32: {
+- if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- uid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000008;
+- }
+- uid_.add(input.readSInt32());
+- break;
+- }
+- case 34: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000008) == 0x00000008) && input.getBytesUntilLimit() > 0) {
+- uid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000008;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- uid_.add(input.readSInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 40: {
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- userSid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- userSid_.add(input.readSInt32());
+- break;
+- }
+- case 42: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
+- userSid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- userSid_.add(input.readSInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 48: {
+- if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
+- visible_ = new java.util.ArrayList<java.lang.Boolean>();
+- mutable_bitField0_ |= 0x00000020;
+- }
+- visible_.add(input.readBool());
+- break;
+- }
+- case 50: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000020) == 0x00000020) && input.getBytesUntilLimit() > 0) {
+- visible_ = new java.util.ArrayList<java.lang.Boolean>();
+- mutable_bitField0_ |= 0x00000020;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- visible_.add(input.readBool());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- version_ = java.util.Collections.unmodifiableList(version_);
+- }
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- timestamp_ = java.util.Collections.unmodifiableList(timestamp_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- changeset_ = java.util.Collections.unmodifiableList(changeset_);
+- }
+- if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- uid_ = java.util.Collections.unmodifiableList(uid_);
+- }
+- if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- userSid_ = java.util.Collections.unmodifiableList(userSid_);
+- }
+- if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
+- visible_ = java.util.Collections.unmodifiableList(visible_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<DenseInfo> PARSER =
+- new com.google.protobuf.AbstractParser<DenseInfo>() {
+- public DenseInfo parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new DenseInfo(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<DenseInfo> getParserForType() {
+- return PARSER;
++ private DenseInfo() {
++ version_ = emptyIntList();
++ timestamp_ = emptyLongList();
++ changeset_ = emptyLongList();
++ uid_ = emptyIntList();
++ userSid_ = emptyIntList();
++ visible_ = emptyBooleanList();
+ }
+-
+ public static final int VERSION_FIELD_NUMBER = 1;
+- private java.util.List<java.lang.Integer> version_;
++ private com.google.protobuf.Internal.IntList version_;
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+@@ -6287,155 +6029,397 @@ public final class Osmformat {
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public int getVersion(int index) {
+- return version_.get(index);
++ return version_.getInt(index);
+ }
+ private int versionMemoizedSerializedSize = -1;
++ private void ensureVersionIsMutable() {
++ if (!version_.isModifiable()) {
++ version_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(version_);
++ }
++ }
++ /**
++ * <code>repeated int32 version = 1 [packed = true];</code>
++ */
++ private void setVersion(
++ int index, int value) {
++ ensureVersionIsMutable();
++ version_.setInt(index, value);
++ }
++ /**
++ * <code>repeated int32 version = 1 [packed = true];</code>
++ */
++ private void addVersion(int value) {
++ ensureVersionIsMutable();
++ version_.addInt(value);
++ }
++ /**
++ * <code>repeated int32 version = 1 [packed = true];</code>
++ */
++ private void addAllVersion(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureVersionIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, version_);
++ }
++ /**
++ * <code>repeated int32 version = 1 [packed = true];</code>
++ */
++ private void clearVersion() {
++ version_ = emptyIntList();
++ }
+
+ public static final int TIMESTAMP_FIELD_NUMBER = 2;
+- private java.util.List<java.lang.Long> timestamp_;
++ private com.google.protobuf.Internal.LongList timestamp_;
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getTimestampList() {
+ return timestamp_;
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public int getTimestampCount() {
+ return timestamp_.size();
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public long getTimestamp(int index) {
+- return timestamp_.get(index);
++ return timestamp_.getLong(index);
+ }
+ private int timestampMemoizedSerializedSize = -1;
+-
+- public static final int CHANGESET_FIELD_NUMBER = 3;
+- private java.util.List<java.lang.Long> changeset_;
++ private void ensureTimestampIsMutable() {
++ if (!timestamp_.isModifiable()) {
++ timestamp_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(timestamp_);
++ }
++ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+- public java.util.List<java.lang.Long>
+- getChangesetList() {
+- return changeset_;
++ private void setTimestamp(
++ int index, long value) {
++ ensureTimestampIsMutable();
++ timestamp_.setLong(index, value);
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+- public int getChangesetCount() {
+- return changeset_.size();
++ private void addTimestamp(long value) {
++ ensureTimestampIsMutable();
++ timestamp_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++ */
++ private void addAllTimestamp(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureTimestampIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, timestamp_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++ */
++ private void clearTimestamp() {
++ timestamp_ = emptyLongList();
+ }
++
++ public static final int CHANGESET_FIELD_NUMBER = 3;
++ private com.google.protobuf.Internal.LongList changeset_;
+ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
+ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ public java.util.List<java.lang.Long>
++ getChangesetList() {
++ return changeset_;
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
+ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ public int getChangesetCount() {
++ return changeset_.size();
++ }
++ /**
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public long getChangeset(int index) {
+- return changeset_.get(index);
++ return changeset_.getLong(index);
+ }
+ private int changesetMemoizedSerializedSize = -1;
++ private void ensureChangesetIsMutable() {
++ if (!changeset_.isModifiable()) {
++ changeset_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(changeset_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ private void setChangeset(
++ int index, long value) {
++ ensureChangesetIsMutable();
++ changeset_.setLong(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ private void addChangeset(long value) {
++ ensureChangesetIsMutable();
++ changeset_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ private void addAllChangeset(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureChangesetIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, changeset_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
++ */
++ private void clearChangeset() {
++ changeset_ = emptyLongList();
++ }
+
+ public static final int UID_FIELD_NUMBER = 4;
+- private java.util.List<java.lang.Integer> uid_;
++ private com.google.protobuf.Internal.IntList uid_;
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getUidList() {
+ return uid_;
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public int getUidCount() {
+ return uid_.size();
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public int getUid(int index) {
+- return uid_.get(index);
++ return uid_.getInt(index);
+ }
+ private int uidMemoizedSerializedSize = -1;
++ private void ensureUidIsMutable() {
++ if (!uid_.isModifiable()) {
++ uid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(uid_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
++ */
++ private void setUid(
++ int index, int value) {
++ ensureUidIsMutable();
++ uid_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
++ */
++ private void addUid(int value) {
++ ensureUidIsMutable();
++ uid_.addInt(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
++ */
++ private void addAllUid(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureUidIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, uid_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
++ */
++ private void clearUid() {
++ uid_ = emptyIntList();
++ }
+
+ public static final int USER_SID_FIELD_NUMBER = 5;
+- private java.util.List<java.lang.Integer> userSid_;
++ private com.google.protobuf.Internal.IntList userSid_;
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getUserSidList() {
+ return userSid_;
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public int getUserSidCount() {
+ return userSid_.size();
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public int getUserSid(int index) {
+- return userSid_.get(index);
++ return userSid_.getInt(index);
+ }
+ private int userSidMemoizedSerializedSize = -1;
++ private void ensureUserSidIsMutable() {
++ if (!userSid_.isModifiable()) {
++ userSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(userSid_);
++ }
++ }
++ /**
++ * <pre>
++ * String IDs for usernames. DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++ */
++ private void setUserSid(
++ int index, int value) {
++ ensureUserSidIsMutable();
++ userSid_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * String IDs for usernames. DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++ */
++ private void addUserSid(int value) {
++ ensureUserSidIsMutable();
++ userSid_.addInt(value);
++ }
++ /**
++ * <pre>
++ * String IDs for usernames. DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++ */
++ private void addAllUserSid(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureUserSidIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, userSid_);
++ }
++ /**
++ * <pre>
++ * String IDs for usernames. DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++ */
++ private void clearUserSid() {
++ userSid_ = emptyIntList();
++ }
+
+ public static final int VISIBLE_FIELD_NUMBER = 6;
+- private java.util.List<java.lang.Boolean> visible_;
++ private com.google.protobuf.Internal.BooleanList visible_;
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6446,14 +6430,14 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Boolean>
+ getVisibleList() {
+ return visible_;
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6464,13 +6448,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public int getVisibleCount() {
+ return visible_.size();
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -6481,79 +6465,142 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public boolean getVisible(int index) {
+- return visible_.get(index);
++ return visible_.getBoolean(index);
+ }
+ private int visibleMemoizedSerializedSize = -1;
+-
+- private void initFields() {
+- version_ = java.util.Collections.emptyList();
+- timestamp_ = java.util.Collections.emptyList();
+- changeset_ = java.util.Collections.emptyList();
+- uid_ = java.util.Collections.emptyList();
+- userSid_ = java.util.Collections.emptyList();
+- visible_ = java.util.Collections.emptyList();
++ private void ensureVisibleIsMutable() {
++ if (!visible_.isModifiable()) {
++ visible_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(visible_);
++ }
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
++ */
++ private void setVisible(
++ int index, boolean value) {
++ ensureVisibleIsMutable();
++ visible_.setBoolean(index, value);
++ }
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
++ */
++ private void addVisible(boolean value) {
++ ensureVisibleIsMutable();
++ visible_.addBoolean(value);
++ }
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
++ */
++ private void addAllVisible(
++ java.lang.Iterable<? extends java.lang.Boolean> values) {
++ ensureVisibleIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, visible_);
++ }
++ /**
++ * <pre>
++ * The visible flag is used to store history information. It indicates that
++ * the current object version has been created by a delete operation on the
++ * OSM API.
++ * When a writer sets this flag, it MUST add a required_features tag with
++ * value "HistoricalInformation" to the HeaderBlock.
++ * If this flag is not available for some object it MUST be assumed to be
++ * true if the file has the required_features tag "HistoricalInformation"
++ * set.
++ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
++ */
++ private void clearVisible() {
++ visible_ = emptyBooleanList();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (getVersionList().size() > 0) {
+- output.writeRawVarint32(10);
+- output.writeRawVarint32(versionMemoizedSerializedSize);
++ output.writeUInt32NoTag(10);
++ output.writeUInt32NoTag(versionMemoizedSerializedSize);
+ }
+ for (int i = 0; i < version_.size(); i++) {
+- output.writeInt32NoTag(version_.get(i));
++ output.writeInt32NoTag(version_.getInt(i));
+ }
+ if (getTimestampList().size() > 0) {
+- output.writeRawVarint32(18);
+- output.writeRawVarint32(timestampMemoizedSerializedSize);
++ output.writeUInt32NoTag(18);
++ output.writeUInt32NoTag(timestampMemoizedSerializedSize);
+ }
+ for (int i = 0; i < timestamp_.size(); i++) {
+- output.writeSInt64NoTag(timestamp_.get(i));
++ output.writeSInt64NoTag(timestamp_.getLong(i));
+ }
+ if (getChangesetList().size() > 0) {
+- output.writeRawVarint32(26);
+- output.writeRawVarint32(changesetMemoizedSerializedSize);
++ output.writeUInt32NoTag(26);
++ output.writeUInt32NoTag(changesetMemoizedSerializedSize);
+ }
+ for (int i = 0; i < changeset_.size(); i++) {
+- output.writeSInt64NoTag(changeset_.get(i));
++ output.writeSInt64NoTag(changeset_.getLong(i));
+ }
+ if (getUidList().size() > 0) {
+- output.writeRawVarint32(34);
+- output.writeRawVarint32(uidMemoizedSerializedSize);
++ output.writeUInt32NoTag(34);
++ output.writeUInt32NoTag(uidMemoizedSerializedSize);
+ }
+ for (int i = 0; i < uid_.size(); i++) {
+- output.writeSInt32NoTag(uid_.get(i));
++ output.writeSInt32NoTag(uid_.getInt(i));
+ }
+ if (getUserSidList().size() > 0) {
+- output.writeRawVarint32(42);
+- output.writeRawVarint32(userSidMemoizedSerializedSize);
++ output.writeUInt32NoTag(42);
++ output.writeUInt32NoTag(userSidMemoizedSerializedSize);
+ }
+ for (int i = 0; i < userSid_.size(); i++) {
+- output.writeSInt32NoTag(userSid_.get(i));
++ output.writeSInt32NoTag(userSid_.getInt(i));
+ }
+ if (getVisibleList().size() > 0) {
+- output.writeRawVarint32(50);
+- output.writeRawVarint32(visibleMemoizedSerializedSize);
++ output.writeUInt32NoTag(50);
++ output.writeUInt32NoTag(visibleMemoizedSerializedSize);
+ }
+ for (int i = 0; i < visible_.size(); i++) {
+- output.writeBoolNoTag(visible_.get(i));
++ output.writeBoolNoTag(visible_.getBoolean(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -6563,7 +6610,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < version_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeInt32SizeNoTag(version_.get(i));
++ .computeInt32SizeNoTag(version_.getInt(i));
+ }
+ size += dataSize;
+ if (!getVersionList().isEmpty()) {
+@@ -6577,7 +6624,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < timestamp_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(timestamp_.get(i));
++ .computeSInt64SizeNoTag(timestamp_.getLong(i));
+ }
+ size += dataSize;
+ if (!getTimestampList().isEmpty()) {
+@@ -6591,7 +6638,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < changeset_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(changeset_.get(i));
++ .computeSInt64SizeNoTag(changeset_.getLong(i));
+ }
+ size += dataSize;
+ if (!getChangesetList().isEmpty()) {
+@@ -6605,7 +6652,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < uid_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt32SizeNoTag(uid_.get(i));
++ .computeSInt32SizeNoTag(uid_.getInt(i));
+ }
+ size += dataSize;
+ if (!getUidList().isEmpty()) {
+@@ -6619,7 +6666,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < userSid_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt32SizeNoTag(userSid_.get(i));
++ .computeSInt32SizeNoTag(userSid_.getInt(i));
+ }
+ size += dataSize;
+ if (!getUserSidList().isEmpty()) {
+@@ -6640,304 +6687,132 @@ public final class Osmformat {
+ }
+ visibleMemoizedSerializedSize = dataSize;
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+- * Protobuf type {@code OSMPBF.DenseInfo}
+- *
+ * <pre>
+ ** Optional metadata that may be included into each primitive. Special dense format used in DenseNodes.
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.DenseInfo}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.DenseInfo)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfoOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder clear() {
+- super.clear();
+- version_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- timestamp_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- changeset_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- uid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- userSid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+- visible_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000020);
+- return this;
+- }
+
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo result = new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo(this);
+- int from_bitField0_ = bitField0_;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- version_ = java.util.Collections.unmodifiableList(version_);
+- bitField0_ = (bitField0_ & ~0x00000001);
+- }
+- result.version_ = version_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- timestamp_ = java.util.Collections.unmodifiableList(timestamp_);
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.timestamp_ = timestamp_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- changeset_ = java.util.Collections.unmodifiableList(changeset_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.changeset_ = changeset_;
+- if (((bitField0_ & 0x00000008) == 0x00000008)) {
+- uid_ = java.util.Collections.unmodifiableList(uid_);
+- bitField0_ = (bitField0_ & ~0x00000008);
+- }
+- result.uid_ = uid_;
+- if (((bitField0_ & 0x00000010) == 0x00000010)) {
+- userSid_ = java.util.Collections.unmodifiableList(userSid_);
+- bitField0_ = (bitField0_ & ~0x00000010);
+- }
+- result.userSid_ = userSid_;
+- if (((bitField0_ & 0x00000020) == 0x00000020)) {
+- visible_ = java.util.Collections.unmodifiableList(visible_);
+- bitField0_ = (bitField0_ & ~0x00000020);
+- }
+- result.visible_ = visible_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance()) return this;
+- if (!other.version_.isEmpty()) {
+- if (version_.isEmpty()) {
+- version_ = other.version_;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- } else {
+- ensureVersionIsMutable();
+- version_.addAll(other.version_);
+- }
+-
+- }
+- if (!other.timestamp_.isEmpty()) {
+- if (timestamp_.isEmpty()) {
+- timestamp_ = other.timestamp_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensureTimestampIsMutable();
+- timestamp_.addAll(other.timestamp_);
+- }
+-
+- }
+- if (!other.changeset_.isEmpty()) {
+- if (changeset_.isEmpty()) {
+- changeset_ = other.changeset_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureChangesetIsMutable();
+- changeset_.addAll(other.changeset_);
+- }
+-
+- }
+- if (!other.uid_.isEmpty()) {
+- if (uid_.isEmpty()) {
+- uid_ = other.uid_;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- } else {
+- ensureUidIsMutable();
+- uid_.addAll(other.uid_);
+- }
+-
+- }
+- if (!other.userSid_.isEmpty()) {
+- if (userSid_.isEmpty()) {
+- userSid_ = other.userSid_;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- } else {
+- ensureUserSidIsMutable();
+- userSid_.addAll(other.userSid_);
+- }
+-
+- }
+- if (!other.visible_.isEmpty()) {
+- if (visible_.isEmpty()) {
+- visible_ = other.visible_;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- } else {
+- ensureVisibleIsMutable();
+- visible_.addAll(other.visible_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+-
+- private java.util.List<java.lang.Integer> version_ = java.util.Collections.emptyList();
+- private void ensureVersionIsMutable() {
+- if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+- version_ = new java.util.ArrayList<java.lang.Integer>(version_);
+- bitField0_ |= 0x00000001;
+- }
+- }
+- /**
+- * <code>repeated int32 version = 1 [packed = true];</code>
+- */
+- public java.util.List<java.lang.Integer>
+- getVersionList() {
+- return java.util.Collections.unmodifiableList(version_);
++ /**
++ * <code>repeated int32 version = 1 [packed = true];</code>
++ */
++ public java.util.List<java.lang.Integer>
++ getVersionList() {
++ return java.util.Collections.unmodifiableList(
++ instance.getVersionList());
+ }
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public int getVersionCount() {
+- return version_.size();
++ return instance.getVersionCount();
+ }
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public int getVersion(int index) {
+- return version_.get(index);
++ return instance.getVersion(index);
+ }
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public Builder setVersion(
+ int index, int value) {
+- ensureVersionIsMutable();
+- version_.set(index, value);
+-
++ copyOnWrite();
++ instance.setVersion(index, value);
+ return this;
+ }
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public Builder addVersion(int value) {
+- ensureVersionIsMutable();
+- version_.add(value);
+-
++ copyOnWrite();
++ instance.addVersion(value);
+ return this;
+ }
+ /**
+@@ -6945,408 +6820,352 @@ public final class Osmformat {
+ */
+ public Builder addAllVersion(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureVersionIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, version_);
+-
++ copyOnWrite();
++ instance.addAllVersion(values);
+ return this;
+ }
+ /**
+ * <code>repeated int32 version = 1 [packed = true];</code>
+ */
+ public Builder clearVersion() {
+- version_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+-
++ copyOnWrite();
++ instance.clearVersion();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> timestamp_ = java.util.Collections.emptyList();
+- private void ensureTimestampIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- timestamp_ = new java.util.ArrayList<java.lang.Long>(timestamp_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getTimestampList() {
+- return java.util.Collections.unmodifiableList(timestamp_);
++ return java.util.Collections.unmodifiableList(
++ instance.getTimestampList());
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public int getTimestampCount() {
+- return timestamp_.size();
++ return instance.getTimestampCount();
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public long getTimestamp(int index) {
+- return timestamp_.get(index);
++ return instance.getTimestamp(index);
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public Builder setTimestamp(
+ int index, long value) {
+- ensureTimestampIsMutable();
+- timestamp_.set(index, value);
+-
++ copyOnWrite();
++ instance.setTimestamp(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public Builder addTimestamp(long value) {
+- ensureTimestampIsMutable();
+- timestamp_.add(value);
+-
++ copyOnWrite();
++ instance.addTimestamp(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public Builder addAllTimestamp(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureTimestampIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, timestamp_);
+-
++ copyOnWrite();
++ instance.addAllTimestamp(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 timestamp = 2 [packed = true];</code>
+ */
+ public Builder clearTimestamp() {
+- timestamp_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearTimestamp();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> changeset_ = java.util.Collections.emptyList();
+- private void ensureChangesetIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- changeset_ = new java.util.ArrayList<java.lang.Long>(changeset_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getChangesetList() {
+- return java.util.Collections.unmodifiableList(changeset_);
++ return java.util.Collections.unmodifiableList(
++ instance.getChangesetList());
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public int getChangesetCount() {
+- return changeset_.size();
++ return instance.getChangesetCount();
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public long getChangeset(int index) {
+- return changeset_.get(index);
++ return instance.getChangeset(index);
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public Builder setChangeset(
+ int index, long value) {
+- ensureChangesetIsMutable();
+- changeset_.set(index, value);
+-
++ copyOnWrite();
++ instance.setChangeset(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public Builder addChangeset(long value) {
+- ensureChangesetIsMutable();
+- changeset_.add(value);
+-
++ copyOnWrite();
++ instance.addChangeset(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public Builder addAllChangeset(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureChangesetIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, changeset_);
+-
++ copyOnWrite();
++ instance.addAllChangeset(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 changeset = 3 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 changeset = 3 [packed = true];</code>
+ */
+ public Builder clearChangeset() {
+- changeset_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearChangeset();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> uid_ = java.util.Collections.emptyList();
+- private void ensureUidIsMutable() {
+- if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+- uid_ = new java.util.ArrayList<java.lang.Integer>(uid_);
+- bitField0_ |= 0x00000008;
+- }
+- }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getUidList() {
+- return java.util.Collections.unmodifiableList(uid_);
++ return java.util.Collections.unmodifiableList(
++ instance.getUidList());
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public int getUidCount() {
+- return uid_.size();
++ return instance.getUidCount();
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public int getUid(int index) {
+- return uid_.get(index);
++ return instance.getUid(index);
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public Builder setUid(
+ int index, int value) {
+- ensureUidIsMutable();
+- uid_.set(index, value);
+-
++ copyOnWrite();
++ instance.setUid(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public Builder addUid(int value) {
+- ensureUidIsMutable();
+- uid_.add(value);
+-
++ copyOnWrite();
++ instance.addUid(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public Builder addAllUid(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureUidIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, uid_);
+-
++ copyOnWrite();
++ instance.addAllUid(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 uid = 4 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 uid = 4 [packed = true];</code>
+ */
+ public Builder clearUid() {
+- uid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+-
++ copyOnWrite();
++ instance.clearUid();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> userSid_ = java.util.Collections.emptyList();
+- private void ensureUserSidIsMutable() {
+- if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+- userSid_ = new java.util.ArrayList<java.lang.Integer>(userSid_);
+- bitField0_ |= 0x00000010;
+- }
+- }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getUserSidList() {
+- return java.util.Collections.unmodifiableList(userSid_);
++ return java.util.Collections.unmodifiableList(
++ instance.getUserSidList());
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public int getUserSidCount() {
+- return userSid_.size();
++ return instance.getUserSidCount();
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public int getUserSid(int index) {
+- return userSid_.get(index);
++ return instance.getUserSid(index);
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public Builder setUserSid(
+ int index, int value) {
+- ensureUserSidIsMutable();
+- userSid_.set(index, value);
+-
++ copyOnWrite();
++ instance.setUserSid(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public Builder addUserSid(int value) {
+- ensureUserSidIsMutable();
+- userSid_.add(value);
+-
++ copyOnWrite();
++ instance.addUserSid(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public Builder addAllUserSid(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureUserSidIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, userSid_);
+-
++ copyOnWrite();
++ instance.addAllUserSid(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs for usernames. DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint32 user_sid = 5 [packed = true];</code>
+ */
+ public Builder clearUserSid() {
+- userSid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+-
++ copyOnWrite();
++ instance.clearUserSid();
+ return this;
+ }
+
+- private java.util.List<java.lang.Boolean> visible_ = java.util.Collections.emptyList();
+- private void ensureVisibleIsMutable() {
+- if (!((bitField0_ & 0x00000020) == 0x00000020)) {
+- visible_ = new java.util.ArrayList<java.lang.Boolean>(visible_);
+- bitField0_ |= 0x00000020;
+- }
+- }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7357,14 +7176,15 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Boolean>
+ getVisibleList() {
+- return java.util.Collections.unmodifiableList(visible_);
++ return java.util.Collections.unmodifiableList(
++ instance.getVisibleList());
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7375,13 +7195,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public int getVisibleCount() {
+- return visible_.size();
++ return instance.getVisibleCount();
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7392,13 +7212,13 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public boolean getVisible(int index) {
+- return visible_.get(index);
++ return instance.getVisible(index);
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7409,17 +7229,16 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public Builder setVisible(
+ int index, boolean value) {
+- ensureVisibleIsMutable();
+- visible_.set(index, value);
+-
++ copyOnWrite();
++ instance.setVisible(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7430,16 +7249,15 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public Builder addVisible(boolean value) {
+- ensureVisibleIsMutable();
+- visible_.add(value);
+-
++ copyOnWrite();
++ instance.addVisible(value);
+ return this;
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7450,18 +7268,16 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public Builder addAllVisible(
+ java.lang.Iterable<? extends java.lang.Boolean> values) {
+- ensureVisibleIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, visible_);
+-
++ copyOnWrite();
++ instance.addAllVisible(values);
+ return this;
+ }
+ /**
+- * <code>repeated bool visible = 6 [packed = true];</code>
+- *
+ * <pre>
+ * The visible flag is used to store history information. It indicates that
+ * the current object version has been created by a delete operation on the
+@@ -7472,23 +7288,243 @@ public final class Osmformat {
+ * true if the file has the required_features tag "HistoricalInformation"
+ * set.
+ * </pre>
++ *
++ * <code>repeated bool visible = 6 [packed = true];</code>
+ */
+ public Builder clearVisible() {
+- visible_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000020);
+-
++ copyOnWrite();
++ instance.clearVisible();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.DenseInfo)
+ }
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo();
++ }
++ case IS_INITIALIZED: {
++ return DEFAULT_INSTANCE;
++ }
++ case MAKE_IMMUTABLE: {
++ version_.makeImmutable();
++ timestamp_.makeImmutable();
++ changeset_.makeImmutable();
++ uid_.makeImmutable();
++ userSid_.makeImmutable();
++ visible_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo other = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo) arg1;
++ version_= visitor.visitIntList(version_, other.version_);
++ timestamp_= visitor.visitLongList(timestamp_, other.timestamp_);
++ changeset_= visitor.visitLongList(changeset_, other.changeset_);
++ uid_= visitor.visitIntList(uid_, other.uid_);
++ userSid_= visitor.visitIntList(userSid_, other.userSid_);
++ visible_= visitor.visitBooleanList(visible_, other.visible_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ if (!version_.isModifiable()) {
++ version_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(version_);
++ }
++ version_.addInt(input.readInt32());
++ break;
++ }
++ case 10: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!version_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ version_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(version_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ version_.addInt(input.readInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 16: {
++ if (!timestamp_.isModifiable()) {
++ timestamp_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(timestamp_);
++ }
++ timestamp_.addLong(input.readSInt64());
++ break;
++ }
++ case 18: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!timestamp_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ timestamp_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(timestamp_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ timestamp_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 24: {
++ if (!changeset_.isModifiable()) {
++ changeset_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(changeset_);
++ }
++ changeset_.addLong(input.readSInt64());
++ break;
++ }
++ case 26: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!changeset_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ changeset_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(changeset_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ changeset_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 32: {
++ if (!uid_.isModifiable()) {
++ uid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(uid_);
++ }
++ uid_.addInt(input.readSInt32());
++ break;
++ }
++ case 34: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!uid_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ uid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(uid_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ uid_.addInt(input.readSInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 40: {
++ if (!userSid_.isModifiable()) {
++ userSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(userSid_);
++ }
++ userSid_.addInt(input.readSInt32());
++ break;
++ }
++ case 42: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!userSid_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ userSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(userSid_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ userSid_.addInt(input.readSInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 48: {
++ if (!visible_.isModifiable()) {
++ visible_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(visible_);
++ }
++ visible_.addBoolean(input.readBool());
++ break;
++ }
++ case 50: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!visible_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ final int currentSize = visible_.size();
++ visible_ = visible_.mutableCopyWithCapacity(
++ currentSize + (length/1));
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ visible_.addBoolean(input.readBool());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.DenseInfo)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new DenseInfo(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new DenseInfo();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.DenseInfo)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<DenseInfo> PARSER;
++
++ public static com.google.protobuf.Parser<DenseInfo> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface ChangeSetOrBuilder extends
+@@ -7496,8 +7532,6 @@ public final class Osmformat {
+ com.google.protobuf.MessageLiteOrBuilder {
+
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7505,11 +7539,11 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7517,108 +7551,30 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ long getId();
+ }
+ /**
+- * Protobuf type {@code OSMPBF.ChangeSet}
+- *
+ * <pre>
+ * THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
+ * TODO: REMOVE THIS?
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.ChangeSet}
+ */
+- public static final class ChangeSet extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class ChangeSet extends
++ com.google.protobuf.GeneratedMessageLite<
++ ChangeSet, ChangeSet.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.ChangeSet)
+ ChangeSetOrBuilder {
+- // Use ChangeSet.newBuilder() to construct.
+- private ChangeSet(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private ChangeSet(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final ChangeSet defaultInstance;
+- public static ChangeSet getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public ChangeSet getDefaultInstanceForType() {
+- return defaultInstance;
++ private ChangeSet() {
+ }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private ChangeSet(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- id_ = input.readInt64();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<ChangeSet> PARSER =
+- new com.google.protobuf.AbstractParser<ChangeSet>() {
+- public ChangeSet parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new ChangeSet(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<ChangeSet> getParserForType() {
+- return PARSER;
+- }
+-
+ private int bitField0_;
+ public static final int ID_FIELD_NUMBER = 1;
+ private long id_;
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7626,13 +7582,13 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7640,38 +7596,51 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public long getId() {
+ return id_;
+ }
+-
+- private void initFields() {
+- id_ = 0L;
++ /**
++ * <pre>
++ *
++ * // Parallel arrays.
++ * repeated uint32 keys = 2 [packed = true]; // String IDs.
++ * repeated uint32 vals = 3 [packed = true]; // String IDs.
++ * optional Info info = 4;
++ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
++ */
++ private void setId(long value) {
++ bitField0_ |= 0x00000001;
++ id_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasId()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ *
++ * // Parallel arrays.
++ * repeated uint32 keys = 2 [packed = true]; // String IDs.
++ * repeated uint32 vals = 3 [packed = true]; // String IDs.
++ * optional Info info = 4;
++ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
++ */
++ private void clearId() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ id_ = 0L;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+- getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeInt64(1, id_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -7681,179 +7650,99 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt64Size(1, id_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+- * Protobuf type {@code OSMPBF.ChangeSet}
+- *
+ * <pre>
+ * THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
+ * TODO: REMOVE THIS?
+ * </pre>
++ *
++ * Protobuf type {@code OSMPBF.ChangeSet}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.ChangeSet)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- id_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet result = new org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.id_ = id_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.getDefaultInstance()) return this;
+- if (other.hasId()) {
+- setId(other.getId());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasId()) {
+-
+- return false;
+- }
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private long id_ ;
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7861,13 +7750,13 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public boolean hasId() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasId();
+ }
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7875,13 +7764,13 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public long getId() {
+- return id_;
++ return instance.getId();
+ }
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7889,16 +7778,15 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public Builder setId(long value) {
+- bitField0_ |= 0x00000001;
+- id_ = value;
+-
++ copyOnWrite();
++ instance.setId(value);
+ return this;
+ }
+ /**
+- * <code>required int64 id = 1;</code>
+- *
+ * <pre>
+ *
+ * // Parallel arrays.
+@@ -7906,23 +7794,127 @@ public final class Osmformat {
+ * repeated uint32 vals = 3 [packed = true]; // String IDs.
+ * optional Info info = 4;
+ * </pre>
++ *
++ * <code>required int64 id = 1;</code>
+ */
+ public Builder clearId() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- id_ = 0L;
+-
++ copyOnWrite();
++ instance.clearId();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.ChangeSet)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasId()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet other = (org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet) arg1;
++ id_ = visitor.visitLong(
++ hasId(), id_,
++ other.hasId(), other.id_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ id_ = input.readInt64();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
+
++ // @@protoc_insertion_point(class_scope:OSMPBF.ChangeSet)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new ChangeSet(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new ChangeSet();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.ChangeSet)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<ChangeSet> PARSER;
++
++ public static com.google.protobuf.Parser<ChangeSet> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface NodeOrBuilder extends
+@@ -7939,69 +7931,69 @@ public final class Osmformat {
+ long getId();
+
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getKeysList();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeysCount();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeys(int index);
+
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getValsList();
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ int getValsCount();
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ int getVals(int index);
+
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ boolean hasInfo();
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+
+@@ -8026,162 +8018,15 @@ public final class Osmformat {
+ /**
+ * Protobuf type {@code OSMPBF.Node}
+ */
+- public static final class Node extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class Node extends
++ com.google.protobuf.GeneratedMessageLite<
++ Node, Node.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.Node)
+ NodeOrBuilder {
+- // Use Node.newBuilder() to construct.
+- private Node(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private Node(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final Node defaultInstance;
+- public static Node getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public Node getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private Node(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- id_ = input.readSInt64();
+- break;
+- }
+- case 16: {
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- keys_.add(input.readUInt32());
+- break;
+- }
+- case 18: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- keys_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 24: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- vals_.add(input.readUInt32());
+- break;
+- }
+- case 26: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- vals_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 34: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- subBuilder = info_.toBuilder();
+- }
+- info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(info_);
+- info_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000002;
+- break;
+- }
+- case 64: {
+- bitField0_ |= 0x00000004;
+- lat_ = input.readSInt64();
+- break;
+- }
+- case 72: {
+- bitField0_ |= 0x00000008;
+- lon_ = input.readSInt64();
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<Node> PARSER =
+- new com.google.protobuf.AbstractParser<Node>() {
+- public Node parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new Node(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<Node> getParserForType() {
+- return PARSER;
++ private Node() {
++ keys_ = emptyIntList();
++ vals_ = emptyIntList();
+ }
+-
+ private int bitField0_;
+ public static final int ID_FIELD_NUMBER = 1;
+ private long id_;
+@@ -8197,98 +8042,269 @@ public final class Osmformat {
+ public long getId() {
+ return id_;
+ }
++ /**
++ * <code>required sint64 id = 1;</code>
++ */
++ private void setId(long value) {
++ bitField0_ |= 0x00000001;
++ id_ = value;
++ }
++ /**
++ * <code>required sint64 id = 1;</code>
++ */
++ private void clearId() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ id_ = 0L;
++ }
+
+ public static final int KEYS_FIELD_NUMBER = 2;
+- private java.util.List<java.lang.Integer> keys_;
++ private com.google.protobuf.Internal.IntList keys_;
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+ return keys_;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeysCount() {
+ return keys_.size();
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeys(int index) {
+- return keys_.get(index);
++ return keys_.getInt(index);
+ }
+ private int keysMemoizedSerializedSize = -1;
++ private void ensureKeysIsMutable() {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void setKeys(
++ int index, int value) {
++ ensureKeysIsMutable();
++ keys_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void addKeys(int value) {
++ ensureKeysIsMutable();
++ keys_.addInt(value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void addAllKeys(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureKeysIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, keys_);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void clearKeys() {
++ keys_ = emptyIntList();
++ }
+
+ public static final int VALS_FIELD_NUMBER = 3;
+- private java.util.List<java.lang.Integer> vals_;
++ private com.google.protobuf.Internal.IntList vals_;
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getValsList() {
+ return vals_;
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getValsCount() {
+ return vals_.size();
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return vals_.getInt(index);
+ }
+ private int valsMemoizedSerializedSize = -1;
+-
+- public static final int INFO_FIELD_NUMBER = 4;
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
++ private void ensureValsIsMutable() {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+- * May be omitted in omitmeta
++ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+- public boolean hasInfo() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ private void setVals(
++ int index, int value) {
++ ensureValsIsMutable();
++ vals_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * String IDs.
++ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addVals(int value) {
++ ensureValsIsMutable();
++ vals_.addInt(value);
++ }
++ /**
++ * <pre>
++ * String IDs.
++ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addAllVals(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureValsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, vals_);
++ }
++ /**
++ * <pre>
++ * String IDs.
++ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void clearVals() {
++ vals_ = emptyIntList();
++ }
++
++ public static final int INFO_FIELD_NUMBER = 4;
++ private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
++ /**
++ * <pre>
++ * May be omitted in omitmeta
++ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ public boolean hasInfo() {
++ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return info_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance() : info_;
++ }
++ /**
++ * <pre>
++ * May be omitted in omitmeta
++ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ info_ = value;
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <pre>
++ * May be omitted in omitmeta
++ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
++ info_ = builderForValue.build();
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <pre>
++ * May be omitted in omitmeta
++ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (info_ != null &&
++ info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
++ info_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
++ } else {
++ info_ = value;
++ }
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <pre>
++ * May be omitted in omitmeta
++ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void clearInfo() { info_ = null;
++ bitField0_ = (bitField0_ & ~0x00000002);
+ }
+
+ public static final int LAT_FIELD_NUMBER = 8;
+@@ -8305,6 +8321,20 @@ public final class Osmformat {
+ public long getLat() {
+ return lat_;
+ }
++ /**
++ * <code>required sint64 lat = 8;</code>
++ */
++ private void setLat(long value) {
++ bitField0_ |= 0x00000004;
++ lat_ = value;
++ }
++ /**
++ * <code>required sint64 lat = 8;</code>
++ */
++ private void clearLat() {
++ bitField0_ = (bitField0_ & ~0x00000004);
++ lat_ = 0L;
++ }
+
+ public static final int LON_FIELD_NUMBER = 9;
+ private long lon_;
+@@ -8320,35 +8350,19 @@ public final class Osmformat {
+ public long getLon() {
+ return lon_;
+ }
+-
+- private void initFields() {
+- id_ = 0L;
+- keys_ = java.util.Collections.emptyList();
+- vals_ = java.util.Collections.emptyList();
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- lat_ = 0L;
+- lon_ = 0L;
++ /**
++ * <code>required sint64 lon = 9;</code>
++ */
++ private void setLon(long value) {
++ bitField0_ |= 0x00000008;
++ lon_ = value;
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasId()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasLat()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- if (!hasLon()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <code>required sint64 lon = 9;</code>
++ */
++ private void clearLon() {
++ bitField0_ = (bitField0_ & ~0x00000008);
++ lon_ = 0L;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+@@ -8358,21 +8372,21 @@ public final class Osmformat {
+ output.writeSInt64(1, id_);
+ }
+ if (getKeysList().size() > 0) {
+- output.writeRawVarint32(18);
+- output.writeRawVarint32(keysMemoizedSerializedSize);
++ output.writeUInt32NoTag(18);
++ output.writeUInt32NoTag(keysMemoizedSerializedSize);
+ }
+ for (int i = 0; i < keys_.size(); i++) {
+- output.writeUInt32NoTag(keys_.get(i));
++ output.writeUInt32NoTag(keys_.getInt(i));
+ }
+ if (getValsList().size() > 0) {
+- output.writeRawVarint32(26);
+- output.writeRawVarint32(valsMemoizedSerializedSize);
++ output.writeUInt32NoTag(26);
++ output.writeUInt32NoTag(valsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < vals_.size(); i++) {
+- output.writeUInt32NoTag(vals_.get(i));
++ output.writeUInt32NoTag(vals_.getInt(i));
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- output.writeMessage(4, info_);
++ output.writeMessage(4, getInfo());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeSInt64(8, lat_);
+@@ -8380,10 +8394,9 @@ public final class Osmformat {
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeSInt64(9, lon_);
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -8397,7 +8410,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < keys_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(keys_.get(i));
++ .computeUInt32SizeNoTag(keys_.getInt(i));
+ }
+ size += dataSize;
+ if (!getKeysList().isEmpty()) {
+@@ -8411,7 +8424,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < vals_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(vals_.get(i));
++ .computeUInt32SizeNoTag(vals_.getInt(i));
+ }
+ size += dataSize;
+ if (!getValsList().isEmpty()) {
+@@ -8423,7 +8436,7 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(4, info_);
++ .computeMessageSize(4, getInfo());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+@@ -8433,1150 +8446,1214 @@ public final class Osmformat {
+ size += com.google.protobuf.CodedOutputStream
+ .computeSInt64Size(9, lon_);
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Node prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.Node}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Node, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Node, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.Node)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.NodeOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Node.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- id_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- lat_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- lon_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Node getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.Node.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Node build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Node result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Node buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Node result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Node(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.id_ = id_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.keys_ = keys_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.vals_ = vals_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.info_ = info_;
+- if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+- to_bitField0_ |= 0x00000004;
+- }
+- result.lat_ = lat_;
+- if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+- to_bitField0_ |= 0x00000008;
+- }
+- result.lon_ = lon_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Node other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Node.getDefaultInstance()) return this;
+- if (other.hasId()) {
+- setId(other.getId());
+- }
+- if (!other.keys_.isEmpty()) {
+- if (keys_.isEmpty()) {
+- keys_ = other.keys_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensureKeysIsMutable();
+- keys_.addAll(other.keys_);
+- }
+-
+- }
+- if (!other.vals_.isEmpty()) {
+- if (vals_.isEmpty()) {
+- vals_ = other.vals_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureValsIsMutable();
+- vals_.addAll(other.vals_);
+- }
+-
+- }
+- if (other.hasInfo()) {
+- mergeInfo(other.getInfo());
+- }
+- if (other.hasLat()) {
+- setLat(other.getLat());
+- }
+- if (other.hasLon()) {
+- setLon(other.getLon());
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasId()) {
+-
+- return false;
+- }
+- if (!hasLat()) {
+-
+- return false;
+- }
+- if (!hasLon()) {
+-
+- return false;
+- }
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Node parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Node) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private long id_ ;
+ /**
+ * <code>required sint64 id = 1;</code>
+ */
+ public boolean hasId() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasId();
+ }
+ /**
+ * <code>required sint64 id = 1;</code>
+ */
+ public long getId() {
+- return id_;
++ return instance.getId();
+ }
+ /**
+ * <code>required sint64 id = 1;</code>
+ */
+ public Builder setId(long value) {
+- bitField0_ |= 0x00000001;
+- id_ = value;
+-
++ copyOnWrite();
++ instance.setId(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 id = 1;</code>
+ */
+ public Builder clearId() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- id_ = 0L;
+-
++ copyOnWrite();
++ instance.clearId();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+- private void ensureKeysIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+- return java.util.Collections.unmodifiableList(keys_);
++ return java.util.Collections.unmodifiableList(
++ instance.getKeysList());
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeysCount() {
+- return keys_.size();
++ return instance.getKeysCount();
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeys(int index) {
+- return keys_.get(index);
++ return instance.getKeys(index);
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder setKeys(
+ int index, int value) {
+- ensureKeysIsMutable();
+- keys_.set(index, value);
+-
++ copyOnWrite();
++ instance.setKeys(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addKeys(int value) {
+- ensureKeysIsMutable();
+- keys_.add(value);
+-
++ copyOnWrite();
++ instance.addKeys(value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addAllKeys(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureKeysIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, keys_);
+-
++ copyOnWrite();
++ instance.addAllKeys(values);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder clearKeys() {
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearKeys();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+- private void ensureValsIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getValsList() {
+- return java.util.Collections.unmodifiableList(vals_);
++ return java.util.Collections.unmodifiableList(
++ instance.getValsList());
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getValsCount() {
+- return vals_.size();
++ return instance.getValsCount();
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return instance.getVals(index);
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder setVals(
+ int index, int value) {
+- ensureValsIsMutable();
+- vals_.set(index, value);
+-
++ copyOnWrite();
++ instance.setVals(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder addVals(int value) {
+- ensureValsIsMutable();
+- vals_.add(value);
+-
++ copyOnWrite();
++ instance.addVals(value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder addAllVals(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureValsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, vals_);
+-
++ copyOnWrite();
++ instance.addAllVals(values);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 vals = 3 [packed = true];</code>
+- *
+ * <pre>
+ * String IDs.
+ * </pre>
++ *
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder clearVals() {
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearVals();
+ return this;
+ }
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public boolean hasInfo() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasInfo();
+ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return instance.getInfo();
+ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- info_ = value;
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(value);
+ return this;
+- }
++ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+- info_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(builderForValue);
+ return this;
+ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (((bitField0_ & 0x00000008) == 0x00000008) &&
+- info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+- info_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
+- } else {
+- info_ = value;
+- }
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.mergeInfo(value);
+ return this;
+ }
+ /**
+- * <code>optional .OSMPBF.Info info = 4;</code>
+- *
+ * <pre>
+ * May be omitted in omitmeta
+ * </pre>
++ *
++ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+- public Builder clearInfo() {
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000008);
++ public Builder clearInfo() { copyOnWrite();
++ instance.clearInfo();
+ return this;
+ }
+
+- private long lat_ ;
+ /**
+ * <code>required sint64 lat = 8;</code>
+ */
+ public boolean hasLat() {
+- return ((bitField0_ & 0x00000010) == 0x00000010);
++ return instance.hasLat();
+ }
+ /**
+ * <code>required sint64 lat = 8;</code>
+ */
+ public long getLat() {
+- return lat_;
++ return instance.getLat();
+ }
+ /**
+ * <code>required sint64 lat = 8;</code>
+ */
+ public Builder setLat(long value) {
+- bitField0_ |= 0x00000010;
+- lat_ = value;
+-
++ copyOnWrite();
++ instance.setLat(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 lat = 8;</code>
+ */
+ public Builder clearLat() {
+- bitField0_ = (bitField0_ & ~0x00000010);
+- lat_ = 0L;
+-
++ copyOnWrite();
++ instance.clearLat();
+ return this;
+ }
+
+- private long lon_ ;
+ /**
+ * <code>required sint64 lon = 9;</code>
+ */
+ public boolean hasLon() {
+- return ((bitField0_ & 0x00000020) == 0x00000020);
++ return instance.hasLon();
+ }
+ /**
+ * <code>required sint64 lon = 9;</code>
+ */
+ public long getLon() {
+- return lon_;
++ return instance.getLon();
+ }
+ /**
+ * <code>required sint64 lon = 9;</code>
+ */
+ public Builder setLon(long value) {
+- bitField0_ |= 0x00000020;
+- lon_ = value;
+-
++ copyOnWrite();
++ instance.setLon(value);
+ return this;
+ }
+ /**
+ * <code>required sint64 lon = 9;</code>
+ */
+ public Builder clearLon() {
+- bitField0_ = (bitField0_ & ~0x00000020);
+- lon_ = 0L;
+-
++ copyOnWrite();
++ instance.clearLon();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.Node)
+ }
+-
+- static {
+- defaultInstance = new Node(true);
+- defaultInstance.initFields();
+- }
+-
+- // @@protoc_insertion_point(class_scope:OSMPBF.Node)
+- }
+-
+- public interface DenseNodesOrBuilder extends
+- // @@protoc_insertion_point(interface_extends:OSMPBF.DenseNodes)
+- com.google.protobuf.MessageLiteOrBuilder {
+-
+- /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+- * <pre>
+- * DELTA coded
+- * </pre>
+- */
+- java.util.List<java.lang.Long> getIdList();
+- /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+- * <pre>
+- * DELTA coded
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.Node();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasId()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasLat()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (!hasLon()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ keys_.makeImmutable();
++ vals_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Node other = (org.openstreetmap.osmosis.osmbinary.Osmformat.Node) arg1;
++ id_ = visitor.visitLong(
++ hasId(), id_,
++ other.hasId(), other.id_);
++ keys_= visitor.visitIntList(keys_, other.keys_);
++ vals_= visitor.visitIntList(vals_, other.vals_);
++ info_ = visitor.visitMessage(info_, other.info_);
++ lat_ = visitor.visitLong(
++ hasLat(), lat_,
++ other.hasLat(), other.lat_);
++ lon_ = visitor.visitLong(
++ hasLon(), lon_,
++ other.hasLon(), other.lon_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ id_ = input.readSInt64();
++ break;
++ }
++ case 16: {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ keys_.addInt(input.readUInt32());
++ break;
++ }
++ case 18: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!keys_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ keys_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 24: {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ vals_.addInt(input.readUInt32());
++ break;
++ }
++ case 26: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!vals_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ vals_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 34: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000002) == 0x00000002)) {
++ subBuilder = info_.toBuilder();
++ }
++ info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(info_);
++ info_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000002;
++ break;
++ }
++ case 64: {
++ bitField0_ |= 0x00000004;
++ lat_ = input.readSInt64();
++ break;
++ }
++ case 72: {
++ bitField0_ |= 0x00000008;
++ lon_ = input.readSInt64();
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.Node.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.Node)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.Node DEFAULT_INSTANCE;
++ static {
++ DEFAULT_INSTANCE = new Node();
++ DEFAULT_INSTANCE.makeImmutable();
++ }
++
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<Node> PARSER;
++
++ public static com.google.protobuf.Parser<Node> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
++ }
++
++ public interface DenseNodesOrBuilder extends
++ // @@protoc_insertion_point(interface_extends:OSMPBF.DenseNodes)
++ com.google.protobuf.MessageLiteOrBuilder {
++
++ /**
++ * <pre>
++ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+- int getIdCount();
++ java.util.List<java.lang.Long> getIdList();
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
++ * <pre>
++ * DELTA coded
++ * </pre>
+ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
++ */
++ int getIdCount();
++ /**
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ long getId(int index);
+
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ boolean hasDenseinfo();
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo();
+
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getLatList();
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ int getLatCount();
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ long getLat(int index);
+
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getLonList();
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ int getLonCount();
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ long getLon(int index);
+
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getKeysValsList();
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ int getKeysValsCount();
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ int getKeysVals(int index);
+ }
+ /**
+ * Protobuf type {@code OSMPBF.DenseNodes}
+ */
+- public static final class DenseNodes extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class DenseNodes extends
++ com.google.protobuf.GeneratedMessageLite<
++ DenseNodes, DenseNodes.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.DenseNodes)
+ DenseNodesOrBuilder {
+- // Use DenseNodes.newBuilder() to construct.
+- private DenseNodes(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private DenseNodes(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final DenseNodes defaultInstance;
+- public static DenseNodes getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public DenseNodes getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private DenseNodes(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- id_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- id_.add(input.readSInt64());
+- break;
+- }
+- case 10: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
+- id_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000001;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- id_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 42: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- subBuilder = denseinfo_.toBuilder();
+- }
+- denseinfo_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(denseinfo_);
+- denseinfo_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000001;
+- break;
+- }
+- case 64: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- lat_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- lat_.add(input.readSInt64());
+- break;
+- }
+- case 66: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+- lat_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- lat_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 72: {
+- if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- lon_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000008;
+- }
+- lon_.add(input.readSInt64());
+- break;
+- }
+- case 74: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000008) == 0x00000008) && input.getBytesUntilLimit() > 0) {
+- lon_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000008;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- lon_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 80: {
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- keysVals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- keysVals_.add(input.readInt32());
+- break;
+- }
+- case 82: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
+- keysVals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- keysVals_.add(input.readInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+- id_ = java.util.Collections.unmodifiableList(id_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- lat_ = java.util.Collections.unmodifiableList(lat_);
+- }
+- if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+- lon_ = java.util.Collections.unmodifiableList(lon_);
+- }
+- if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- keysVals_ = java.util.Collections.unmodifiableList(keysVals_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<DenseNodes> PARSER =
+- new com.google.protobuf.AbstractParser<DenseNodes>() {
+- public DenseNodes parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new DenseNodes(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<DenseNodes> getParserForType() {
+- return PARSER;
++ private DenseNodes() {
++ id_ = emptyLongList();
++ lat_ = emptyLongList();
++ lon_ = emptyLongList();
++ keysVals_ = emptyIntList();
+ }
+-
+ private int bitField0_;
+ public static final int ID_FIELD_NUMBER = 1;
+- private java.util.List<java.lang.Long> id_;
++ private com.google.protobuf.Internal.LongList id_;
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getIdList() {
+ return id_;
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public int getIdCount() {
+ return id_.size();
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public long getId(int index) {
+- return id_.get(index);
++ return id_.getLong(index);
+ }
+ private int idMemoizedSerializedSize = -1;
++ private void ensureIdIsMutable() {
++ if (!id_.isModifiable()) {
++ id_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(id_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
++ */
++ private void setId(
++ int index, long value) {
++ ensureIdIsMutable();
++ id_.setLong(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
++ */
++ private void addId(long value) {
++ ensureIdIsMutable();
++ id_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
++ */
++ private void addAllId(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureIdIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, id_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
++ */
++ private void clearId() {
++ id_ = emptyLongList();
++ }
+
+ public static final int DENSEINFO_FIELD_NUMBER = 5;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo denseinfo_;
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public boolean hasDenseinfo() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
++ * <pre>
++ *repeated Info info = 4;
++ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++ */
++ public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo() {
++ return denseinfo_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance() : denseinfo_;
++ }
++ /**
++ * <pre>
++ *repeated Info info = 4;
++ * </pre>
++ *
+ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++ */
++ private void setDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ denseinfo_ = value;
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <pre>
++ *repeated Info info = 4;
++ * </pre>
+ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++ */
++ private void setDenseinfo(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder builderForValue) {
++ denseinfo_ = builderForValue.build();
++ bitField0_ |= 0x00000001;
++ }
++ /**
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo() {
+- return denseinfo_;
++ private void mergeDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
++ if (denseinfo_ != null &&
++ denseinfo_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance()) {
++ denseinfo_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.newBuilder(denseinfo_).mergeFrom(value).buildPartial();
++ } else {
++ denseinfo_ = value;
++ }
++ bitField0_ |= 0x00000001;
++ }
++ /**
++ * <pre>
++ *repeated Info info = 4;
++ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++ */
++ private void clearDenseinfo() { denseinfo_ = null;
++ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+
+ public static final int LAT_FIELD_NUMBER = 8;
+- private java.util.List<java.lang.Long> lat_;
++ private com.google.protobuf.Internal.LongList lat_;
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getLatList() {
+ return lat_;
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public int getLatCount() {
+ return lat_.size();
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public long getLat(int index) {
+- return lat_.get(index);
++ return lat_.getLong(index);
+ }
+ private int latMemoizedSerializedSize = -1;
++ private void ensureLatIsMutable() {
++ if (!lat_.isModifiable()) {
++ lat_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lat_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
++ */
++ private void setLat(
++ int index, long value) {
++ ensureLatIsMutable();
++ lat_.setLong(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
++ */
++ private void addLat(long value) {
++ ensureLatIsMutable();
++ lat_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
++ */
++ private void addAllLat(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureLatIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, lat_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
++ */
++ private void clearLat() {
++ lat_ = emptyLongList();
++ }
+
+ public static final int LON_FIELD_NUMBER = 9;
+- private java.util.List<java.lang.Long> lon_;
++ private com.google.protobuf.Internal.LongList lon_;
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getLonList() {
+ return lon_;
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public int getLonCount() {
+ return lon_.size();
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public long getLon(int index) {
+- return lon_.get(index);
++ return lon_.getLong(index);
+ }
+ private int lonMemoizedSerializedSize = -1;
++ private void ensureLonIsMutable() {
++ if (!lon_.isModifiable()) {
++ lon_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lon_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
++ */
++ private void setLon(
++ int index, long value) {
++ ensureLonIsMutable();
++ lon_.setLong(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
++ */
++ private void addLon(long value) {
++ ensureLonIsMutable();
++ lon_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
++ */
++ private void addAllLon(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureLonIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, lon_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
++ */
++ private void clearLon() {
++ lon_ = emptyLongList();
++ }
+
+ public static final int KEYS_VALS_FIELD_NUMBER = 10;
+- private java.util.List<java.lang.Integer> keysVals_;
++ private com.google.protobuf.Internal.IntList keysVals_;
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysValsList() {
+ return keysVals_;
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public int getKeysValsCount() {
+ return keysVals_.size();
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public int getKeysVals(int index) {
+- return keysVals_.get(index);
++ return keysVals_.getInt(index);
+ }
+ private int keysValsMemoizedSerializedSize = -1;
+-
+- private void initFields() {
+- id_ = java.util.Collections.emptyList();
+- denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+- lat_ = java.util.Collections.emptyList();
+- lon_ = java.util.Collections.emptyList();
+- keysVals_ = java.util.Collections.emptyList();
++ private void ensureKeysValsIsMutable() {
++ if (!keysVals_.isModifiable()) {
++ keysVals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keysVals_);
++ }
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++ */
++ private void setKeysVals(
++ int index, int value) {
++ ensureKeysValsIsMutable();
++ keysVals_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++ */
++ private void addKeysVals(int value) {
++ ensureKeysValsIsMutable();
++ keysVals_.addInt(value);
++ }
++ /**
++ * <pre>
++ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++ */
++ private void addAllKeysVals(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureKeysValsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, keysVals_);
++ }
++ /**
++ * <pre>
++ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++ */
++ private void clearKeysVals() {
++ keysVals_ = emptyIntList();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (getIdList().size() > 0) {
+- output.writeRawVarint32(10);
+- output.writeRawVarint32(idMemoizedSerializedSize);
++ output.writeUInt32NoTag(10);
++ output.writeUInt32NoTag(idMemoizedSerializedSize);
+ }
+ for (int i = 0; i < id_.size(); i++) {
+- output.writeSInt64NoTag(id_.get(i));
++ output.writeSInt64NoTag(id_.getLong(i));
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- output.writeMessage(5, denseinfo_);
++ output.writeMessage(5, getDenseinfo());
+ }
+ if (getLatList().size() > 0) {
+- output.writeRawVarint32(66);
+- output.writeRawVarint32(latMemoizedSerializedSize);
++ output.writeUInt32NoTag(66);
++ output.writeUInt32NoTag(latMemoizedSerializedSize);
+ }
+ for (int i = 0; i < lat_.size(); i++) {
+- output.writeSInt64NoTag(lat_.get(i));
++ output.writeSInt64NoTag(lat_.getLong(i));
+ }
+ if (getLonList().size() > 0) {
+- output.writeRawVarint32(74);
+- output.writeRawVarint32(lonMemoizedSerializedSize);
++ output.writeUInt32NoTag(74);
++ output.writeUInt32NoTag(lonMemoizedSerializedSize);
+ }
+ for (int i = 0; i < lon_.size(); i++) {
+- output.writeSInt64NoTag(lon_.get(i));
++ output.writeSInt64NoTag(lon_.getLong(i));
+ }
+ if (getKeysValsList().size() > 0) {
+- output.writeRawVarint32(82);
+- output.writeRawVarint32(keysValsMemoizedSerializedSize);
++ output.writeUInt32NoTag(82);
++ output.writeUInt32NoTag(keysValsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < keysVals_.size(); i++) {
+- output.writeInt32NoTag(keysVals_.get(i));
++ output.writeInt32NoTag(keysVals_.getInt(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -9586,7 +9663,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < id_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(id_.get(i));
++ .computeSInt64SizeNoTag(id_.getLong(i));
+ }
+ size += dataSize;
+ if (!getIdList().isEmpty()) {
+@@ -9598,13 +9675,13 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(5, denseinfo_);
++ .computeMessageSize(5, getDenseinfo());
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < lat_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(lat_.get(i));
++ .computeSInt64SizeNoTag(lat_.getLong(i));
+ }
+ size += dataSize;
+ if (!getLatList().isEmpty()) {
+@@ -9618,7 +9695,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < lon_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(lon_.get(i));
++ .computeSInt64SizeNoTag(lon_.getLong(i));
+ }
+ size += dataSize;
+ if (!getLonList().isEmpty()) {
+@@ -9632,7 +9709,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < keysVals_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeInt32SizeNoTag(keysVals_.get(i));
++ .computeInt32SizeNoTag(keysVals_.getInt(i));
+ }
+ size += dataSize;
+ if (!getKeysValsList().isEmpty()) {
+@@ -9642,703 +9719,690 @@ public final class Osmformat {
+ }
+ keysValsMemoizedSerializedSize = dataSize;
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.DenseNodes}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.DenseNodes)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodesOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- id_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+- denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- lat_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- lon_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- keysVals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes result = new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((bitField0_ & 0x00000001) == 0x00000001)) {
+- id_ = java.util.Collections.unmodifiableList(id_);
+- bitField0_ = (bitField0_ & ~0x00000001);
+- }
+- result.id_ = id_;
+- if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.denseinfo_ = denseinfo_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- lat_ = java.util.Collections.unmodifiableList(lat_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.lat_ = lat_;
+- if (((bitField0_ & 0x00000008) == 0x00000008)) {
+- lon_ = java.util.Collections.unmodifiableList(lon_);
+- bitField0_ = (bitField0_ & ~0x00000008);
+- }
+- result.lon_ = lon_;
+- if (((bitField0_ & 0x00000010) == 0x00000010)) {
+- keysVals_ = java.util.Collections.unmodifiableList(keysVals_);
+- bitField0_ = (bitField0_ & ~0x00000010);
+- }
+- result.keysVals_ = keysVals_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance()) return this;
+- if (!other.id_.isEmpty()) {
+- if (id_.isEmpty()) {
+- id_ = other.id_;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- } else {
+- ensureIdIsMutable();
+- id_.addAll(other.id_);
+- }
+-
+- }
+- if (other.hasDenseinfo()) {
+- mergeDenseinfo(other.getDenseinfo());
+- }
+- if (!other.lat_.isEmpty()) {
+- if (lat_.isEmpty()) {
+- lat_ = other.lat_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureLatIsMutable();
+- lat_.addAll(other.lat_);
+- }
+-
+- }
+- if (!other.lon_.isEmpty()) {
+- if (lon_.isEmpty()) {
+- lon_ = other.lon_;
+- bitField0_ = (bitField0_ & ~0x00000008);
+- } else {
+- ensureLonIsMutable();
+- lon_.addAll(other.lon_);
+- }
+-
+- }
+- if (!other.keysVals_.isEmpty()) {
+- if (keysVals_.isEmpty()) {
+- keysVals_ = other.keysVals_;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- } else {
+- ensureKeysValsIsMutable();
+- keysVals_.addAll(other.keysVals_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private java.util.List<java.lang.Long> id_ = java.util.Collections.emptyList();
+- private void ensureIdIsMutable() {
+- if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+- id_ = new java.util.ArrayList<java.lang.Long>(id_);
+- bitField0_ |= 0x00000001;
+- }
+- }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getIdList() {
+- return java.util.Collections.unmodifiableList(id_);
++ return java.util.Collections.unmodifiableList(
++ instance.getIdList());
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public int getIdCount() {
+- return id_.size();
++ return instance.getIdCount();
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public long getId(int index) {
+- return id_.get(index);
++ return instance.getId(index);
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public Builder setId(
+ int index, long value) {
+- ensureIdIsMutable();
+- id_.set(index, value);
+-
++ copyOnWrite();
++ instance.setId(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public Builder addId(long value) {
+- ensureIdIsMutable();
+- id_.add(value);
+-
++ copyOnWrite();
++ instance.addId(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public Builder addAllId(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureIdIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, id_);
+-
++ copyOnWrite();
++ instance.addAllId(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 id = 1 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 id = 1 [packed = true];</code>
+ */
+ public Builder clearId() {
+- id_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000001);
+-
++ copyOnWrite();
++ instance.clearId();
+ return this;
+ }
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public boolean hasDenseinfo() {
+- return ((bitField0_ & 0x00000002) == 0x00000002);
++ return instance.hasDenseinfo();
+ }
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo() {
+- return denseinfo_;
++ return instance.getDenseinfo();
+ }
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public Builder setDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- denseinfo_ = value;
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.setDenseinfo(value);
+ return this;
+- }
++ }
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public Builder setDenseinfo(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder builderForValue) {
+- denseinfo_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.setDenseinfo(builderForValue);
+ return this;
+ }
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+ public Builder mergeDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
+- if (((bitField0_ & 0x00000002) == 0x00000002) &&
+- denseinfo_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance()) {
+- denseinfo_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.newBuilder(denseinfo_).mergeFrom(value).buildPartial();
+- } else {
+- denseinfo_ = value;
+- }
+-
+- bitField0_ |= 0x00000002;
++ copyOnWrite();
++ instance.mergeDenseinfo(value);
+ return this;
+ }
+ /**
+- * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+- *
+ * <pre>
+ *repeated Info info = 4;
+ * </pre>
++ *
++ * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
+ */
+- public Builder clearDenseinfo() {
+- denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000002);
++ public Builder clearDenseinfo() { copyOnWrite();
++ instance.clearDenseinfo();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> lat_ = java.util.Collections.emptyList();
+- private void ensureLatIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- lat_ = new java.util.ArrayList<java.lang.Long>(lat_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getLatList() {
+- return java.util.Collections.unmodifiableList(lat_);
++ return java.util.Collections.unmodifiableList(
++ instance.getLatList());
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public int getLatCount() {
+- return lat_.size();
++ return instance.getLatCount();
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public long getLat(int index) {
+- return lat_.get(index);
++ return instance.getLat(index);
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public Builder setLat(
+ int index, long value) {
+- ensureLatIsMutable();
+- lat_.set(index, value);
+-
++ copyOnWrite();
++ instance.setLat(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public Builder addLat(long value) {
+- ensureLatIsMutable();
+- lat_.add(value);
+-
++ copyOnWrite();
++ instance.addLat(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public Builder addAllLat(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureLatIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, lat_);
+-
++ copyOnWrite();
++ instance.addAllLat(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lat = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lat = 8 [packed = true];</code>
+ */
+ public Builder clearLat() {
+- lat_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearLat();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> lon_ = java.util.Collections.emptyList();
+- private void ensureLonIsMutable() {
+- if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+- lon_ = new java.util.ArrayList<java.lang.Long>(lon_);
+- bitField0_ |= 0x00000008;
+- }
+- }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getLonList() {
+- return java.util.Collections.unmodifiableList(lon_);
++ return java.util.Collections.unmodifiableList(
++ instance.getLonList());
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public int getLonCount() {
+- return lon_.size();
++ return instance.getLonCount();
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public long getLon(int index) {
+- return lon_.get(index);
++ return instance.getLon(index);
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public Builder setLon(
+ int index, long value) {
+- ensureLonIsMutable();
+- lon_.set(index, value);
+-
++ copyOnWrite();
++ instance.setLon(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public Builder addLon(long value) {
+- ensureLonIsMutable();
+- lon_.add(value);
+-
++ copyOnWrite();
++ instance.addLon(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public Builder addAllLon(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureLonIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, lon_);
+-
++ copyOnWrite();
++ instance.addAllLon(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 lon = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 lon = 9 [packed = true];</code>
+ */
+ public Builder clearLon() {
+- lon_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000008);
+-
++ copyOnWrite();
++ instance.clearLon();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> keysVals_ = java.util.Collections.emptyList();
+- private void ensureKeysValsIsMutable() {
+- if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+- keysVals_ = new java.util.ArrayList<java.lang.Integer>(keysVals_);
+- bitField0_ |= 0x00000010;
+- }
+- }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysValsList() {
+- return java.util.Collections.unmodifiableList(keysVals_);
++ return java.util.Collections.unmodifiableList(
++ instance.getKeysValsList());
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public int getKeysValsCount() {
+- return keysVals_.size();
++ return instance.getKeysValsCount();
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public int getKeysVals(int index) {
+- return keysVals_.get(index);
++ return instance.getKeysVals(index);
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public Builder setKeysVals(
+ int index, int value) {
+- ensureKeysValsIsMutable();
+- keysVals_.set(index, value);
+-
++ copyOnWrite();
++ instance.setKeysVals(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public Builder addKeysVals(int value) {
+- ensureKeysValsIsMutable();
+- keysVals_.add(value);
+-
++ copyOnWrite();
++ instance.addKeysVals(value);
+ return this;
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public Builder addAllKeysVals(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureKeysValsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, keysVals_);
+-
++ copyOnWrite();
++ instance.addAllKeysVals(values);
+ return this;
+ }
+ /**
+- * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+- *
+ * <pre>
+ * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+ * </pre>
++ *
++ * <code>repeated int32 keys_vals = 10 [packed = true];</code>
+ */
+ public Builder clearKeysVals() {
+- keysVals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+-
++ copyOnWrite();
++ instance.clearKeysVals();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.DenseNodes)
+ }
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes();
++ }
++ case IS_INITIALIZED: {
++ return DEFAULT_INSTANCE;
++ }
++ case MAKE_IMMUTABLE: {
++ id_.makeImmutable();
++ lat_.makeImmutable();
++ lon_.makeImmutable();
++ keysVals_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes other = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes) arg1;
++ id_= visitor.visitLongList(id_, other.id_);
++ denseinfo_ = visitor.visitMessage(denseinfo_, other.denseinfo_);
++ lat_= visitor.visitLongList(lat_, other.lat_);
++ lon_= visitor.visitLongList(lon_, other.lon_);
++ keysVals_= visitor.visitIntList(keysVals_, other.keysVals_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ if (!id_.isModifiable()) {
++ id_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(id_);
++ }
++ id_.addLong(input.readSInt64());
++ break;
++ }
++ case 10: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!id_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ id_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(id_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ id_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 42: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000001) == 0x00000001)) {
++ subBuilder = denseinfo_.toBuilder();
++ }
++ denseinfo_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(denseinfo_);
++ denseinfo_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000001;
++ break;
++ }
++ case 64: {
++ if (!lat_.isModifiable()) {
++ lat_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lat_);
++ }
++ lat_.addLong(input.readSInt64());
++ break;
++ }
++ case 66: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!lat_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ lat_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lat_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ lat_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 72: {
++ if (!lon_.isModifiable()) {
++ lon_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lon_);
++ }
++ lon_.addLong(input.readSInt64());
++ break;
++ }
++ case 74: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!lon_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ lon_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(lon_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ lon_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 80: {
++ if (!keysVals_.isModifiable()) {
++ keysVals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keysVals_);
++ }
++ keysVals_.addInt(input.readInt32());
++ break;
++ }
++ case 82: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!keysVals_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ keysVals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keysVals_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ keysVals_.addInt(input.readInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
+
++ // @@protoc_insertion_point(class_scope:OSMPBF.DenseNodes)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new DenseNodes(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new DenseNodes();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.DenseNodes)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<DenseNodes> PARSER;
++
++ public static com.google.protobuf.Parser<DenseNodes> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface WayOrBuilder extends
+@@ -10355,27 +10419,27 @@ public final class Osmformat {
+ long getId();
+
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getKeysList();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeysCount();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeys(int index);
+
+@@ -10402,203 +10466,43 @@ public final class Osmformat {
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getRefsList();
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ int getRefsCount();
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ long getRefs(int index);
+ }
+ /**
+ * Protobuf type {@code OSMPBF.Way}
+ */
+- public static final class Way extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class Way extends
++ com.google.protobuf.GeneratedMessageLite<
++ Way, Way.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.Way)
+ WayOrBuilder {
+- // Use Way.newBuilder() to construct.
+- private Way(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private Way(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final Way defaultInstance;
+- public static Way getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public Way getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private Way(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- id_ = input.readInt64();
+- break;
+- }
+- case 16: {
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- keys_.add(input.readUInt32());
+- break;
+- }
+- case 18: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- keys_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 24: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- vals_.add(input.readUInt32());
+- break;
+- }
+- case 26: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- vals_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 34: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- subBuilder = info_.toBuilder();
+- }
+- info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(info_);
+- info_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000002;
+- break;
+- }
+- case 64: {
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- refs_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- refs_.add(input.readSInt64());
+- break;
+- }
+- case 66: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
+- refs_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- refs_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- }
+- if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- refs_ = java.util.Collections.unmodifiableList(refs_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<Way> PARSER =
+- new com.google.protobuf.AbstractParser<Way>() {
+- public Way parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new Way(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<Way> getParserForType() {
+- return PARSER;
++ private Way() {
++ keys_ = emptyIntList();
++ vals_ = emptyIntList();
++ refs_ = emptyLongList();
+ }
+-
+ private int bitField0_;
+ public static final int ID_FIELD_NUMBER = 1;
+ private long id_;
+@@ -10614,44 +10518,110 @@ public final class Osmformat {
+ public long getId() {
+ return id_;
+ }
++ /**
++ * <code>required int64 id = 1;</code>
++ */
++ private void setId(long value) {
++ bitField0_ |= 0x00000001;
++ id_ = value;
++ }
++ /**
++ * <code>required int64 id = 1;</code>
++ */
++ private void clearId() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ id_ = 0L;
++ }
+
+ public static final int KEYS_FIELD_NUMBER = 2;
+- private java.util.List<java.lang.Integer> keys_;
++ private com.google.protobuf.Internal.IntList keys_;
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+ return keys_;
+ }
+ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ public int getKeysCount() {
++ return keys_.size();
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ public int getKeys(int index) {
++ return keys_.getInt(index);
++ }
++ private int keysMemoizedSerializedSize = -1;
++ private void ensureKeysIsMutable() {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
+ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void setKeys(
++ int index, int value) {
++ ensureKeysIsMutable();
++ keys_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
+ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void addKeys(int value) {
++ ensureKeysIsMutable();
++ keys_.addInt(value);
++ }
++ /**
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+- public int getKeysCount() {
+- return keys_.size();
++ private void addAllKeys(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureKeysIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, keys_);
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+- public int getKeys(int index) {
+- return keys_.get(index);
++ private void clearKeys() {
++ keys_ = emptyIntList();
+ }
+- private int keysMemoizedSerializedSize = -1;
+
+ public static final int VALS_FIELD_NUMBER = 3;
+- private java.util.List<java.lang.Integer> vals_;
++ private com.google.protobuf.Internal.IntList vals_;
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+@@ -10669,9 +10639,45 @@ public final class Osmformat {
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return vals_.getInt(index);
+ }
+ private int valsMemoizedSerializedSize = -1;
++ private void ensureValsIsMutable() {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void setVals(
++ int index, int value) {
++ ensureValsIsMutable();
++ vals_.setInt(index, value);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addVals(int value) {
++ ensureValsIsMutable();
++ vals_.addInt(value);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addAllVals(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureValsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, vals_);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void clearVals() {
++ vals_ = emptyIntList();
++ }
+
+ public static final int INFO_FIELD_NUMBER = 4;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
+@@ -10685,63 +10691,131 @@ public final class Osmformat {
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return info_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance() : info_;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ info_ = value;
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
++ info_ = builderForValue.build();
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (info_ != null &&
++ info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
++ info_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
++ } else {
++ info_ = value;
++ }
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void clearInfo() { info_ = null;
++ bitField0_ = (bitField0_ & ~0x00000002);
+ }
+
+ public static final int REFS_FIELD_NUMBER = 8;
+- private java.util.List<java.lang.Long> refs_;
++ private com.google.protobuf.Internal.LongList refs_;
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getRefsList() {
+ return refs_;
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public int getRefsCount() {
+ return refs_.size();
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public long getRefs(int index) {
+- return refs_.get(index);
++ return refs_.getLong(index);
+ }
+ private int refsMemoizedSerializedSize = -1;
+-
+- private void initFields() {
+- id_ = 0L;
+- keys_ = java.util.Collections.emptyList();
+- vals_ = java.util.Collections.emptyList();
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- refs_ = java.util.Collections.emptyList();
++ private void ensureRefsIsMutable() {
++ if (!refs_.isModifiable()) {
++ refs_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(refs_);
++ }
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasId()) {
+- memoizedIsInitialized = 0;
+- return false;
+- }
+- memoizedIsInitialized = 1;
+- return true;
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
++ */
++ private void setRefs(
++ int index, long value) {
++ ensureRefsIsMutable();
++ refs_.setLong(index, value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
++ */
++ private void addRefs(long value) {
++ ensureRefsIsMutable();
++ refs_.addLong(value);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
++ */
++ private void addAllRefs(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureRefsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, refs_);
++ }
++ /**
++ * <pre>
++ * DELTA coded
++ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
++ */
++ private void clearRefs() {
++ refs_ = emptyLongList();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+@@ -10751,33 +10825,32 @@ public final class Osmformat {
+ output.writeInt64(1, id_);
+ }
+ if (getKeysList().size() > 0) {
+- output.writeRawVarint32(18);
+- output.writeRawVarint32(keysMemoizedSerializedSize);
++ output.writeUInt32NoTag(18);
++ output.writeUInt32NoTag(keysMemoizedSerializedSize);
+ }
+ for (int i = 0; i < keys_.size(); i++) {
+- output.writeUInt32NoTag(keys_.get(i));
++ output.writeUInt32NoTag(keys_.getInt(i));
+ }
+ if (getValsList().size() > 0) {
+- output.writeRawVarint32(26);
+- output.writeRawVarint32(valsMemoizedSerializedSize);
++ output.writeUInt32NoTag(26);
++ output.writeUInt32NoTag(valsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < vals_.size(); i++) {
+- output.writeUInt32NoTag(vals_.get(i));
++ output.writeUInt32NoTag(vals_.getInt(i));
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- output.writeMessage(4, info_);
++ output.writeMessage(4, getInfo());
+ }
+ if (getRefsList().size() > 0) {
+- output.writeRawVarint32(66);
+- output.writeRawVarint32(refsMemoizedSerializedSize);
++ output.writeUInt32NoTag(66);
++ output.writeUInt32NoTag(refsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < refs_.size(); i++) {
+- output.writeSInt64NoTag(refs_.get(i));
++ output.writeSInt64NoTag(refs_.getLong(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -10791,7 +10864,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < keys_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(keys_.get(i));
++ .computeUInt32SizeNoTag(keys_.getInt(i));
+ }
+ size += dataSize;
+ if (!getKeysList().isEmpty()) {
+@@ -10805,7 +10878,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < vals_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(vals_.get(i));
++ .computeUInt32SizeNoTag(vals_.getInt(i));
+ }
+ size += dataSize;
+ if (!getValsList().isEmpty()) {
+@@ -10817,13 +10890,13 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(4, info_);
++ .computeMessageSize(4, getInfo());
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < refs_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(refs_.get(i));
++ .computeSInt64SizeNoTag(refs_.getLong(i));
+ }
+ size += dataSize;
+ if (!getRefsList().isEmpty()) {
+@@ -10833,399 +10906,240 @@ public final class Osmformat {
+ }
+ refsMemoizedSerializedSize = dataSize;
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Way prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.Way}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Way, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Way, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.Way)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.WayOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Way.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- id_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- refs_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+- return this;
+- }
+-
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Way getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.Way.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Way build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Way result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Way buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Way result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Way(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.id_ = id_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.keys_ = keys_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.vals_ = vals_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.info_ = info_;
+- if (((bitField0_ & 0x00000010) == 0x00000010)) {
+- refs_ = java.util.Collections.unmodifiableList(refs_);
+- bitField0_ = (bitField0_ & ~0x00000010);
+- }
+- result.refs_ = refs_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Way other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Way.getDefaultInstance()) return this;
+- if (other.hasId()) {
+- setId(other.getId());
+- }
+- if (!other.keys_.isEmpty()) {
+- if (keys_.isEmpty()) {
+- keys_ = other.keys_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensureKeysIsMutable();
+- keys_.addAll(other.keys_);
+- }
+-
+- }
+- if (!other.vals_.isEmpty()) {
+- if (vals_.isEmpty()) {
+- vals_ = other.vals_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureValsIsMutable();
+- vals_.addAll(other.vals_);
+- }
+-
+- }
+- if (other.hasInfo()) {
+- mergeInfo(other.getInfo());
+- }
+- if (!other.refs_.isEmpty()) {
+- if (refs_.isEmpty()) {
+- refs_ = other.refs_;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- } else {
+- ensureRefsIsMutable();
+- refs_.addAll(other.refs_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasId()) {
+-
+- return false;
+- }
+- return true;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Way parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Way) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private long id_ ;
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public boolean hasId() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasId();
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public long getId() {
+- return id_;
++ return instance.getId();
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public Builder setId(long value) {
+- bitField0_ |= 0x00000001;
+- id_ = value;
+-
++ copyOnWrite();
++ instance.setId(value);
+ return this;
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public Builder clearId() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- id_ = 0L;
+-
++ copyOnWrite();
++ instance.clearId();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+- private void ensureKeysIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+- return java.util.Collections.unmodifiableList(keys_);
++ return java.util.Collections.unmodifiableList(
++ instance.getKeysList());
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeysCount() {
+- return keys_.size();
++ return instance.getKeysCount();
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeys(int index) {
+- return keys_.get(index);
++ return instance.getKeys(index);
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder setKeys(
+ int index, int value) {
+- ensureKeysIsMutable();
+- keys_.set(index, value);
+-
++ copyOnWrite();
++ instance.setKeys(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addKeys(int value) {
+- ensureKeysIsMutable();
+- keys_.add(value);
+-
++ copyOnWrite();
++ instance.addKeys(value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addAllKeys(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureKeysIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, keys_);
+-
++ copyOnWrite();
++ instance.addAllKeys(values);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder clearKeys() {
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearKeys();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+- private void ensureValsIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getValsList() {
+- return java.util.Collections.unmodifiableList(vals_);
++ return java.util.Collections.unmodifiableList(
++ instance.getValsList());
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getValsCount() {
+- return vals_.size();
++ return instance.getValsCount();
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return instance.getVals(index);
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder setVals(
+ int index, int value) {
+- ensureValsIsMutable();
+- vals_.set(index, value);
+-
++ copyOnWrite();
++ instance.setVals(index, value);
+ return this;
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder addVals(int value) {
+- ensureValsIsMutable();
+- vals_.add(value);
+-
++ copyOnWrite();
++ instance.addVals(value);
+ return this;
+ }
+ /**
+@@ -11233,185 +11147,342 @@ public final class Osmformat {
+ */
+ public Builder addAllVals(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureValsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, vals_);
+-
++ copyOnWrite();
++ instance.addAllVals(values);
+ return this;
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder clearVals() {
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearVals();
+ return this;
+ }
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public boolean hasInfo() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasInfo();
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return instance.getInfo();
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- info_ = value;
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(value);
+ return this;
+- }
++ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+- info_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(builderForValue);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (((bitField0_ & 0x00000008) == 0x00000008) &&
+- info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+- info_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
+- } else {
+- info_ = value;
+- }
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.mergeInfo(value);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+- public Builder clearInfo() {
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000008);
++ public Builder clearInfo() { copyOnWrite();
++ instance.clearInfo();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> refs_ = java.util.Collections.emptyList();
+- private void ensureRefsIsMutable() {
+- if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+- refs_ = new java.util.ArrayList<java.lang.Long>(refs_);
+- bitField0_ |= 0x00000010;
+- }
+- }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getRefsList() {
+- return java.util.Collections.unmodifiableList(refs_);
++ return java.util.Collections.unmodifiableList(
++ instance.getRefsList());
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public int getRefsCount() {
+- return refs_.size();
++ return instance.getRefsCount();
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public long getRefs(int index) {
+- return refs_.get(index);
++ return instance.getRefs(index);
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public Builder setRefs(
+ int index, long value) {
+- ensureRefsIsMutable();
+- refs_.set(index, value);
+-
++ copyOnWrite();
++ instance.setRefs(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public Builder addRefs(long value) {
+- ensureRefsIsMutable();
+- refs_.add(value);
+-
++ copyOnWrite();
++ instance.addRefs(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public Builder addAllRefs(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureRefsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, refs_);
+-
++ copyOnWrite();
++ instance.addAllRefs(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 refs = 8 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA coded
+ * </pre>
++ *
++ * <code>repeated sint64 refs = 8 [packed = true];</code>
+ */
+ public Builder clearRefs() {
+- refs_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+-
++ copyOnWrite();
++ instance.clearRefs();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.Way)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.Way();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasId()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ keys_.makeImmutable();
++ vals_.makeImmutable();
++ refs_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Way other = (org.openstreetmap.osmosis.osmbinary.Osmformat.Way) arg1;
++ id_ = visitor.visitLong(
++ hasId(), id_,
++ other.hasId(), other.id_);
++ keys_= visitor.visitIntList(keys_, other.keys_);
++ vals_= visitor.visitIntList(vals_, other.vals_);
++ info_ = visitor.visitMessage(info_, other.info_);
++ refs_= visitor.visitLongList(refs_, other.refs_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ id_ = input.readInt64();
++ break;
++ }
++ case 16: {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ keys_.addInt(input.readUInt32());
++ break;
++ }
++ case 18: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!keys_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ keys_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 24: {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ vals_.addInt(input.readUInt32());
++ break;
++ }
++ case 26: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!vals_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ vals_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 34: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000002) == 0x00000002)) {
++ subBuilder = info_.toBuilder();
++ }
++ info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(info_);
++ info_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000002;
++ break;
++ }
++ case 64: {
++ if (!refs_.isModifiable()) {
++ refs_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(refs_);
++ }
++ refs_.addLong(input.readSInt64());
++ break;
++ }
++ case 66: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!refs_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ refs_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(refs_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ refs_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.Way.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
+
++
++ // @@protoc_insertion_point(class_scope:OSMPBF.Way)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.Way DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new Way(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new Way();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.Way)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<Way> PARSER;
++
++ public static com.google.protobuf.Parser<Way> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+ public interface RelationOrBuilder extends
+@@ -11428,27 +11499,27 @@ public final class Osmformat {
+ long getId();
+
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getKeysList();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeysCount();
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ int getKeys(int index);
+
+@@ -11474,53 +11545,53 @@ public final class Osmformat {
+ */
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+
+- /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
++ /**
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ java.util.List<java.lang.Integer> getRolesSidList();
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ int getRolesSidCount();
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ int getRolesSid(int index);
+
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ java.util.List<java.lang.Long> getMemidsList();
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ int getMemidsCount();
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ long getMemids(int index);
+
+@@ -11540,238 +11611,18 @@ public final class Osmformat {
+ /**
+ * Protobuf type {@code OSMPBF.Relation}
+ */
+- public static final class Relation extends
+- com.google.protobuf.GeneratedMessageLite implements
++ public static final class Relation extends
++ com.google.protobuf.GeneratedMessageLite<
++ Relation, Relation.Builder> implements
+ // @@protoc_insertion_point(message_implements:OSMPBF.Relation)
+ RelationOrBuilder {
+- // Use Relation.newBuilder() to construct.
+- private Relation(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+- super(builder);
+- this.unknownFields = builder.getUnknownFields();
+- }
+- private Relation(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
+-
+- private static final Relation defaultInstance;
+- public static Relation getDefaultInstance() {
+- return defaultInstance;
+- }
+-
+- public Relation getDefaultInstanceForType() {
+- return defaultInstance;
+- }
+-
+- private final com.google.protobuf.ByteString unknownFields;
+- private Relation(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- initFields();
+- int mutable_bitField0_ = 0;
+- com.google.protobuf.ByteString.Output unknownFieldsOutput =
+- com.google.protobuf.ByteString.newOutput();
+- com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+- com.google.protobuf.CodedOutputStream.newInstance(
+- unknownFieldsOutput);
+- try {
+- boolean done = false;
+- while (!done) {
+- int tag = input.readTag();
+- switch (tag) {
+- case 0:
+- done = true;
+- break;
+- default: {
+- if (!parseUnknownField(input, unknownFieldsCodedOutput,
+- extensionRegistry, tag)) {
+- done = true;
+- }
+- break;
+- }
+- case 8: {
+- bitField0_ |= 0x00000001;
+- id_ = input.readInt64();
+- break;
+- }
+- case 16: {
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- keys_.add(input.readUInt32());
+- break;
+- }
+- case 18: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000002;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- keys_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 24: {
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- vals_.add(input.readUInt32());
+- break;
+- }
+- case 26: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000004;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- vals_.add(input.readUInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 34: {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- subBuilder = info_.toBuilder();
+- }
+- info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
+- if (subBuilder != null) {
+- subBuilder.mergeFrom(info_);
+- info_ = subBuilder.buildPartial();
+- }
+- bitField0_ |= 0x00000002;
+- break;
+- }
+- case 64: {
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- rolesSid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- rolesSid_.add(input.readInt32());
+- break;
+- }
+- case 66: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
+- rolesSid_ = new java.util.ArrayList<java.lang.Integer>();
+- mutable_bitField0_ |= 0x00000010;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- rolesSid_.add(input.readInt32());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 72: {
+- if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
+- memids_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000020;
+- }
+- memids_.add(input.readSInt64());
+- break;
+- }
+- case 74: {
+- int length = input.readRawVarint32();
+- int limit = input.pushLimit(length);
+- if (!((mutable_bitField0_ & 0x00000020) == 0x00000020) && input.getBytesUntilLimit() > 0) {
+- memids_ = new java.util.ArrayList<java.lang.Long>();
+- mutable_bitField0_ |= 0x00000020;
+- }
+- while (input.getBytesUntilLimit() > 0) {
+- memids_.add(input.readSInt64());
+- }
+- input.popLimit(limit);
+- break;
+- }
+- case 80: {
+- int rawValue = input.readEnum();
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
+- if (value == null) {
+- unknownFieldsCodedOutput.writeRawVarint32(tag);
+- unknownFieldsCodedOutput.writeRawVarint32(rawValue);
+- } else {
+- if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+- types_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>();
+- mutable_bitField0_ |= 0x00000040;
+- }
+- types_.add(value);
+- }
+- break;
+- }
+- case 82: {
+- int length = input.readRawVarint32();
+- int oldLimit = input.pushLimit(length);
+- while(input.getBytesUntilLimit() > 0) {
+- int rawValue = input.readEnum();
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
+- if (value == null) {
+- unknownFieldsCodedOutput.writeRawVarint32(tag);
+- unknownFieldsCodedOutput.writeRawVarint32(rawValue);
+- } else {
+- if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+- types_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>();
+- mutable_bitField0_ |= 0x00000040;
+- }
+- types_.add(value);
+- }
+- }
+- input.popLimit(oldLimit);
+- break;
+- }
+- }
+- }
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- throw e.setUnfinishedMessage(this);
+- } catch (java.io.IOException e) {
+- throw new com.google.protobuf.InvalidProtocolBufferException(
+- e.getMessage()).setUnfinishedMessage(this);
+- } finally {
+- if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- }
+- if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- }
+- if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
+- rolesSid_ = java.util.Collections.unmodifiableList(rolesSid_);
+- }
+- if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
+- memids_ = java.util.Collections.unmodifiableList(memids_);
+- }
+- if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+- types_ = java.util.Collections.unmodifiableList(types_);
+- }
+- try {
+- unknownFieldsCodedOutput.flush();
+- } catch (java.io.IOException e) {
+- // Should not happen
+- } finally {
+- unknownFields = unknownFieldsOutput.toByteString();
+- }
+- makeExtensionsImmutable();
+- }
+- }
+- public static com.google.protobuf.Parser<Relation> PARSER =
+- new com.google.protobuf.AbstractParser<Relation>() {
+- public Relation parsePartialFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws com.google.protobuf.InvalidProtocolBufferException {
+- return new Relation(input, extensionRegistry);
+- }
+- };
+-
+- @java.lang.Override
+- public com.google.protobuf.Parser<Relation> getParserForType() {
+- return PARSER;
++ private Relation() {
++ keys_ = emptyIntList();
++ vals_ = emptyIntList();
++ rolesSid_ = emptyIntList();
++ memids_ = emptyLongList();
++ types_ = emptyIntList();
+ }
+-
+ /**
+ * Protobuf enum {@code OSMPBF.Relation.MemberType}
+ */
+@@ -11780,15 +11631,15 @@ public final class Osmformat {
+ /**
+ * <code>NODE = 0;</code>
+ */
+- NODE(0, 0),
++ NODE(0),
+ /**
+ * <code>WAY = 1;</code>
+ */
+- WAY(1, 1),
++ WAY(1),
+ /**
+ * <code>RELATION = 2;</code>
+ */
+- RELATION(2, 2),
++ RELATION(2),
+ ;
+
+ /**
+@@ -11805,9 +11656,19 @@ public final class Osmformat {
+ public static final int RELATION_VALUE = 2;
+
+
+- public final int getNumber() { return value; }
++ public final int getNumber() {
++ return value;
++ }
+
++ /**
++ * @deprecated Use {@link #forNumber(int)} instead.
++ */
++ @java.lang.Deprecated
+ public static MemberType valueOf(int value) {
++ return forNumber(value);
++ }
++
++ public static MemberType forNumber(int value) {
+ switch (value) {
+ case 0: return NODE;
+ case 1: return WAY;
+@@ -11820,17 +11681,17 @@ public final class Osmformat {
+ internalGetValueMap() {
+ return internalValueMap;
+ }
+- private static com.google.protobuf.Internal.EnumLiteMap<MemberType>
+- internalValueMap =
++ private static final com.google.protobuf.Internal.EnumLiteMap<
++ MemberType> internalValueMap =
+ new com.google.protobuf.Internal.EnumLiteMap<MemberType>() {
+ public MemberType findValueByNumber(int number) {
+- return MemberType.valueOf(number);
++ return MemberType.forNumber(number);
+ }
+ };
+
+ private final int value;
+
+- private MemberType(int index, int value) {
++ private MemberType(int value) {
+ this.value = value;
+ }
+
+@@ -11852,44 +11713,110 @@ public final class Osmformat {
+ public long getId() {
+ return id_;
+ }
++ /**
++ * <code>required int64 id = 1;</code>
++ */
++ private void setId(long value) {
++ bitField0_ |= 0x00000001;
++ id_ = value;
++ }
++ /**
++ * <code>required int64 id = 1;</code>
++ */
++ private void clearId() {
++ bitField0_ = (bitField0_ & ~0x00000001);
++ id_ = 0L;
++ }
+
+ public static final int KEYS_FIELD_NUMBER = 2;
+- private java.util.List<java.lang.Integer> keys_;
++ private com.google.protobuf.Internal.IntList keys_;
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+ return keys_;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeysCount() {
+ return keys_.size();
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeys(int index) {
+- return keys_.get(index);
++ return keys_.getInt(index);
+ }
+ private int keysMemoizedSerializedSize = -1;
++ private void ensureKeysIsMutable() {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void setKeys(
++ int index, int value) {
++ ensureKeysIsMutable();
++ keys_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void addKeys(int value) {
++ ensureKeysIsMutable();
++ keys_.addInt(value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void addAllKeys(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureKeysIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, keys_);
++ }
++ /**
++ * <pre>
++ * Parallel arrays.
++ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
++ */
++ private void clearKeys() {
++ keys_ = emptyIntList();
++ }
+
+ public static final int VALS_FIELD_NUMBER = 3;
+- private java.util.List<java.lang.Integer> vals_;
++ private com.google.protobuf.Internal.IntList vals_;
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+@@ -11907,9 +11834,45 @@ public final class Osmformat {
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return vals_.getInt(index);
+ }
+ private int valsMemoizedSerializedSize = -1;
++ private void ensureValsIsMutable() {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void setVals(
++ int index, int value) {
++ ensureValsIsMutable();
++ vals_.setInt(index, value);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addVals(int value) {
++ ensureValsIsMutable();
++ vals_.addInt(value);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void addAllVals(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureValsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, vals_);
++ }
++ /**
++ * <code>repeated uint32 vals = 3 [packed = true];</code>
++ */
++ private void clearVals() {
++ vals_ = emptyIntList();
++ }
+
+ public static final int INFO_FIELD_NUMBER = 4;
+ private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
+@@ -11923,86 +11886,237 @@ public final class Osmformat {
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return info_ == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance() : info_;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ info_ = value;
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void setInfo(
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
++ info_ = builderForValue.build();
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
++ if (info_ != null &&
++ info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
++ info_ =
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
++ } else {
++ info_ = value;
++ }
++ bitField0_ |= 0x00000002;
++ }
++ /**
++ * <code>optional .OSMPBF.Info info = 4;</code>
++ */
++ private void clearInfo() { info_ = null;
++ bitField0_ = (bitField0_ & ~0x00000002);
+ }
+
+ public static final int ROLES_SID_FIELD_NUMBER = 8;
+- private java.util.List<java.lang.Integer> rolesSid_;
++ private com.google.protobuf.Internal.IntList rolesSid_;
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getRolesSidList() {
+ return rolesSid_;
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public int getRolesSidCount() {
+ return rolesSid_.size();
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+- * Parallel arrays
++ * Parallel arrays
++ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++ */
++ public int getRolesSid(int index) {
++ return rolesSid_.getInt(index);
++ }
++ private int rolesSidMemoizedSerializedSize = -1;
++ private void ensureRolesSidIsMutable() {
++ if (!rolesSid_.isModifiable()) {
++ rolesSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(rolesSid_);
++ }
++ }
++ /**
++ * <pre>
++ * Parallel arrays
++ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++ */
++ private void setRolesSid(
++ int index, int value) {
++ ensureRolesSidIsMutable();
++ rolesSid_.setInt(index, value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays
++ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++ */
++ private void addRolesSid(int value) {
++ ensureRolesSidIsMutable();
++ rolesSid_.addInt(value);
++ }
++ /**
++ * <pre>
++ * Parallel arrays
++ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++ */
++ private void addAllRolesSid(
++ java.lang.Iterable<? extends java.lang.Integer> values) {
++ ensureRolesSidIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, rolesSid_);
++ }
++ /**
++ * <pre>
++ * Parallel arrays
++ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++ */
++ private void clearRolesSid() {
++ rolesSid_ = emptyIntList();
++ }
++
++ public static final int MEMIDS_FIELD_NUMBER = 9;
++ private com.google.protobuf.Internal.LongList memids_;
++ /**
++ * <pre>
++ * DELTA encoded
++ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
++ */
++ public java.util.List<java.lang.Long>
++ getMemidsList() {
++ return memids_;
++ }
++ /**
++ * <pre>
++ * DELTA encoded
++ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
++ */
++ public int getMemidsCount() {
++ return memids_.size();
++ }
++ /**
++ * <pre>
++ * DELTA encoded
++ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
++ */
++ public long getMemids(int index) {
++ return memids_.getLong(index);
++ }
++ private int memidsMemoizedSerializedSize = -1;
++ private void ensureMemidsIsMutable() {
++ if (!memids_.isModifiable()) {
++ memids_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(memids_);
++ }
++ }
++ /**
++ * <pre>
++ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+- public int getRolesSid(int index) {
+- return rolesSid_.get(index);
++ private void setMemids(
++ int index, long value) {
++ ensureMemidsIsMutable();
++ memids_.setLong(index, value);
+ }
+- private int rolesSidMemoizedSerializedSize = -1;
+-
+- public static final int MEMIDS_FIELD_NUMBER = 9;
+- private java.util.List<java.lang.Long> memids_;
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+- public java.util.List<java.lang.Long>
+- getMemidsList() {
+- return memids_;
++ private void addMemids(long value) {
++ ensureMemidsIsMutable();
++ memids_.addLong(value);
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+- public int getMemidsCount() {
+- return memids_.size();
++ private void addAllMemids(
++ java.lang.Iterable<? extends java.lang.Long> values) {
++ ensureMemidsIsMutable();
++ com.google.protobuf.AbstractMessageLite.addAll(
++ values, memids_);
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+- public long getMemids(int index) {
+- return memids_.get(index);
++ private void clearMemids() {
++ memids_ = emptyLongList();
+ }
+- private int memidsMemoizedSerializedSize = -1;
+
+ public static final int TYPES_FIELD_NUMBER = 10;
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> types_;
++ private com.google.protobuf.Internal.IntList types_;
++ private static final com.google.protobuf.Internal.ListAdapter.Converter<
++ java.lang.Integer, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> types_converter_ =
++ new com.google.protobuf.Internal.ListAdapter.Converter<
++ java.lang.Integer, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>() {
++ public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType convert(java.lang.Integer from) {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType result = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.forNumber(from);
++ return result == null ? org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.NODE : result;
++ }
++ };
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> getTypesList() {
+- return types_;
++ return new com.google.protobuf.Internal.ListAdapter<
++ java.lang.Integer, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>(types_, types_converter_);
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+@@ -12014,31 +12128,51 @@ public final class Osmformat {
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType getTypes(int index) {
+- return types_.get(index);
++ return types_converter_.convert(types_.getInt(index));
+ }
+ private int typesMemoizedSerializedSize;
+-
+- private void initFields() {
+- id_ = 0L;
+- keys_ = java.util.Collections.emptyList();
+- vals_ = java.util.Collections.emptyList();
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- rolesSid_ = java.util.Collections.emptyList();
+- memids_ = java.util.Collections.emptyList();
+- types_ = java.util.Collections.emptyList();
++ private void ensureTypesIsMutable() {
++ if (!types_.isModifiable()) {
++ types_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(types_);
++ }
+ }
+- private byte memoizedIsInitialized = -1;
+- public final boolean isInitialized() {
+- byte isInitialized = memoizedIsInitialized;
+- if (isInitialized == 1) return true;
+- if (isInitialized == 0) return false;
+-
+- if (!hasId()) {
+- memoizedIsInitialized = 0;
+- return false;
++ /**
++ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++ */
++ private void setTypes(
++ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureTypesIsMutable();
++ types_.setInt(index, value.getNumber());
++ }
++ /**
++ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++ */
++ private void addTypes(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
++ if (value == null) {
++ throw new NullPointerException();
++ }
++ ensureTypesIsMutable();
++ types_.addInt(value.getNumber());
++ }
++ /**
++ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++ */
++ private void addAllTypes(
++ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> values) {
++ ensureTypesIsMutable();
++ for (org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value : values) {
++ types_.addInt(value.getNumber());
+ }
+- memoizedIsInitialized = 1;
+- return true;
++ }
++ /**
++ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++ */
++ private void clearTypes() {
++ types_ = emptyIntList();
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+@@ -12048,47 +12182,46 @@ public final class Osmformat {
+ output.writeInt64(1, id_);
+ }
+ if (getKeysList().size() > 0) {
+- output.writeRawVarint32(18);
+- output.writeRawVarint32(keysMemoizedSerializedSize);
++ output.writeUInt32NoTag(18);
++ output.writeUInt32NoTag(keysMemoizedSerializedSize);
+ }
+ for (int i = 0; i < keys_.size(); i++) {
+- output.writeUInt32NoTag(keys_.get(i));
++ output.writeUInt32NoTag(keys_.getInt(i));
+ }
+ if (getValsList().size() > 0) {
+- output.writeRawVarint32(26);
+- output.writeRawVarint32(valsMemoizedSerializedSize);
++ output.writeUInt32NoTag(26);
++ output.writeUInt32NoTag(valsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < vals_.size(); i++) {
+- output.writeUInt32NoTag(vals_.get(i));
++ output.writeUInt32NoTag(vals_.getInt(i));
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- output.writeMessage(4, info_);
++ output.writeMessage(4, getInfo());
+ }
+ if (getRolesSidList().size() > 0) {
+- output.writeRawVarint32(66);
+- output.writeRawVarint32(rolesSidMemoizedSerializedSize);
++ output.writeUInt32NoTag(66);
++ output.writeUInt32NoTag(rolesSidMemoizedSerializedSize);
+ }
+ for (int i = 0; i < rolesSid_.size(); i++) {
+- output.writeInt32NoTag(rolesSid_.get(i));
++ output.writeInt32NoTag(rolesSid_.getInt(i));
+ }
+ if (getMemidsList().size() > 0) {
+- output.writeRawVarint32(74);
+- output.writeRawVarint32(memidsMemoizedSerializedSize);
++ output.writeUInt32NoTag(74);
++ output.writeUInt32NoTag(memidsMemoizedSerializedSize);
+ }
+ for (int i = 0; i < memids_.size(); i++) {
+- output.writeSInt64NoTag(memids_.get(i));
++ output.writeSInt64NoTag(memids_.getLong(i));
+ }
+ if (getTypesList().size() > 0) {
+- output.writeRawVarint32(82);
+- output.writeRawVarint32(typesMemoizedSerializedSize);
++ output.writeUInt32NoTag(82);
++ output.writeUInt32NoTag(typesMemoizedSerializedSize);
+ }
+ for (int i = 0; i < types_.size(); i++) {
+- output.writeEnumNoTag(types_.get(i).getNumber());
++ output.writeEnumNoTag(types_.getInt(i));
+ }
+- output.writeRawBytes(unknownFields);
++ unknownFields.writeTo(output);
+ }
+
+- private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+@@ -12102,7 +12235,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < keys_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(keys_.get(i));
++ .computeUInt32SizeNoTag(keys_.getInt(i));
+ }
+ size += dataSize;
+ if (!getKeysList().isEmpty()) {
+@@ -12116,7 +12249,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < vals_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeUInt32SizeNoTag(vals_.get(i));
++ .computeUInt32SizeNoTag(vals_.getInt(i));
+ }
+ size += dataSize;
+ if (!getValsList().isEmpty()) {
+@@ -12128,13 +12261,13 @@ public final class Osmformat {
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+- .computeMessageSize(4, info_);
++ .computeMessageSize(4, getInfo());
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < rolesSid_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeInt32SizeNoTag(rolesSid_.get(i));
++ .computeInt32SizeNoTag(rolesSid_.getInt(i));
+ }
+ size += dataSize;
+ if (!getRolesSidList().isEmpty()) {
+@@ -12148,7 +12281,7 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < memids_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeSInt64SizeNoTag(memids_.get(i));
++ .computeSInt64SizeNoTag(memids_.getLong(i));
+ }
+ size += dataSize;
+ if (!getMemidsList().isEmpty()) {
+@@ -12162,441 +12295,248 @@ public final class Osmformat {
+ int dataSize = 0;
+ for (int i = 0; i < types_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+- .computeEnumSizeNoTag(types_.get(i).getNumber());
++ .computeEnumSizeNoTag(types_.getInt(i));
+ }
+ size += dataSize;
+ if (!getTypesList().isEmpty()) { size += 1;
+ size += com.google.protobuf.CodedOutputStream
+- .computeRawVarint32Size(dataSize);
++ .computeUInt32SizeNoTag(dataSize);
+ }typesMemoizedSerializedSize = dataSize;
+ }
+- size += unknownFields.size();
++ size += unknownFields.getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+- private static final long serialVersionUID = 0L;
+- @java.lang.Override
+- protected java.lang.Object writeReplace()
+- throws java.io.ObjectStreamException {
+- return super.writeReplace();
+- }
+-
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+- return PARSER.parseFrom(data, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, data, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseDelimitedFrom(input, extensionRegistry);
++ return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input);
+ }
+ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+- return PARSER.parseFrom(input, extensionRegistry);
++ return com.google.protobuf.GeneratedMessageLite.parseFrom(
++ DEFAULT_INSTANCE, input, extensionRegistry);
+ }
+
+- public static Builder newBuilder() { return Builder.create(); }
+- public Builder newBuilderForType() { return newBuilder(); }
++ public static Builder newBuilder() {
++ return DEFAULT_INSTANCE.toBuilder();
++ }
+ public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation prototype) {
+- return newBuilder().mergeFrom(prototype);
++ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+- public Builder toBuilder() { return newBuilder(this); }
+
+ /**
+ * Protobuf type {@code OSMPBF.Relation}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageLite.Builder<
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation, Builder>
+- implements
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation, Builder> implements
+ // @@protoc_insertion_point(builder_implements:OSMPBF.Relation)
+ org.openstreetmap.osmosis.osmbinary.Osmformat.RelationOrBuilder {
+ // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.newBuilder()
+ private Builder() {
+- maybeForceBuilderInitialization();
+- }
+-
+- private void maybeForceBuilderInitialization() {
+- }
+- private static Builder create() {
+- return new Builder();
+- }
+-
+- public Builder clear() {
+- super.clear();
+- id_ = 0L;
+- bitField0_ = (bitField0_ & ~0x00000001);
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+- bitField0_ = (bitField0_ & ~0x00000008);
+- rolesSid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+- memids_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000020);
+- types_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000040);
+- return this;
++ super(DEFAULT_INSTANCE);
+ }
+
+- public Builder clone() {
+- return create().mergeFrom(buildPartial());
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getDefaultInstanceForType() {
+- return org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.getDefaultInstance();
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation build() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation result = buildPartial();
+- if (!result.isInitialized()) {
+- throw newUninitializedMessageException(result);
+- }
+- return result;
+- }
+-
+- public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation buildPartial() {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Relation(this);
+- int from_bitField0_ = bitField0_;
+- int to_bitField0_ = 0;
+- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+- to_bitField0_ |= 0x00000001;
+- }
+- result.id_ = id_;
+- if (((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = java.util.Collections.unmodifiableList(keys_);
+- bitField0_ = (bitField0_ & ~0x00000002);
+- }
+- result.keys_ = keys_;
+- if (((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = java.util.Collections.unmodifiableList(vals_);
+- bitField0_ = (bitField0_ & ~0x00000004);
+- }
+- result.vals_ = vals_;
+- if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+- to_bitField0_ |= 0x00000002;
+- }
+- result.info_ = info_;
+- if (((bitField0_ & 0x00000010) == 0x00000010)) {
+- rolesSid_ = java.util.Collections.unmodifiableList(rolesSid_);
+- bitField0_ = (bitField0_ & ~0x00000010);
+- }
+- result.rolesSid_ = rolesSid_;
+- if (((bitField0_ & 0x00000020) == 0x00000020)) {
+- memids_ = java.util.Collections.unmodifiableList(memids_);
+- bitField0_ = (bitField0_ & ~0x00000020);
+- }
+- result.memids_ = memids_;
+- if (((bitField0_ & 0x00000040) == 0x00000040)) {
+- types_ = java.util.Collections.unmodifiableList(types_);
+- bitField0_ = (bitField0_ & ~0x00000040);
+- }
+- result.types_ = types_;
+- result.bitField0_ = to_bitField0_;
+- return result;
+- }
+-
+- public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation other) {
+- if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.getDefaultInstance()) return this;
+- if (other.hasId()) {
+- setId(other.getId());
+- }
+- if (!other.keys_.isEmpty()) {
+- if (keys_.isEmpty()) {
+- keys_ = other.keys_;
+- bitField0_ = (bitField0_ & ~0x00000002);
+- } else {
+- ensureKeysIsMutable();
+- keys_.addAll(other.keys_);
+- }
+-
+- }
+- if (!other.vals_.isEmpty()) {
+- if (vals_.isEmpty()) {
+- vals_ = other.vals_;
+- bitField0_ = (bitField0_ & ~0x00000004);
+- } else {
+- ensureValsIsMutable();
+- vals_.addAll(other.vals_);
+- }
+-
+- }
+- if (other.hasInfo()) {
+- mergeInfo(other.getInfo());
+- }
+- if (!other.rolesSid_.isEmpty()) {
+- if (rolesSid_.isEmpty()) {
+- rolesSid_ = other.rolesSid_;
+- bitField0_ = (bitField0_ & ~0x00000010);
+- } else {
+- ensureRolesSidIsMutable();
+- rolesSid_.addAll(other.rolesSid_);
+- }
+-
+- }
+- if (!other.memids_.isEmpty()) {
+- if (memids_.isEmpty()) {
+- memids_ = other.memids_;
+- bitField0_ = (bitField0_ & ~0x00000020);
+- } else {
+- ensureMemidsIsMutable();
+- memids_.addAll(other.memids_);
+- }
+-
+- }
+- if (!other.types_.isEmpty()) {
+- if (types_.isEmpty()) {
+- types_ = other.types_;
+- bitField0_ = (bitField0_ & ~0x00000040);
+- } else {
+- ensureTypesIsMutable();
+- types_.addAll(other.types_);
+- }
+-
+- }
+- setUnknownFields(
+- getUnknownFields().concat(other.unknownFields));
+- return this;
+- }
+-
+- public final boolean isInitialized() {
+- if (!hasId()) {
+-
+- return false;
+- }
+- return true;
+- }
+-
+- public Builder mergeFrom(
+- com.google.protobuf.CodedInputStream input,
+- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+- throws java.io.IOException {
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parsedMessage = null;
+- try {
+- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+- parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Relation) e.getUnfinishedMessage();
+- throw e;
+- } finally {
+- if (parsedMessage != null) {
+- mergeFrom(parsedMessage);
+- }
+- }
+- return this;
+- }
+- private int bitField0_;
+
+- private long id_ ;
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public boolean hasId() {
+- return ((bitField0_ & 0x00000001) == 0x00000001);
++ return instance.hasId();
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public long getId() {
+- return id_;
++ return instance.getId();
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public Builder setId(long value) {
+- bitField0_ |= 0x00000001;
+- id_ = value;
+-
++ copyOnWrite();
++ instance.setId(value);
+ return this;
+ }
+ /**
+ * <code>required int64 id = 1;</code>
+ */
+ public Builder clearId() {
+- bitField0_ = (bitField0_ & ~0x00000001);
+- id_ = 0L;
+-
++ copyOnWrite();
++ instance.clearId();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+- private void ensureKeysIsMutable() {
+- if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+- keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+- bitField0_ |= 0x00000002;
+- }
+- }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getKeysList() {
+- return java.util.Collections.unmodifiableList(keys_);
++ return java.util.Collections.unmodifiableList(
++ instance.getKeysList());
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeysCount() {
+- return keys_.size();
++ return instance.getKeysCount();
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public int getKeys(int index) {
+- return keys_.get(index);
++ return instance.getKeys(index);
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder setKeys(
+ int index, int value) {
+- ensureKeysIsMutable();
+- keys_.set(index, value);
+-
++ copyOnWrite();
++ instance.setKeys(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addKeys(int value) {
+- ensureKeysIsMutable();
+- keys_.add(value);
+-
++ copyOnWrite();
++ instance.addKeys(value);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder addAllKeys(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureKeysIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, keys_);
+-
++ copyOnWrite();
++ instance.addAllKeys(values);
+ return this;
+ }
+ /**
+- * <code>repeated uint32 keys = 2 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays.
+ * </pre>
++ *
++ * <code>repeated uint32 keys = 2 [packed = true];</code>
+ */
+ public Builder clearKeys() {
+- keys_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000002);
+-
++ copyOnWrite();
++ instance.clearKeys();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+- private void ensureValsIsMutable() {
+- if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+- vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+- bitField0_ |= 0x00000004;
+- }
+- }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getValsList() {
+- return java.util.Collections.unmodifiableList(vals_);
++ return java.util.Collections.unmodifiableList(
++ instance.getValsList());
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getValsCount() {
+- return vals_.size();
++ return instance.getValsCount();
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public int getVals(int index) {
+- return vals_.get(index);
++ return instance.getVals(index);
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder setVals(
+ int index, int value) {
+- ensureValsIsMutable();
+- vals_.set(index, value);
+-
++ copyOnWrite();
++ instance.setVals(index, value);
+ return this;
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder addVals(int value) {
+- ensureValsIsMutable();
+- vals_.add(value);
+-
++ copyOnWrite();
++ instance.addVals(value);
+ return this;
+ }
+ /**
+@@ -12604,319 +12544,263 @@ public final class Osmformat {
+ */
+ public Builder addAllVals(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureValsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, vals_);
+-
++ copyOnWrite();
++ instance.addAllVals(values);
+ return this;
+ }
+ /**
+ * <code>repeated uint32 vals = 3 [packed = true];</code>
+ */
+ public Builder clearVals() {
+- vals_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000004);
+-
++ copyOnWrite();
++ instance.clearVals();
+ return this;
+ }
+
+- private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public boolean hasInfo() {
+- return ((bitField0_ & 0x00000008) == 0x00000008);
++ return instance.hasInfo();
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+- return info_;
++ return instance.getInfo();
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- info_ = value;
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(value);
+ return this;
+- }
++ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder setInfo(
+ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+- info_ = builderForValue.build();
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.setInfo(builderForValue);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+ public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+- if (((bitField0_ & 0x00000008) == 0x00000008) &&
+- info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+- info_ =
+- org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder(info_).mergeFrom(value).buildPartial();
+- } else {
+- info_ = value;
+- }
+-
+- bitField0_ |= 0x00000008;
++ copyOnWrite();
++ instance.mergeInfo(value);
+ return this;
+ }
+ /**
+ * <code>optional .OSMPBF.Info info = 4;</code>
+ */
+- public Builder clearInfo() {
+- info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-
+- bitField0_ = (bitField0_ & ~0x00000008);
++ public Builder clearInfo() { copyOnWrite();
++ instance.clearInfo();
+ return this;
+ }
+
+- private java.util.List<java.lang.Integer> rolesSid_ = java.util.Collections.emptyList();
+- private void ensureRolesSidIsMutable() {
+- if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+- rolesSid_ = new java.util.ArrayList<java.lang.Integer>(rolesSid_);
+- bitField0_ |= 0x00000010;
+- }
+- }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Integer>
+ getRolesSidList() {
+- return java.util.Collections.unmodifiableList(rolesSid_);
++ return java.util.Collections.unmodifiableList(
++ instance.getRolesSidList());
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public int getRolesSidCount() {
+- return rolesSid_.size();
++ return instance.getRolesSidCount();
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public int getRolesSid(int index) {
+- return rolesSid_.get(index);
++ return instance.getRolesSid(index);
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public Builder setRolesSid(
+ int index, int value) {
+- ensureRolesSidIsMutable();
+- rolesSid_.set(index, value);
+-
++ copyOnWrite();
++ instance.setRolesSid(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public Builder addRolesSid(int value) {
+- ensureRolesSidIsMutable();
+- rolesSid_.add(value);
+-
++ copyOnWrite();
++ instance.addRolesSid(value);
+ return this;
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public Builder addAllRolesSid(
+ java.lang.Iterable<? extends java.lang.Integer> values) {
+- ensureRolesSidIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, rolesSid_);
+-
++ copyOnWrite();
++ instance.addAllRolesSid(values);
+ return this;
+ }
+ /**
+- * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+- *
+ * <pre>
+ * Parallel arrays
+ * </pre>
++ *
++ * <code>repeated int32 roles_sid = 8 [packed = true];</code>
+ */
+ public Builder clearRolesSid() {
+- rolesSid_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000010);
+-
++ copyOnWrite();
++ instance.clearRolesSid();
+ return this;
+ }
+
+- private java.util.List<java.lang.Long> memids_ = java.util.Collections.emptyList();
+- private void ensureMemidsIsMutable() {
+- if (!((bitField0_ & 0x00000020) == 0x00000020)) {
+- memids_ = new java.util.ArrayList<java.lang.Long>(memids_);
+- bitField0_ |= 0x00000020;
+- }
+- }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public java.util.List<java.lang.Long>
+ getMemidsList() {
+- return java.util.Collections.unmodifiableList(memids_);
++ return java.util.Collections.unmodifiableList(
++ instance.getMemidsList());
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public int getMemidsCount() {
+- return memids_.size();
++ return instance.getMemidsCount();
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public long getMemids(int index) {
+- return memids_.get(index);
++ return instance.getMemids(index);
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public Builder setMemids(
+ int index, long value) {
+- ensureMemidsIsMutable();
+- memids_.set(index, value);
+-
++ copyOnWrite();
++ instance.setMemids(index, value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public Builder addMemids(long value) {
+- ensureMemidsIsMutable();
+- memids_.add(value);
+-
++ copyOnWrite();
++ instance.addMemids(value);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public Builder addAllMemids(
+ java.lang.Iterable<? extends java.lang.Long> values) {
+- ensureMemidsIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, memids_);
+-
++ copyOnWrite();
++ instance.addAllMemids(values);
+ return this;
+ }
+ /**
+- * <code>repeated sint64 memids = 9 [packed = true];</code>
+- *
+ * <pre>
+ * DELTA encoded
+ * </pre>
++ *
++ * <code>repeated sint64 memids = 9 [packed = true];</code>
+ */
+ public Builder clearMemids() {
+- memids_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000020);
+-
++ copyOnWrite();
++ instance.clearMemids();
+ return this;
+ }
+
+- private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> types_ =
+- java.util.Collections.emptyList();
+- private void ensureTypesIsMutable() {
+- if (!((bitField0_ & 0x00000040) == 0x00000040)) {
+- types_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>(types_);
+- bitField0_ |= 0x00000040;
+- }
+- }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> getTypesList() {
+- return java.util.Collections.unmodifiableList(types_);
++ return instance.getTypesList();
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public int getTypesCount() {
+- return types_.size();
++ return instance.getTypesCount();
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType getTypes(int index) {
+- return types_.get(index);
++ return instance.getTypes(index);
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public Builder setTypes(
+ int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureTypesIsMutable();
+- types_.set(index, value);
+-
++ copyOnWrite();
++ instance.setTypes(index, value);
+ return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public Builder addTypes(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
+- if (value == null) {
+- throw new NullPointerException();
+- }
+- ensureTypesIsMutable();
+- types_.add(value);
+-
++ copyOnWrite();
++ instance.addTypes(value);
+ return this;
+ }
+ /**
+@@ -12924,31 +12808,271 @@ public final class Osmformat {
+ */
+ public Builder addAllTypes(
+ java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> values) {
+- ensureTypesIsMutable();
+- com.google.protobuf.AbstractMessageLite.Builder.addAll(
+- values, types_);
+-
+- return this;
++ copyOnWrite();
++ instance.addAllTypes(values); return this;
+ }
+ /**
+ * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
+ */
+ public Builder clearTypes() {
+- types_ = java.util.Collections.emptyList();
+- bitField0_ = (bitField0_ & ~0x00000040);
+-
++ copyOnWrite();
++ instance.clearTypes();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:OSMPBF.Relation)
+ }
++ private byte memoizedIsInitialized = -1;
++ protected final Object dynamicMethod(
++ com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
++ Object arg0, Object arg1) {
++ switch (method) {
++ case NEW_MUTABLE_INSTANCE: {
++ return new org.openstreetmap.osmosis.osmbinary.Osmformat.Relation();
++ }
++ case IS_INITIALIZED: {
++ byte isInitialized = memoizedIsInitialized;
++ if (isInitialized == 1) return DEFAULT_INSTANCE;
++ if (isInitialized == 0) return null;
++
++ boolean shouldMemoize = ((Boolean) arg0).booleanValue();
++ if (!hasId()) {
++ if (shouldMemoize) {
++ memoizedIsInitialized = 0;
++ }
++ return null;
++ }
++ if (shouldMemoize) memoizedIsInitialized = 1;
++ return DEFAULT_INSTANCE;
++
++ }
++ case MAKE_IMMUTABLE: {
++ keys_.makeImmutable();
++ vals_.makeImmutable();
++ rolesSid_.makeImmutable();
++ memids_.makeImmutable();
++ types_.makeImmutable();
++ return null;
++ }
++ case NEW_BUILDER: {
++ return new Builder();
++ }
++ case VISIT: {
++ Visitor visitor = (Visitor) arg0;
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation other = (org.openstreetmap.osmosis.osmbinary.Osmformat.Relation) arg1;
++ id_ = visitor.visitLong(
++ hasId(), id_,
++ other.hasId(), other.id_);
++ keys_= visitor.visitIntList(keys_, other.keys_);
++ vals_= visitor.visitIntList(vals_, other.vals_);
++ info_ = visitor.visitMessage(info_, other.info_);
++ rolesSid_= visitor.visitIntList(rolesSid_, other.rolesSid_);
++ memids_= visitor.visitLongList(memids_, other.memids_);
++ types_= visitor.visitIntList(types_, other.types_);
++ if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
++ .INSTANCE) {
++ bitField0_ |= other.bitField0_;
++ }
++ return this;
++ }
++ case MERGE_FROM_STREAM: {
++ com.google.protobuf.CodedInputStream input =
++ (com.google.protobuf.CodedInputStream) arg0;
++ com.google.protobuf.ExtensionRegistryLite extensionRegistry =
++ (com.google.protobuf.ExtensionRegistryLite) arg1;
++ try {
++ boolean done = false;
++ while (!done) {
++ int tag = input.readTag();
++ switch (tag) {
++ case 0:
++ done = true;
++ break;
++ default: {
++ if (!parseUnknownField(tag, input)) {
++ done = true;
++ }
++ break;
++ }
++ case 8: {
++ bitField0_ |= 0x00000001;
++ id_ = input.readInt64();
++ break;
++ }
++ case 16: {
++ if (!keys_.isModifiable()) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ keys_.addInt(input.readUInt32());
++ break;
++ }
++ case 18: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!keys_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ keys_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(keys_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ keys_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 24: {
++ if (!vals_.isModifiable()) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ vals_.addInt(input.readUInt32());
++ break;
++ }
++ case 26: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!vals_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ vals_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(vals_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ vals_.addInt(input.readUInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 34: {
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++ if (((bitField0_ & 0x00000002) == 0x00000002)) {
++ subBuilder = info_.toBuilder();
++ }
++ info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.parser(), extensionRegistry);
++ if (subBuilder != null) {
++ subBuilder.mergeFrom(info_);
++ info_ = subBuilder.buildPartial();
++ }
++ bitField0_ |= 0x00000002;
++ break;
++ }
++ case 64: {
++ if (!rolesSid_.isModifiable()) {
++ rolesSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(rolesSid_);
++ }
++ rolesSid_.addInt(input.readInt32());
++ break;
++ }
++ case 66: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!rolesSid_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ rolesSid_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(rolesSid_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ rolesSid_.addInt(input.readInt32());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 72: {
++ if (!memids_.isModifiable()) {
++ memids_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(memids_);
++ }
++ memids_.addLong(input.readSInt64());
++ break;
++ }
++ case 74: {
++ int length = input.readRawVarint32();
++ int limit = input.pushLimit(length);
++ if (!memids_.isModifiable() && input.getBytesUntilLimit() > 0) {
++ memids_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(memids_);
++ }
++ while (input.getBytesUntilLimit() > 0) {
++ memids_.addLong(input.readSInt64());
++ }
++ input.popLimit(limit);
++ break;
++ }
++ case 80: {
++ if (!types_.isModifiable()) {
++ types_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(types_);
++ }
++ int rawValue = input.readEnum();
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.forNumber(rawValue);
++ if (value == null) {
++ super.mergeVarintField(10, rawValue);
++ } else {
++ types_.addInt(rawValue);
++ }
++ break;
++ }
++ case 82: {
++ if (!types_.isModifiable()) {
++ types_ =
++ com.google.protobuf.GeneratedMessageLite.mutableCopy(types_);
++ }
++ int length = input.readRawVarint32();
++ int oldLimit = input.pushLimit(length);
++ while(input.getBytesUntilLimit() > 0) {
++ int rawValue = input.readEnum();
++ org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.forNumber(rawValue);
++ if (value == null) {
++ super.mergeVarintField(10, rawValue);
++ } else {
++ types_.addInt(rawValue);
++ }
++ }
++ input.popLimit(oldLimit);
++ break;
++ }
++ }
++ }
++ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++ throw new RuntimeException(e.setUnfinishedMessage(this));
++ } catch (java.io.IOException e) {
++ throw new RuntimeException(
++ new com.google.protobuf.InvalidProtocolBufferException(
++ e.getMessage()).setUnfinishedMessage(this));
++ } finally {
++ }
++ }
++ case GET_DEFAULT_INSTANCE: {
++ return DEFAULT_INSTANCE;
++ }
++ case GET_PARSER: {
++ if (PARSER == null) { synchronized (org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.class) {
++ if (PARSER == null) {
++ PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
++ }
++ }
++ }
++ return PARSER;
++ }
++ }
++ throw new UnsupportedOperationException();
++ }
++
+
++ // @@protoc_insertion_point(class_scope:OSMPBF.Relation)
++ private static final org.openstreetmap.osmosis.osmbinary.Osmformat.Relation DEFAULT_INSTANCE;
+ static {
+- defaultInstance = new Relation(true);
+- defaultInstance.initFields();
++ DEFAULT_INSTANCE = new Relation();
++ DEFAULT_INSTANCE.makeImmutable();
+ }
+
+- // @@protoc_insertion_point(class_scope:OSMPBF.Relation)
++ public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getDefaultInstance() {
++ return DEFAULT_INSTANCE;
++ }
++
++ private static volatile com.google.protobuf.Parser<Relation> PARSER;
++
++ public static com.google.protobuf.Parser<Relation> parser() {
++ return DEFAULT_INSTANCE.getParserForType();
++ }
+ }
+
+
diff --git a/debian/patches/series b/debian/patches/series
index 9fb14cd..bb29cc5 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,4 @@
01-fix_launcher.patch
02-fix_plexus.patch
04-osmosis-version.patch
+protobuf-3.0.0.patch
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/osmosis.git
More information about the Pkg-grass-devel
mailing list