Ignore:
Timestamp:
2017-11-04T21:50:31+01:00 (9 years ago)
Author:
donvip
Message:

update to latest version of Protocol Buffers (v3.4.1)

Location:
applications/editors/josm/plugins/pbf
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/pbf

    • Property svn:externals

      •  

        old new  
        1 proto https://github.com/scrosby/OSM-binary/trunk/src
        2 protobuf https://github.com/google/protobuf/tags/v2.6.1/src/google/protobuf/
         1https://github.com/scrosby/OSM-binary/trunk/src proto
         2https://github.com/google/protobuf/tags/v3.4.1/src/google/protobuf protobuf

  • applications/editors/josm/plugins/pbf/gen/crosby/binary/Fileformat.java

    r31905 r33772  
    1414
    1515    /**
     16     * <pre>
     17     * No compression
     18     * </pre>
     19     *
    1620     * <code>optional bytes raw = 1;</code>
    17      *
     21     */
     22    boolean hasRaw();
     23    /**
    1824     * <pre>
    1925     * No compression
    2026     * </pre>
    21      */
    22     boolean hasRaw();
    23     /**
     27     *
    2428     * <code>optional bytes raw = 1;</code>
    25      *
    26      * <pre>
    27      * No compression
    28      * </pre>
    2929     */
    3030    com.google.protobuf.ByteString getRaw();
    3131
    3232    /**
     33     * <pre>
     34     * When compressed, the uncompressed size
     35     * </pre>
     36     *
    3337     * <code>optional int32 raw_size = 2;</code>
    34      *
     38     */
     39    boolean hasRawSize();
     40    /**
    3541     * <pre>
    3642     * When compressed, the uncompressed size
    3743     * </pre>
    38      */
    39     boolean hasRawSize();
    40     /**
     44     *
    4145     * <code>optional int32 raw_size = 2;</code>
    42      *
    43      * <pre>
    44      * When compressed, the uncompressed size
    45      * </pre>
    4646     */
    4747    int getRawSize();
    4848
    4949    /**
     50     * <pre>
     51     * Possible compressed versions of the data.
     52     * </pre>
     53     *
    5054     * <code>optional bytes zlib_data = 3;</code>
    51      *
     55     */
     56    boolean hasZlibData();
     57    /**
    5258     * <pre>
    5359     * Possible compressed versions of the data.
    5460     * </pre>
    55      */
    56     boolean hasZlibData();
    57     /**
     61     *
    5862     * <code>optional bytes zlib_data = 3;</code>
    59      *
    60      * <pre>
    61      * Possible compressed versions of the data.
    62      * </pre>
    6363     */
    6464    com.google.protobuf.ByteString getZlibData();
    6565
    6666    /**
     67     * <pre>
     68     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     69     * </pre>
     70     *
    6771     * <code>optional bytes lzma_data = 4;</code>
    68      *
     72     */
     73    boolean hasLzmaData();
     74    /**
    6975     * <pre>
    7076     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    7177     * </pre>
    72      */
    73     boolean hasLzmaData();
    74     /**
     78     *
    7579     * <code>optional bytes lzma_data = 4;</code>
    76      *
    77      * <pre>
    78      * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    79      * </pre>
    8080     */
    8181    com.google.protobuf.ByteString getLzmaData();
    8282
    8383    /**
     84     * <pre>
     85     * Formerly used for bzip2 compressed data. Depreciated in 2010.
     86     * </pre>
     87     *
    8488     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    85      *
     89     */
     90    @java.lang.Deprecated boolean hasOBSOLETEBzip2Data();
     91    /**
    8692     * <pre>
    8793     * Formerly used for bzip2 compressed data. Depreciated in 2010.
    8894     * </pre>
    89      */
    90     @java.lang.Deprecated boolean hasOBSOLETEBzip2Data();
    91     /**
     95     *
    9296     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    93      *
    94      * <pre>
    95      * Formerly used for bzip2 compressed data. Depreciated in 2010.
    96      * </pre>
    9797     */
    9898    @java.lang.Deprecated com.google.protobuf.ByteString getOBSOLETEBzip2Data();
    … …  
    101101   * Protobuf type {@code OSMPBF.Blob}
    102102   */
    103   public static final class Blob extends
    104       com.google.protobuf.GeneratedMessageLite implements
     103  public  static final class Blob extends
     104      com.google.protobuf.GeneratedMessageLite<
     105          Blob, Blob.Builder> implements
    105106      // @@protoc_insertion_point(message_implements:OSMPBF.Blob)
    106107      BlobOrBuilder {
    107     // Use Blob.newBuilder() to construct.
    108     private Blob(com.google.protobuf.GeneratedMessageLite.Builder builder) {
    109       super(builder);
    110       this.unknownFields = builder.getUnknownFields();
    111     }
    112     private Blob(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
    113 
    114     private static final Blob defaultInstance;
    115     public static Blob getDefaultInstance() {
    116       return defaultInstance;
    117     }
    118 
    119     @Override
    120         public Blob getDefaultInstanceForType() {
    121       return defaultInstance;
    122     }
    123 
    124     private final com.google.protobuf.ByteString unknownFields;
    125     private Blob(
    126         com.google.protobuf.CodedInputStream input,
    127         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    128         throws com.google.protobuf.InvalidProtocolBufferException {
    129       initFields();
    130       int mutable_bitField0_ = 0;
    131       com.google.protobuf.ByteString.Output unknownFieldsOutput =
    132           com.google.protobuf.ByteString.newOutput();
    133       com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
    134           com.google.protobuf.CodedOutputStream.newInstance(
    135               unknownFieldsOutput);
    136       try {
    137         boolean done = false;
    138         while (!done) {
    139           int tag = input.readTag();
    140           switch (tag) {
    141             case 0:
    142               done = true;
    143               break;
    144             default: {
    145               if (!parseUnknownField(input, unknownFieldsCodedOutput,
    146                                      extensionRegistry, tag)) {
    147                 done = true;
    148               }
    149               break;
    150             }
    151             case 10: {
    152               bitField0_ |= 0x00000001;
    153               raw_ = input.readBytes();
    154               break;
    155             }
    156             case 16: {
    157               bitField0_ |= 0x00000002;
    158               rawSize_ = input.readInt32();
    159               break;
    160             }
    161             case 26: {
    162               bitField0_ |= 0x00000004;
    163               zlibData_ = input.readBytes();
    164               break;
    165             }
    166             case 34: {
    167               bitField0_ |= 0x00000008;
    168               lzmaData_ = input.readBytes();
    169               break;
    170             }
    171             case 42: {
    172               bitField0_ |= 0x00000010;
    173               oBSOLETEBzip2Data_ = input.readBytes();
    174               break;
    175             }
    176           }
    177         }
    178       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
    179         throw e.setUnfinishedMessage(this);
    180       } catch (java.io.IOException e) {
    181         throw new com.google.protobuf.InvalidProtocolBufferException(
    182             e.getMessage()).setUnfinishedMessage(this);
    183       } finally {
    184         try {
    185           unknownFieldsCodedOutput.flush();
    186         } catch (java.io.IOException e) {
    187         // Should not happen
    188         } finally {
    189           unknownFields = unknownFieldsOutput.toByteString();
    190         }
    191         makeExtensionsImmutable();
    192       }
    193     }
    194     public static com.google.protobuf.Parser<Blob> PARSER =
    195         new com.google.protobuf.AbstractParser<Blob>() {
    196       @Override
    197         public Blob parsePartialFrom(
    198           com.google.protobuf.CodedInputStream input,
    199           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    200           throws com.google.protobuf.InvalidProtocolBufferException {
    201         return new Blob(input, extensionRegistry);
    202       }
    203     };
    204 
    205     @java.lang.Override
    206     public com.google.protobuf.Parser<Blob> getParserForType() {
    207       return PARSER;
    208     }
    209 
     108    private Blob() {
     109      raw_ = com.google.protobuf.ByteString.EMPTY;
     110      zlibData_ = com.google.protobuf.ByteString.EMPTY;
     111      lzmaData_ = com.google.protobuf.ByteString.EMPTY;
     112      oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
     113    }
    210114    private int bitField0_;
    211115    public static final int RAW_FIELD_NUMBER = 1;
    212116    private com.google.protobuf.ByteString raw_;
    213117    /**
     118     * <pre>
     119     * No compression
     120     * </pre>
     121     *
    214122     * <code>optional bytes raw = 1;</code>
    215      *
     123     */
     124    public boolean hasRaw() {
     125      return ((bitField0_ & 0x00000001) == 0x00000001);
     126    }
     127    /**
    216128     * <pre>
    217129     * No compression
    218130     * </pre>
    219      */
    220     @Override
    221         public boolean hasRaw() {
    222       return ((bitField0_ & 0x00000001) == 0x00000001);
    223     }
    224     /**
     131     *
    225132     * <code>optional bytes raw = 1;</code>
    226      *
     133     */
     134    public com.google.protobuf.ByteString getRaw() {
     135      return raw_;
     136    }
     137    /**
    227138     * <pre>
    228139     * No compression
    229140     * </pre>
    230      */
    231     @Override
    232         public com.google.protobuf.ByteString getRaw() {
    233       return raw_;
     141     *
     142     * <code>optional bytes raw = 1;</code>
     143     */
     144    private void setRaw(com.google.protobuf.ByteString value) {
     145      if (value == null) {
     146    throw new NullPointerException();
     147  }
     148  bitField0_ |= 0x00000001;
     149      raw_ = value;
     150    }
     151    /**
     152     * <pre>
     153     * No compression
     154     * </pre>
     155     *
     156     * <code>optional bytes raw = 1;</code>
     157     */
     158    private void clearRaw() {
     159      bitField0_ = (bitField0_ & ~0x00000001);
     160      raw_ = getDefaultInstance().getRaw();
    234161    }
    235162
    … …  
    237164    private int rawSize_;
    238165    /**
     166     * <pre>
     167     * When compressed, the uncompressed size
     168     * </pre>
     169     *
    239170     * <code>optional int32 raw_size = 2;</code>
    240      *
     171     */
     172    public boolean hasRawSize() {
     173      return ((bitField0_ & 0x00000002) == 0x00000002);
     174    }
     175    /**
    241176     * <pre>
    242177     * When compressed, the uncompressed size
    243178     * </pre>
    244      */
    245     @Override
    246         public boolean hasRawSize() {
    247       return ((bitField0_ & 0x00000002) == 0x00000002);
    248     }
    249     /**
     179     *
    250180     * <code>optional int32 raw_size = 2;</code>
    251      *
     181     */
     182    public int getRawSize() {
     183      return rawSize_;
     184    }
     185    /**
    252186     * <pre>
    253187     * When compressed, the uncompressed size
    254188     * </pre>
    255      */
    256     @Override
    257         public int getRawSize() {
    258       return rawSize_;
     189     *
     190     * <code>optional int32 raw_size = 2;</code>
     191     */
     192    private void setRawSize(int value) {
     193      bitField0_ |= 0x00000002;
     194      rawSize_ = value;
     195    }
     196    /**
     197     * <pre>
     198     * When compressed, the uncompressed size
     199     * </pre>
     200     *
     201     * <code>optional int32 raw_size = 2;</code>
     202     */
     203    private void clearRawSize() {
     204      bitField0_ = (bitField0_ & ~0x00000002);
     205      rawSize_ = 0;
    259206    }
    260207
    … …  
    262209    private com.google.protobuf.ByteString zlibData_;
    263210    /**
     211     * <pre>
     212     * Possible compressed versions of the data.
     213     * </pre>
     214     *
    264215     * <code>optional bytes zlib_data = 3;</code>
    265      *
     216     */
     217    public boolean hasZlibData() {
     218      return ((bitField0_ & 0x00000004) == 0x00000004);
     219    }
     220    /**
    266221     * <pre>
    267222     * Possible compressed versions of the data.
    268223     * </pre>
    269      */
    270     @Override
    271         public boolean hasZlibData() {
    272       return ((bitField0_ & 0x00000004) == 0x00000004);
    273     }
    274     /**
     224     *
    275225     * <code>optional bytes zlib_data = 3;</code>
    276      *
     226     */
     227    public com.google.protobuf.ByteString getZlibData() {
     228      return zlibData_;
     229    }
     230    /**
    277231     * <pre>
    278232     * Possible compressed versions of the data.
    279233     * </pre>
    280      */
    281     @Override
    282         public com.google.protobuf.ByteString getZlibData() {
    283       return zlibData_;
     234     *
     235     * <code>optional bytes zlib_data = 3;</code>
     236     */
     237    private void setZlibData(com.google.protobuf.ByteString value) {
     238      if (value == null) {
     239    throw new NullPointerException();
     240  }
     241  bitField0_ |= 0x00000004;
     242      zlibData_ = value;
     243    }
     244    /**
     245     * <pre>
     246     * Possible compressed versions of the data.
     247     * </pre>
     248     *
     249     * <code>optional bytes zlib_data = 3;</code>
     250     */
     251    private void clearZlibData() {
     252      bitField0_ = (bitField0_ & ~0x00000004);
     253      zlibData_ = getDefaultInstance().getZlibData();
    284254    }
    285255
    … …  
    287257    private com.google.protobuf.ByteString lzmaData_;
    288258    /**
     259     * <pre>
     260     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     261     * </pre>
     262     *
    289263     * <code>optional bytes lzma_data = 4;</code>
    290      *
     264     */
     265    public boolean hasLzmaData() {
     266      return ((bitField0_ & 0x00000008) == 0x00000008);
     267    }
     268    /**
    291269     * <pre>
    292270     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    293271     * </pre>
    294      */
    295     @Override
    296         public boolean hasLzmaData() {
    297       return ((bitField0_ & 0x00000008) == 0x00000008);
    298     }
    299     /**
     272     *
    300273     * <code>optional bytes lzma_data = 4;</code>
    301      *
     274     */
     275    public com.google.protobuf.ByteString getLzmaData() {
     276      return lzmaData_;
     277    }
     278    /**
    302279     * <pre>
    303280     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    304281     * </pre>
    305      */
    306     @Override
    307         public com.google.protobuf.ByteString getLzmaData() {
    308       return lzmaData_;
     282     *
     283     * <code>optional bytes lzma_data = 4;</code>
     284     */
     285    private void setLzmaData(com.google.protobuf.ByteString value) {
     286      if (value == null) {
     287    throw new NullPointerException();
     288  }
     289  bitField0_ |= 0x00000008;
     290      lzmaData_ = value;
     291    }
     292    /**
     293     * <pre>
     294     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     295     * </pre>
     296     *
     297     * <code>optional bytes lzma_data = 4;</code>
     298     */
     299    private void clearLzmaData() {
     300      bitField0_ = (bitField0_ & ~0x00000008);
     301      lzmaData_ = getDefaultInstance().getLzmaData();
    309302    }
    310303
    … …  
    312305    private com.google.protobuf.ByteString oBSOLETEBzip2Data_;
    313306    /**
     307     * <pre>
     308     * Formerly used for bzip2 compressed data. Depreciated in 2010.
     309     * </pre>
     310     *
    314311     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    315      *
     312     */
     313    @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
     314      return ((bitField0_ & 0x00000010) == 0x00000010);
     315    }
     316    /**
    316317     * <pre>
    317318     * Formerly used for bzip2 compressed data. Depreciated in 2010.
    318319     * </pre>
    319      */
    320     @Override
    321         @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
    322       return ((bitField0_ & 0x00000010) == 0x00000010);
    323     }
    324     /**
     320     *
    325321     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    326      *
     322     */
     323    @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
     324      return oBSOLETEBzip2Data_;
     325    }
     326    /**
    327327     * <pre>
    328328     * Formerly used for bzip2 compressed data. Depreciated in 2010.
    329329     * </pre>
    330      */
    331     @Override
    332         @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
    333       return oBSOLETEBzip2Data_;
    334     }
    335 
    336     private void initFields() {
    337       raw_ = com.google.protobuf.ByteString.EMPTY;
    338       rawSize_ = 0;
    339       zlibData_ = com.google.protobuf.ByteString.EMPTY;
    340       lzmaData_ = com.google.protobuf.ByteString.EMPTY;
    341       oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
    342     }
    343     private byte memoizedIsInitialized = -1;
    344     @Override
    345         public final boolean isInitialized() {
    346       byte isInitialized = memoizedIsInitialized;
    347       if (isInitialized == 1) return true;
    348       if (isInitialized == 0) return false;
    349 
    350       memoizedIsInitialized = 1;
    351       return true;
    352     }
    353 
    354     @Override
    355         public void writeTo(com.google.protobuf.CodedOutputStream output)
     330     *
     331     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     332     */
     333    private void setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
     334      if (value == null) {
     335    throw new NullPointerException();
     336  }
     337  bitField0_ |= 0x00000010;
     338      oBSOLETEBzip2Data_ = value;
     339    }
     340    /**
     341     * <pre>
     342     * Formerly used for bzip2 compressed data. Depreciated in 2010.
     343     * </pre>
     344     *
     345     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     346     */
     347    private void clearOBSOLETEBzip2Data() {
     348      bitField0_ = (bitField0_ & ~0x00000010);
     349      oBSOLETEBzip2Data_ = getDefaultInstance().getOBSOLETEBzip2Data();
     350    }
     351
     352    public void writeTo(com.google.protobuf.CodedOutputStream output)
    356353                        throws java.io.IOException {
    357       getSerializedSize();
    358354      if (((bitField0_ & 0x00000001) == 0x00000001)) {
    359355        output.writeBytes(1, raw_);
    … …  
    371367        output.writeBytes(5, oBSOLETEBzip2Data_);
    372368      }
    373       output.writeRawBytes(unknownFields);
    374     }
    375 
    376     private int memoizedSerializedSize = -1;
    377     @Override
    378         public int getSerializedSize() {
     369      unknownFields.writeTo(output);
     370    }
     371
     372    public int getSerializedSize() {
    379373      int size = memoizedSerializedSize;
    380374      if (size != -1) return size;
    … …  
    401395          .computeBytesSize(5, oBSOLETEBzip2Data_);
    402396      }
    403       size += unknownFields.size();
     397      size += unknownFields.getSerializedSize();
    404398      memoizedSerializedSize = size;
    405399      return size;
    406400    }
    407401
    408     private static final long serialVersionUID = 0L;
    409     @java.lang.Override
    410     protected java.lang.Object writeReplace()
    411         throws java.io.ObjectStreamException {
    412       return super.writeReplace();
    413     }
    414 
     402    public static crosby.binary.Fileformat.Blob parseFrom(
     403        java.nio.ByteBuffer data)
     404        throws com.google.protobuf.InvalidProtocolBufferException {
     405      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     406          DEFAULT_INSTANCE, data);
     407    }
     408    public static crosby.binary.Fileformat.Blob parseFrom(
     409        java.nio.ByteBuffer data,
     410        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
     411        throws com.google.protobuf.InvalidProtocolBufferException {
     412      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     413          DEFAULT_INSTANCE, data, extensionRegistry);
     414    }
    415415    public static crosby.binary.Fileformat.Blob parseFrom(
    416416        com.google.protobuf.ByteString data)
    417417        throws com.google.protobuf.InvalidProtocolBufferException {
    418       return PARSER.parseFrom(data);
     418      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     419          DEFAULT_INSTANCE, data);
    419420    }
    420421    public static crosby.binary.Fileformat.Blob parseFrom(
    … …  
    422423        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    423424        throws com.google.protobuf.InvalidProtocolBufferException {
    424       return PARSER.parseFrom(data, extensionRegistry);
     425      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     426          DEFAULT_INSTANCE, data, extensionRegistry);
    425427    }
    426428    public static crosby.binary.Fileformat.Blob parseFrom(byte[] data)
    427429        throws com.google.protobuf.InvalidProtocolBufferException {
    428       return PARSER.parseFrom(data);
     430      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     431          DEFAULT_INSTANCE, data);
    429432    }
    430433    public static crosby.binary.Fileformat.Blob parseFrom(
    … …  
    432435        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    433436        throws com.google.protobuf.InvalidProtocolBufferException {
    434       return PARSER.parseFrom(data, extensionRegistry);
     437      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     438          DEFAULT_INSTANCE, data, extensionRegistry);
    435439    }
    436440    public static crosby.binary.Fileformat.Blob parseFrom(java.io.InputStream input)
    437441        throws java.io.IOException {
    438       return PARSER.parseFrom(input);
     442      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     443          DEFAULT_INSTANCE, input);
    439444    }
    440445    public static crosby.binary.Fileformat.Blob parseFrom(
    … …  
    442447        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    443448        throws java.io.IOException {
    444       return PARSER.parseFrom(input, extensionRegistry);
     449      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     450          DEFAULT_INSTANCE, input, extensionRegistry);
    445451    }
    446452    public static crosby.binary.Fileformat.Blob parseDelimitedFrom(java.io.InputStream input)
    447453        throws java.io.IOException {
    448       return PARSER.parseDelimitedFrom(input);
     454      return parseDelimitedFrom(DEFAULT_INSTANCE, input);
    449455    }
    450456    public static crosby.binary.Fileformat.Blob parseDelimitedFrom(
    … …  
    452458        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    453459        throws java.io.IOException {
    454       return PARSER.parseDelimitedFrom(input, extensionRegistry);
     460      return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
    455461    }
    456462    public static crosby.binary.Fileformat.Blob parseFrom(
    457463        com.google.protobuf.CodedInputStream input)
    458464        throws java.io.IOException {
    459       return PARSER.parseFrom(input);
     465      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     466          DEFAULT_INSTANCE, input);
    460467    }
    461468    public static crosby.binary.Fileformat.Blob parseFrom(
    … …  
    463470        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    464471        throws java.io.IOException {
    465       return PARSER.parseFrom(input, extensionRegistry);
    466     }
    467 
    468     public static Builder newBuilder() { return Builder.create(); }
    469     @Override
    470         public Builder newBuilderForType() { return newBuilder(); }
     472      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     473          DEFAULT_INSTANCE, input, extensionRegistry);
     474    }
     475
     476    public static Builder newBuilder() {
     477      return DEFAULT_INSTANCE.toBuilder();
     478    }
    471479    public static Builder newBuilder(crosby.binary.Fileformat.Blob prototype) {
    472       return newBuilder().mergeFrom(prototype);
    473     }
    474     @Override
    475         public Builder toBuilder() { return newBuilder(this); }
     480      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     481    }
    476482
    477483    /**
    … …  
    480486    public static final class Builder extends
    481487        com.google.protobuf.GeneratedMessageLite.Builder<
    482           crosby.binary.Fileformat.Blob, Builder>
    483         implements
     488          crosby.binary.Fileformat.Blob, Builder> implements
    484489        // @@protoc_insertion_point(builder_implements:OSMPBF.Blob)
    485490        crosby.binary.Fileformat.BlobOrBuilder {
    486491      // Construct using crosby.binary.Fileformat.Blob.newBuilder()
    487492      private Builder() {
    488         maybeForceBuilderInitialization();
    489       }
    490 
    491       private void maybeForceBuilderInitialization() {
    492       }
    493       private static Builder create() {
    494         return new Builder();
    495       }
    496 
    497       @Override
    498         public Builder clear() {
    499         super.clear();
    500         raw_ = com.google.protobuf.ByteString.EMPTY;
    501         bitField0_ = (bitField0_ & ~0x00000001);
    502         rawSize_ = 0;
    503         bitField0_ = (bitField0_ & ~0x00000002);
    504         zlibData_ = com.google.protobuf.ByteString.EMPTY;
    505         bitField0_ = (bitField0_ & ~0x00000004);
    506         lzmaData_ = com.google.protobuf.ByteString.EMPTY;
    507         bitField0_ = (bitField0_ & ~0x00000008);
    508         oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
    509         bitField0_ = (bitField0_ & ~0x00000010);
    510         return this;
    511       }
    512 
    513       @Override
    514         public Builder clone() {
    515         return create().mergeFrom(buildPartial());
    516       }
    517 
    518       @Override
    519         public crosby.binary.Fileformat.Blob getDefaultInstanceForType() {
    520         return crosby.binary.Fileformat.Blob.getDefaultInstance();
    521       }
    522 
    523       @Override
    524         public crosby.binary.Fileformat.Blob build() {
    525         crosby.binary.Fileformat.Blob result = buildPartial();
    526         if (!result.isInitialized()) {
    527           throw newUninitializedMessageException(result);
    528         }
    529         return result;
    530       }
    531 
    532       @Override
    533         public crosby.binary.Fileformat.Blob buildPartial() {
    534         crosby.binary.Fileformat.Blob result = new crosby.binary.Fileformat.Blob(this);
    535         int from_bitField0_ = bitField0_;
    536         int to_bitField0_ = 0;
    537         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
    538           to_bitField0_ |= 0x00000001;
    539         }
    540         result.raw_ = raw_;
    541         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
    542           to_bitField0_ |= 0x00000002;
    543         }
    544         result.rawSize_ = rawSize_;
    545         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
    546           to_bitField0_ |= 0x00000004;
    547         }
    548         result.zlibData_ = zlibData_;
    549         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
    550           to_bitField0_ |= 0x00000008;
    551         }
    552         result.lzmaData_ = lzmaData_;
    553         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
    554           to_bitField0_ |= 0x00000010;
    555         }
    556         result.oBSOLETEBzip2Data_ = oBSOLETEBzip2Data_;
    557         result.bitField0_ = to_bitField0_;
    558         return result;
    559       }
    560 
    561       @Override
    562         public Builder mergeFrom(crosby.binary.Fileformat.Blob other) {
    563         if (other == crosby.binary.Fileformat.Blob.getDefaultInstance()) return this;
    564         if (other.hasRaw()) {
    565           setRaw(other.getRaw());
    566         }
    567         if (other.hasRawSize()) {
    568           setRawSize(other.getRawSize());
    569         }
    570         if (other.hasZlibData()) {
    571           setZlibData(other.getZlibData());
    572         }
    573         if (other.hasLzmaData()) {
    574           setLzmaData(other.getLzmaData());
    575         }
    576         if (other.hasOBSOLETEBzip2Data()) {
    577           setOBSOLETEBzip2Data(other.getOBSOLETEBzip2Data());
    578         }
    579         setUnknownFields(
    580             getUnknownFields().concat(other.unknownFields));
    581         return this;
    582       }
    583 
    584       @Override
    585         public final boolean isInitialized() {
    586         return true;
    587       }
    588 
    589       @Override
    590         public Builder mergeFrom(
    591           com.google.protobuf.CodedInputStream input,
    592           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    593           throws java.io.IOException {
    594         crosby.binary.Fileformat.Blob parsedMessage = null;
    595         try {
    596           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
    597         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
    598           parsedMessage = (crosby.binary.Fileformat.Blob) e.getUnfinishedMessage();
    599           throw e;
    600         } finally {
    601           if (parsedMessage != null) {
    602             mergeFrom(parsedMessage);
     493        super(DEFAULT_INSTANCE);
     494      }
     495
     496
     497      /**
     498       * <pre>
     499       * No compression
     500       * </pre>
     501       *
     502       * <code>optional bytes raw = 1;</code>
     503       */
     504      public boolean hasRaw() {
     505        return instance.hasRaw();
     506      }
     507      /**
     508       * <pre>
     509       * No compression
     510       * </pre>
     511       *
     512       * <code>optional bytes raw = 1;</code>
     513       */
     514      public com.google.protobuf.ByteString getRaw() {
     515        return instance.getRaw();
     516      }
     517      /**
     518       * <pre>
     519       * No compression
     520       * </pre>
     521       *
     522       * <code>optional bytes raw = 1;</code>
     523       */
     524      public Builder setRaw(com.google.protobuf.ByteString value) {
     525        copyOnWrite();
     526        instance.setRaw(value);
     527        return this;
     528      }
     529      /**
     530       * <pre>
     531       * No compression
     532       * </pre>
     533       *
     534       * <code>optional bytes raw = 1;</code>
     535       */
     536      public Builder clearRaw() {
     537        copyOnWrite();
     538        instance.clearRaw();
     539        return this;
     540      }
     541
     542      /**
     543       * <pre>
     544       * When compressed, the uncompressed size
     545       * </pre>
     546       *
     547       * <code>optional int32 raw_size = 2;</code>
     548       */
     549      public boolean hasRawSize() {
     550        return instance.hasRawSize();
     551      }
     552      /**
     553       * <pre>
     554       * When compressed, the uncompressed size
     555       * </pre>
     556       *
     557       * <code>optional int32 raw_size = 2;</code>
     558       */
     559      public int getRawSize() {
     560        return instance.getRawSize();
     561      }
     562      /**
     563       * <pre>
     564       * When compressed, the uncompressed size
     565       * </pre>
     566       *
     567       * <code>optional int32 raw_size = 2;</code>
     568       */
     569      public Builder setRawSize(int value) {
     570        copyOnWrite();
     571        instance.setRawSize(value);
     572        return this;
     573      }
     574      /**
     575       * <pre>
     576       * When compressed, the uncompressed size
     577       * </pre>
     578       *
     579       * <code>optional int32 raw_size = 2;</code>
     580       */
     581      public Builder clearRawSize() {
     582        copyOnWrite();
     583        instance.clearRawSize();
     584        return this;
     585      }
     586
     587      /**
     588       * <pre>
     589       * Possible compressed versions of the data.
     590       * </pre>
     591       *
     592       * <code>optional bytes zlib_data = 3;</code>
     593       */
     594      public boolean hasZlibData() {
     595        return instance.hasZlibData();
     596      }
     597      /**
     598       * <pre>
     599       * Possible compressed versions of the data.
     600       * </pre>
     601       *
     602       * <code>optional bytes zlib_data = 3;</code>
     603       */
     604      public com.google.protobuf.ByteString getZlibData() {
     605        return instance.getZlibData();
     606      }
     607      /**
     608       * <pre>
     609       * Possible compressed versions of the data.
     610       * </pre>
     611       *
     612       * <code>optional bytes zlib_data = 3;</code>
     613       */
     614      public Builder setZlibData(com.google.protobuf.ByteString value) {
     615        copyOnWrite();
     616        instance.setZlibData(value);
     617        return this;
     618      }
     619      /**
     620       * <pre>
     621       * Possible compressed versions of the data.
     622       * </pre>
     623       *
     624       * <code>optional bytes zlib_data = 3;</code>
     625       */
     626      public Builder clearZlibData() {
     627        copyOnWrite();
     628        instance.clearZlibData();
     629        return this;
     630      }
     631
     632      /**
     633       * <pre>
     634       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     635       * </pre>
     636       *
     637       * <code>optional bytes lzma_data = 4;</code>
     638       */
     639      public boolean hasLzmaData() {
     640        return instance.hasLzmaData();
     641      }
     642      /**
     643       * <pre>
     644       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     645       * </pre>
     646       *
     647       * <code>optional bytes lzma_data = 4;</code>
     648       */
     649      public com.google.protobuf.ByteString getLzmaData() {
     650        return instance.getLzmaData();
     651      }
     652      /**
     653       * <pre>
     654       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     655       * </pre>
     656       *
     657       * <code>optional bytes lzma_data = 4;</code>
     658       */
     659      public Builder setLzmaData(com.google.protobuf.ByteString value) {
     660        copyOnWrite();
     661        instance.setLzmaData(value);
     662        return this;
     663      }
     664      /**
     665       * <pre>
     666       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
     667       * </pre>
     668       *
     669       * <code>optional bytes lzma_data = 4;</code>
     670       */
     671      public Builder clearLzmaData() {
     672        copyOnWrite();
     673        instance.clearLzmaData();
     674        return this;
     675      }
     676
     677      /**
     678       * <pre>
     679       * Formerly used for bzip2 compressed data. Depreciated in 2010.
     680       * </pre>
     681       *
     682       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     683       */
     684      @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
     685        return instance.hasOBSOLETEBzip2Data();
     686      }
     687      /**
     688       * <pre>
     689       * Formerly used for bzip2 compressed data. Depreciated in 2010.
     690       * </pre>
     691       *
     692       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     693       */
     694      @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
     695        return instance.getOBSOLETEBzip2Data();
     696      }
     697      /**
     698       * <pre>
     699       * Formerly used for bzip2 compressed data. Depreciated in 2010.
     700       * </pre>
     701       *
     702       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     703       */
     704      @java.lang.Deprecated public Builder setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
     705        copyOnWrite();
     706        instance.setOBSOLETEBzip2Data(value);
     707        return this;
     708      }
     709      /**
     710       * <pre>
     711       * Formerly used for bzip2 compressed data. Depreciated in 2010.
     712       * </pre>
     713       *
     714       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
     715       */
     716      @java.lang.Deprecated public Builder clearOBSOLETEBzip2Data() {
     717        copyOnWrite();
     718        instance.clearOBSOLETEBzip2Data();
     719        return this;
     720      }
     721
     722      // @@protoc_insertion_point(builder_scope:OSMPBF.Blob)
     723    }
     724    @java.lang.SuppressWarnings({"unchecked", "fallthrough"})
     725    protected final java.lang.Object dynamicMethod(
     726        com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
     727        java.lang.Object arg0, java.lang.Object arg1) {
     728      switch (method) {
     729        case NEW_MUTABLE_INSTANCE: {
     730          return new crosby.binary.Fileformat.Blob();
     731        }
     732        case IS_INITIALIZED: {
     733          return DEFAULT_INSTANCE;
     734        }
     735        case MAKE_IMMUTABLE: {
     736          return null;
     737        }
     738        case NEW_BUILDER: {
     739          return new Builder();
     740        }
     741        case VISIT: {
     742          Visitor visitor = (Visitor) arg0;
     743          crosby.binary.Fileformat.Blob other = (crosby.binary.Fileformat.Blob) arg1;
     744          raw_ = visitor.visitByteString(
     745              hasRaw(), raw_,
     746              other.hasRaw(), other.raw_);
     747          rawSize_ = visitor.visitInt(
     748              hasRawSize(), rawSize_,
     749              other.hasRawSize(), other.rawSize_);
     750          zlibData_ = visitor.visitByteString(
     751              hasZlibData(), zlibData_,
     752              other.hasZlibData(), other.zlibData_);
     753          lzmaData_ = visitor.visitByteString(
     754              hasLzmaData(), lzmaData_,
     755              other.hasLzmaData(), other.lzmaData_);
     756          oBSOLETEBzip2Data_ = visitor.visitByteString(
     757              hasOBSOLETEBzip2Data(), oBSOLETEBzip2Data_,
     758              other.hasOBSOLETEBzip2Data(), other.oBSOLETEBzip2Data_);
     759          if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
     760              .INSTANCE) {
     761            bitField0_ |= other.bitField0_;
    603762          }
    604         }
    605         return this;
    606       }
    607       private int bitField0_;
    608 
    609       private com.google.protobuf.ByteString raw_ = com.google.protobuf.ByteString.EMPTY;
    610       /**
    611        * <code>optional bytes raw = 1;</code>
    612        *
    613        * <pre>
    614        * No compression
    615        * </pre>
    616        */
    617       @Override
    618         public boolean hasRaw() {
    619         return ((bitField0_ & 0x00000001) == 0x00000001);
    620       }
    621       /**
    622        * <code>optional bytes raw = 1;</code>
    623        *
    624        * <pre>
    625        * No compression
    626        * </pre>
    627        */
    628       @Override
    629         public com.google.protobuf.ByteString getRaw() {
    630         return raw_;
    631       }
    632       /**
    633        * <code>optional bytes raw = 1;</code>
    634        *
    635        * <pre>
    636        * No compression
    637        * </pre>
    638        */
    639       public Builder setRaw(com.google.protobuf.ByteString value) {
    640         if (value == null) {
    641     throw new NullPointerException();
    642   }
    643   bitField0_ |= 0x00000001;
    644         raw_ = value;
    645 
    646         return this;
    647       }
    648       /**
    649        * <code>optional bytes raw = 1;</code>
    650        *
    651        * <pre>
    652        * No compression
    653        * </pre>
    654        */
    655       public Builder clearRaw() {
    656         bitField0_ = (bitField0_ & ~0x00000001);
    657         raw_ = getDefaultInstance().getRaw();
    658 
    659         return this;
    660       }
    661 
    662       private int rawSize_ ;
    663       /**
    664        * <code>optional int32 raw_size = 2;</code>
    665        *
    666        * <pre>
    667        * When compressed, the uncompressed size
    668        * </pre>
    669        */
    670       @Override
    671         public boolean hasRawSize() {
    672         return ((bitField0_ & 0x00000002) == 0x00000002);
    673       }
    674       /**
    675        * <code>optional int32 raw_size = 2;</code>
    676        *
    677        * <pre>
    678        * When compressed, the uncompressed size
    679        * </pre>
    680        */
    681       @Override
    682         public int getRawSize() {
    683         return rawSize_;
    684       }
    685       /**
    686        * <code>optional int32 raw_size = 2;</code>
    687        *
    688        * <pre>
    689        * When compressed, the uncompressed size
    690        * </pre>
    691        */
    692       public Builder setRawSize(int value) {
    693         bitField0_ |= 0x00000002;
    694         rawSize_ = value;
    695 
    696         return this;
    697       }
    698       /**
    699        * <code>optional int32 raw_size = 2;</code>
    700        *
    701        * <pre>
    702        * When compressed, the uncompressed size
    703        * </pre>
    704        */
    705       public Builder clearRawSize() {
    706         bitField0_ = (bitField0_ & ~0x00000002);
    707         rawSize_ = 0;
    708 
    709         return this;
    710       }
    711 
    712       private com.google.protobuf.ByteString zlibData_ = com.google.protobuf.ByteString.EMPTY;
    713       /**
    714        * <code>optional bytes zlib_data = 3;</code>
    715        *
    716        * <pre>
    717        * Possible compressed versions of the data.
    718        * </pre>
    719        */
    720       @Override
    721         public boolean hasZlibData() {
    722         return ((bitField0_ & 0x00000004) == 0x00000004);
    723       }
    724       /**
    725        * <code>optional bytes zlib_data = 3;</code>
    726        *
    727        * <pre>
    728        * Possible compressed versions of the data.
    729        * </pre>
    730        */
    731       @Override
    732         public com.google.protobuf.ByteString getZlibData() {
    733         return zlibData_;
    734       }
    735       /**
    736        * <code>optional bytes zlib_data = 3;</code>
    737        *
    738        * <pre>
    739        * Possible compressed versions of the data.
    740        * </pre>
    741        */
    742       public Builder setZlibData(com.google.protobuf.ByteString value) {
    743         if (value == null) {
    744     throw new NullPointerException();
    745   }
    746   bitField0_ |= 0x00000004;
    747         zlibData_ = value;
    748 
    749         return this;
    750       }
    751       /**
    752        * <code>optional bytes zlib_data = 3;</code>
    753        *
    754        * <pre>
    755        * Possible compressed versions of the data.
    756        * </pre>
    757        */
    758       public Builder clearZlibData() {
    759         bitField0_ = (bitField0_ & ~0x00000004);
    760         zlibData_ = getDefaultInstance().getZlibData();
    761 
    762         return this;
    763       }
    764 
    765       private com.google.protobuf.ByteString lzmaData_ = com.google.protobuf.ByteString.EMPTY;
    766       /**
    767        * <code>optional bytes lzma_data = 4;</code>
    768        *
    769        * <pre>
    770        * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    771        * </pre>
    772        */
    773       @Override
    774         public boolean hasLzmaData() {
    775         return ((bitField0_ & 0x00000008) == 0x00000008);
    776       }
    777       /**
    778        * <code>optional bytes lzma_data = 4;</code>
    779        *
    780        * <pre>
    781        * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    782        * </pre>
    783        */
    784       @Override
    785         public com.google.protobuf.ByteString getLzmaData() {
    786         return lzmaData_;
    787       }
    788       /**
    789        * <code>optional bytes lzma_data = 4;</code>
    790        *
    791        * <pre>
    792        * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    793        * </pre>
    794        */
    795       public Builder setLzmaData(com.google.protobuf.ByteString value) {
    796         if (value == null) {
    797     throw new NullPointerException();
    798   }
    799   bitField0_ |= 0x00000008;
    800         lzmaData_ = value;
    801 
    802         return this;
    803       }
    804       /**
    805        * <code>optional bytes lzma_data = 4;</code>
    806        *
    807        * <pre>
    808        * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
    809        * </pre>
    810        */
    811       public Builder clearLzmaData() {
    812         bitField0_ = (bitField0_ & ~0x00000008);
    813         lzmaData_ = getDefaultInstance().getLzmaData();
    814 
    815         return this;
    816       }
    817 
    818       private com.google.protobuf.ByteString oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
    819       /**
    820        * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    821        *
    822        * <pre>
    823        * Formerly used for bzip2 compressed data. Depreciated in 2010.
    824        * </pre>
    825        */
    826       @Override
    827         @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
    828         return ((bitField0_ & 0x00000010) == 0x00000010);
    829       }
    830       /**
    831        * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    832        *
    833        * <pre>
    834        * Formerly used for bzip2 compressed data. Depreciated in 2010.
    835        * </pre>
    836        */
    837       @Override
    838         @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
    839         return oBSOLETEBzip2Data_;
    840       }
    841       /**
    842        * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    843        *
    844        * <pre>
    845        * Formerly used for bzip2 compressed data. Depreciated in 2010.
    846        * </pre>
    847        */
    848       @java.lang.Deprecated public Builder setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
    849         if (value == null) {
    850     throw new NullPointerException();
    851   }
    852   bitField0_ |= 0x00000010;
    853         oBSOLETEBzip2Data_ = value;
    854 
    855         return this;
    856       }
    857       /**
    858        * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
    859        *
    860        * <pre>
    861        * Formerly used for bzip2 compressed data. Depreciated in 2010.
    862        * </pre>
    863        */
    864       @java.lang.Deprecated public Builder clearOBSOLETEBzip2Data() {
    865         bitField0_ = (bitField0_ & ~0x00000010);
    866         oBSOLETEBzip2Data_ = getDefaultInstance().getOBSOLETEBzip2Data();
    867 
    868         return this;
    869       }
    870 
    871       // @@protoc_insertion_point(builder_scope:OSMPBF.Blob)
    872     }
    873 
     763          return this;
     764        }
     765        case MERGE_FROM_STREAM: {
     766          com.google.protobuf.CodedInputStream input =
     767              (com.google.protobuf.CodedInputStream) arg0;
     768          com.google.protobuf.ExtensionRegistryLite extensionRegistry =
     769              (com.google.protobuf.ExtensionRegistryLite) arg1;
     770          try {
     771            boolean done = false;
     772            while (!done) {
     773              int tag = input.readTag();
     774              switch (tag) {
     775                case 0:
     776                  done = true;
     777                  break;
     778                default: {
     779                  if (!parseUnknownField(tag, input)) {
     780                    done = true;
     781                  }
     782                  break;
     783                }
     784                case 10: {
     785                  bitField0_ |= 0x00000001;
     786                  raw_ = input.readBytes();
     787                  break;
     788                }
     789                case 16: {
     790                  bitField0_ |= 0x00000002;
     791                  rawSize_ = input.readInt32();
     792                  break;
     793                }
     794                case 26: {
     795                  bitField0_ |= 0x00000004;
     796                  zlibData_ = input.readBytes();
     797                  break;
     798                }
     799                case 34: {
     800                  bitField0_ |= 0x00000008;
     801                  lzmaData_ = input.readBytes();
     802                  break;
     803                }
     804                case 42: {
     805                  bitField0_ |= 0x00000010;
     806                  oBSOLETEBzip2Data_ = input.readBytes();
     807                  break;
     808                }
     809              }
     810            }
     811          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
     812            throw new RuntimeException(e.setUnfinishedMessage(this));
     813          } catch (java.io.IOException e) {
     814            throw new RuntimeException(
     815                new com.google.protobuf.InvalidProtocolBufferException(
     816                    e.getMessage()).setUnfinishedMessage(this));
     817          } finally {
     818          }
     819        }
     820        // fall through
     821        case GET_DEFAULT_INSTANCE: {
     822          return DEFAULT_INSTANCE;
     823        }
     824        case GET_PARSER: {
     825          if (PARSER == null) {    synchronized (crosby.binary.Fileformat.Blob.class) {
     826              if (PARSER == null) {
     827                PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
     828              }
     829            }
     830          }
     831          return PARSER;
     832        }
     833      }
     834      throw new UnsupportedOperationException();
     835    }
     836
     837
     838    // @@protoc_insertion_point(class_scope:OSMPBF.Blob)
     839    private static final crosby.binary.Fileformat.Blob DEFAULT_INSTANCE;
    874840    static {
    875       defaultInstance = new Blob(true);
    876       defaultInstance.initFields();
    877     }
    878 
    879     // @@protoc_insertion_point(class_scope:OSMPBF.Blob)
     841      DEFAULT_INSTANCE = new Blob();
     842      DEFAULT_INSTANCE.makeImmutable();
     843    }
     844
     845    public static crosby.binary.Fileformat.Blob getDefaultInstance() {
     846      return DEFAULT_INSTANCE;
     847    }
     848
     849    private static volatile com.google.protobuf.Parser<Blob> PARSER;
     850
     851    public static com.google.protobuf.Parser<Blob> parser() {
     852      return DEFAULT_INSTANCE.getParserForType();
     853    }
    880854  }
    881855
    … …  
    919893   * Protobuf type {@code OSMPBF.BlobHeader}
    920894   */
    921   public static final class BlobHeader extends
    922       com.google.protobuf.GeneratedMessageLite implements
     895  public  static final class BlobHeader extends
     896      com.google.protobuf.GeneratedMessageLite<
     897          BlobHeader, BlobHeader.Builder> implements
    923898      // @@protoc_insertion_point(message_implements:OSMPBF.BlobHeader)
    924899      BlobHeaderOrBuilder {
    925     // Use BlobHeader.newBuilder() to construct.
    926     private BlobHeader(com.google.protobuf.GeneratedMessageLite.Builder builder) {
    927       super(builder);
    928       this.unknownFields = builder.getUnknownFields();
    929     }
    930     private BlobHeader(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
    931 
    932     private static final BlobHeader defaultInstance;
    933     public static BlobHeader getDefaultInstance() {
    934       return defaultInstance;
    935     }
    936 
    937     @Override
    938         public BlobHeader getDefaultInstanceForType() {
    939       return defaultInstance;
    940     }
    941 
    942     private final com.google.protobuf.ByteString unknownFields;
    943     private BlobHeader(
    944         com.google.protobuf.CodedInputStream input,
    945         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    946         throws com.google.protobuf.InvalidProtocolBufferException {
    947       initFields();
    948       int mutable_bitField0_ = 0;
    949       com.google.protobuf.ByteString.Output unknownFieldsOutput =
    950           com.google.protobuf.ByteString.newOutput();
    951       com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
    952           com.google.protobuf.CodedOutputStream.newInstance(
    953               unknownFieldsOutput);
    954       try {
    955         boolean done = false;
    956         while (!done) {
    957           int tag = input.readTag();
    958           switch (tag) {
    959             case 0:
    960               done = true;
    961               break;
    962             default: {
    963               if (!parseUnknownField(input, unknownFieldsCodedOutput,
    964                                      extensionRegistry, tag)) {
    965                 done = true;
    966               }
    967               break;
    968             }
    969             case 10: {
    970               com.google.protobuf.ByteString bs = input.readBytes();
    971               bitField0_ |= 0x00000001;
    972               type_ = bs;
    973               break;
    974             }
    975             case 18: {
    976               bitField0_ |= 0x00000002;
    977               indexdata_ = input.readBytes();
    978               break;
    979             }
    980             case 24: {
    981               bitField0_ |= 0x00000004;
    982               datasize_ = input.readInt32();
    983               break;
    984             }
    985           }
    986         }
    987       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
    988         throw e.setUnfinishedMessage(this);
    989       } catch (java.io.IOException e) {
    990         throw new com.google.protobuf.InvalidProtocolBufferException(
    991             e.getMessage()).setUnfinishedMessage(this);
    992       } finally {
    993         try {
    994           unknownFieldsCodedOutput.flush();
    995         } catch (java.io.IOException e) {
    996         // Should not happen
    997         } finally {
    998           unknownFields = unknownFieldsOutput.toByteString();
    999         }
    1000         makeExtensionsImmutable();
    1001       }
    1002     }
    1003     public static com.google.protobuf.Parser<BlobHeader> PARSER =
    1004         new com.google.protobuf.AbstractParser<BlobHeader>() {
    1005       @Override
    1006         public BlobHeader parsePartialFrom(
    1007           com.google.protobuf.CodedInputStream input,
    1008           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    1009           throws com.google.protobuf.InvalidProtocolBufferException {
    1010         return new BlobHeader(input, extensionRegistry);
    1011       }
    1012     };
    1013 
    1014     @java.lang.Override
    1015     public com.google.protobuf.Parser<BlobHeader> getParserForType() {
    1016       return PARSER;
    1017     }
    1018 
     900    private BlobHeader() {
     901      type_ = "";
     902      indexdata_ = com.google.protobuf.ByteString.EMPTY;
     903    }
    1019904    private int bitField0_;
    1020905    public static final int TYPE_FIELD_NUMBER = 1;
    1021     private java.lang.Object type_;
     906    private java.lang.String type_;
    1022907    /**
    1023908     * <code>required string type = 1;</code>
    1024909     */
    1025     @Override
    1026         public boolean hasType() {
     910    public boolean hasType() {
    1027911      return ((bitField0_ & 0x00000001) == 0x00000001);
    1028912    }
    … …  
    1030914     * <code>required string type = 1;</code>
    1031915     */
    1032     @Override
    1033         public java.lang.String getType() {
    1034       java.lang.Object ref = type_;
    1035       if (ref instanceof java.lang.String) {
    1036         return (java.lang.String) ref;
    1037       } else {
    1038         com.google.protobuf.ByteString bs =
    1039             (com.google.protobuf.ByteString) ref;
    1040         java.lang.String s = bs.toStringUtf8();
    1041         if (bs.isValidUtf8()) {
    1042           type_ = s;
    1043         }
    1044         return s;
    1045       }
     916    public java.lang.String getType() {
     917      return type_;
    1046918    }
    1047919    /**
    1048920     * <code>required string type = 1;</code>
    1049921     */
    1050     @Override
    1051         public com.google.protobuf.ByteString
     922    public com.google.protobuf.ByteString
    1052923        getTypeBytes() {
    1053       java.lang.Object ref = type_;
    1054       if (ref instanceof java.lang.String) {
    1055         com.google.protobuf.ByteString b =
    1056             com.google.protobuf.ByteString.copyFromUtf8(
    1057                 (java.lang.String) ref);
    1058         type_ = b;
    1059         return b;
    1060       } else {
    1061         return (com.google.protobuf.ByteString) ref;
    1062       }
     924      return com.google.protobuf.ByteString.copyFromUtf8(type_);
     925    }
     926    /**
     927     * <code>required string type = 1;</code>
     928     */
     929    private void setType(
     930        java.lang.String value) {
     931      if (value == null) {
     932    throw new NullPointerException();
     933  }
     934  bitField0_ |= 0x00000001;
     935      type_ = value;
     936    }
     937    /**
     938     * <code>required string type = 1;</code>
     939     */
     940    private void clearType() {
     941      bitField0_ = (bitField0_ & ~0x00000001);
     942      type_ = getDefaultInstance().getType();
     943    }
     944    /**
     945     * <code>required string type = 1;</code>
     946     */
     947    private void setTypeBytes(
     948        com.google.protobuf.ByteString value) {
     949      if (value == null) {
     950    throw new NullPointerException();
     951  }
     952  bitField0_ |= 0x00000001;
     953      type_ = value.toStringUtf8();
    1063954    }
    1064955
    … …  
    1068959     * <code>optional bytes indexdata = 2;</code>
    1069960     */
    1070     @Override
    1071         public boolean hasIndexdata() {
     961    public boolean hasIndexdata() {
    1072962      return ((bitField0_ & 0x00000002) == 0x00000002);
    1073963    }
    … …  
    1075965     * <code>optional bytes indexdata = 2;</code>
    1076966     */
    1077     @Override
    1078         public com.google.protobuf.ByteString getIndexdata() {
     967    public com.google.protobuf.ByteString getIndexdata() {
    1079968      return indexdata_;
     969    }
     970    /**
     971     * <code>optional bytes indexdata = 2;</code>
     972     */
     973    private void setIndexdata(com.google.protobuf.ByteString value) {
     974      if (value == null) {
     975    throw new NullPointerException();
     976  }
     977  bitField0_ |= 0x00000002;
     978      indexdata_ = value;
     979    }
     980    /**
     981     * <code>optional bytes indexdata = 2;</code>
     982     */
     983    private void clearIndexdata() {
     984      bitField0_ = (bitField0_ & ~0x00000002);
     985      indexdata_ = getDefaultInstance().getIndexdata();
    1080986    }
    1081987
    … …  
    1085991     * <code>required int32 datasize = 3;</code>
    1086992     */
    1087     @Override
    1088         public boolean hasDatasize() {
     993    public boolean hasDatasize() {
    1089994      return ((bitField0_ & 0x00000004) == 0x00000004);
    1090995    }
    … …  
    1092997     * <code>required int32 datasize = 3;</code>
    1093998     */
    1094     @Override
    1095         public int getDatasize() {
     999    public int getDatasize() {
    10961000      return datasize_;
    10971001    }
    1098 
    1099     private void initFields() {
    1100       type_ = "";
    1101       indexdata_ = com.google.protobuf.ByteString.EMPTY;
     1002    /**
     1003     * <code>required int32 datasize = 3;</code>
     1004     */
     1005    private void setDatasize(int value) {
     1006      bitField0_ |= 0x00000004;
     1007      datasize_ = value;
     1008    }
     1009    /**
     1010     * <code>required int32 datasize = 3;</code>
     1011     */
     1012    private void clearDatasize() {
     1013      bitField0_ = (bitField0_ & ~0x00000004);
    11021014      datasize_ = 0;
    11031015    }
    1104     private byte memoizedIsInitialized = -1;
    1105     @Override
    1106         public final boolean isInitialized() {
    1107       byte isInitialized = memoizedIsInitialized;
    1108       if (isInitialized == 1) return true;
    1109       if (isInitialized == 0) return false;
    1110 
    1111       if (!hasType()) {
    1112         memoizedIsInitialized = 0;
    1113         return false;
    1114       }
    1115       if (!hasDatasize()) {
    1116         memoizedIsInitialized = 0;
    1117         return false;
    1118       }
    1119       memoizedIsInitialized = 1;
    1120       return true;
    1121     }
    1122 
    1123     @Override
    1124         public void writeTo(com.google.protobuf.CodedOutputStream output)
     1016
     1017    public void writeTo(com.google.protobuf.CodedOutputStream output)
    11251018                        throws java.io.IOException {
    1126       getSerializedSize();
    11271019      if (((bitField0_ & 0x00000001) == 0x00000001)) {
    1128         output.writeBytes(1, getTypeBytes());
     1020        output.writeString(1, getType());
    11291021      }
    11301022      if (((bitField0_ & 0x00000002) == 0x00000002)) {
    … …  
    11341026        output.writeInt32(3, datasize_);
    11351027      }
    1136       output.writeRawBytes(unknownFields);
    1137     }
    1138 
    1139     private int memoizedSerializedSize = -1;
    1140     @Override
    1141         public int getSerializedSize() {
     1028      unknownFields.writeTo(output);
     1029    }
     1030
     1031    public int getSerializedSize() {
    11421032      int size = memoizedSerializedSize;
    11431033      if (size != -1) return size;
    … …  
    11461036      if (((bitField0_ & 0x00000001) == 0x00000001)) {
    11471037        size += com.google.protobuf.CodedOutputStream
    1148           .computeBytesSize(1, getTypeBytes());
     1038          .computeStringSize(1, getType());
    11491039      }
    11501040      if (((bitField0_ & 0x00000002) == 0x00000002)) {
    … …  
    11561046          .computeInt32Size(3, datasize_);
    11571047      }
    1158       size += unknownFields.size();
     1048      size += unknownFields.getSerializedSize();
    11591049      memoizedSerializedSize = size;
    11601050      return size;
    11611051    }
    11621052
    1163     private static final long serialVersionUID = 0L;
    1164     @java.lang.Override
    1165     protected java.lang.Object writeReplace()
    1166         throws java.io.ObjectStreamException {
    1167       return super.writeReplace();
    1168     }
    1169 
     1053    public static crosby.binary.Fileformat.BlobHeader parseFrom(
     1054        java.nio.ByteBuffer data)
     1055        throws com.google.protobuf.InvalidProtocolBufferException {
     1056      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1057          DEFAULT_INSTANCE, data);
     1058    }
     1059    public static crosby.binary.Fileformat.BlobHeader parseFrom(
     1060        java.nio.ByteBuffer data,
     1061        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
     1062        throws com.google.protobuf.InvalidProtocolBufferException {
     1063      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1064          DEFAULT_INSTANCE, data, extensionRegistry);
     1065    }
    11701066    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    11711067        com.google.protobuf.ByteString data)
    11721068        throws com.google.protobuf.InvalidProtocolBufferException {
    1173       return PARSER.parseFrom(data);
     1069      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1070          DEFAULT_INSTANCE, data);
    11741071    }
    11751072    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    … …  
    11771074        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    11781075        throws com.google.protobuf.InvalidProtocolBufferException {
    1179       return PARSER.parseFrom(data, extensionRegistry);
     1076      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1077          DEFAULT_INSTANCE, data, extensionRegistry);
    11801078    }
    11811079    public static crosby.binary.Fileformat.BlobHeader parseFrom(byte[] data)
    11821080        throws com.google.protobuf.InvalidProtocolBufferException {
    1183       return PARSER.parseFrom(data);
     1081      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1082          DEFAULT_INSTANCE, data);
    11841083    }
    11851084    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    … …  
    11871086        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    11881087        throws com.google.protobuf.InvalidProtocolBufferException {
    1189       return PARSER.parseFrom(data, extensionRegistry);
     1088      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1089          DEFAULT_INSTANCE, data, extensionRegistry);
    11901090    }
    11911091    public static crosby.binary.Fileformat.BlobHeader parseFrom(java.io.InputStream input)
    11921092        throws java.io.IOException {
    1193       return PARSER.parseFrom(input);
     1093      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1094          DEFAULT_INSTANCE, input);
    11941095    }
    11951096    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    … …  
    11971098        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    11981099        throws java.io.IOException {
    1199       return PARSER.parseFrom(input, extensionRegistry);
     1100      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1101          DEFAULT_INSTANCE, input, extensionRegistry);
    12001102    }
    12011103    public static crosby.binary.Fileformat.BlobHeader parseDelimitedFrom(java.io.InputStream input)
    12021104        throws java.io.IOException {
    1203       return PARSER.parseDelimitedFrom(input);
     1105      return parseDelimitedFrom(DEFAULT_INSTANCE, input);
    12041106    }
    12051107    public static crosby.binary.Fileformat.BlobHeader parseDelimitedFrom(
    … …  
    12071109        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    12081110        throws java.io.IOException {
    1209       return PARSER.parseDelimitedFrom(input, extensionRegistry);
     1111      return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);
    12101112    }
    12111113    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    12121114        com.google.protobuf.CodedInputStream input)
    12131115        throws java.io.IOException {
    1214       return PARSER.parseFrom(input);
     1116      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1117          DEFAULT_INSTANCE, input);
    12151118    }
    12161119    public static crosby.binary.Fileformat.BlobHeader parseFrom(
    … …  
    12181121        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    12191122        throws java.io.IOException {
    1220       return PARSER.parseFrom(input, extensionRegistry);
    1221     }
    1222 
    1223     public static Builder newBuilder() { return Builder.create(); }
    1224     @Override
    1225         public Builder newBuilderForType() { return newBuilder(); }
     1123      return com.google.protobuf.GeneratedMessageLite.parseFrom(
     1124          DEFAULT_INSTANCE, input, extensionRegistry);
     1125    }
     1126
     1127    public static Builder newBuilder() {
     1128      return DEFAULT_INSTANCE.toBuilder();
     1129    }
    12261130    public static Builder newBuilder(crosby.binary.Fileformat.BlobHeader prototype) {
    1227       return newBuilder().mergeFrom(prototype);
    1228     }
    1229     @Override
    1230         public Builder toBuilder() { return newBuilder(this); }
     1131      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     1132    }
    12311133
    12321134    /**
    … …  
    12351137    public static final class Builder extends
    12361138        com.google.protobuf.GeneratedMessageLite.Builder<
    1237           crosby.binary.Fileformat.BlobHeader, Builder>
    1238         implements
     1139          crosby.binary.Fileformat.BlobHeader, Builder> implements
    12391140        // @@protoc_insertion_point(builder_implements:OSMPBF.BlobHeader)
    12401141        crosby.binary.Fileformat.BlobHeaderOrBuilder {
    12411142      // Construct using crosby.binary.Fileformat.BlobHeader.newBuilder()
    12421143      private Builder() {
    1243         maybeForceBuilderInitialization();
    1244       }
    1245 
    1246       private void maybeForceBuilderInitialization() {
    1247       }
    1248       private static Builder create() {
    1249         return new Builder();
    1250       }
    1251 
    1252       @Override
    1253         public Builder clear() {
    1254         super.clear();
    1255         type_ = "";
    1256         bitField0_ = (bitField0_ & ~0x00000001);
    1257         indexdata_ = com.google.protobuf.ByteString.EMPTY;
    1258         bitField0_ = (bitField0_ & ~0x00000002);
    1259         datasize_ = 0;
    1260         bitField0_ = (bitField0_ & ~0x00000004);
    1261         return this;
    1262       }
    1263 
    1264       @Override
    1265         public Builder clone() {
    1266         return create().mergeFrom(buildPartial());
    1267       }
    1268 
    1269       @Override
    1270         public crosby.binary.Fileformat.BlobHeader getDefaultInstanceForType() {
    1271         return crosby.binary.Fileformat.BlobHeader.getDefaultInstance();
    1272       }
    1273 
    1274       @Override
    1275         public crosby.binary.Fileformat.BlobHeader build() {
    1276         crosby.binary.Fileformat.BlobHeader result = buildPartial();
    1277         if (!result.isInitialized()) {
    1278           throw newUninitializedMessageException(result);
    1279         }
    1280         return result;
    1281       }
    1282 
    1283       @Override
    1284         public crosby.binary.Fileformat.BlobHeader buildPartial() {
    1285         crosby.binary.Fileformat.BlobHeader result = new crosby.binary.Fileformat.BlobHeader(this);
    1286         int from_bitField0_ = bitField0_;
    1287         int to_bitField0_ = 0;
    1288         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
    1289           to_bitField0_ |= 0x00000001;
    1290         }
    1291         result.type_ = type_;
    1292         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
    1293           to_bitField0_ |= 0x00000002;
    1294         }
    1295         result.indexdata_ = indexdata_;
    1296         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
    1297           to_bitField0_ |= 0x00000004;
    1298         }
    1299         result.datasize_ = datasize_;
    1300         result.bitField0_ = to_bitField0_;
    1301         return result;
    1302       }
    1303 
    1304       @Override
    1305         public Builder mergeFrom(crosby.binary.Fileformat.BlobHeader other) {
    1306         if (other == crosby.binary.Fileformat.BlobHeader.getDefaultInstance()) return this;
    1307         if (other.hasType()) {
    1308           bitField0_ |= 0x00000001;
    1309           type_ = other.type_;
    1310 
    1311         }
    1312         if (other.hasIndexdata()) {
    1313           setIndexdata(other.getIndexdata());
    1314         }
    1315         if (other.hasDatasize()) {
    1316           setDatasize(other.getDatasize());
    1317         }
    1318         setUnknownFields(
    1319             getUnknownFields().concat(other.unknownFields));
    1320         return this;
    1321       }
    1322 
    1323       @Override
    1324         public final boolean isInitialized() {
    1325         if (!hasType()) {
    1326 
    1327           return false;
    1328         }
    1329         if (!hasDatasize()) {
    1330 
    1331           return false;
    1332         }
    1333         return true;
    1334       }
    1335 
    1336       @Override
    1337         public Builder mergeFrom(
    1338           com.google.protobuf.CodedInputStream input,
    1339           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
    1340           throws java.io.IOException {
    1341         crosby.binary.Fileformat.BlobHeader parsedMessage = null;
    1342         try {
    1343           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
    1344         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
    1345           parsedMessage = (crosby.binary.Fileformat.BlobHeader) e.getUnfinishedMessage();
    1346           throw e;
    1347         } finally {
    1348           if (parsedMessage != null) {
    1349             mergeFrom(parsedMessage);
    1350           }
    1351         }
    1352         return this;
    1353       }
    1354       private int bitField0_;
    1355 
    1356       private java.lang.Object type_ = "";
     1144        super(DEFAULT_INSTANCE);
     1145      }
     1146
     1147
    13571148      /**
    13581149       * <code>required string type = 1;</code>
    13591150       */
    1360       @Override
    1361         public boolean hasType() {
    1362         return ((bitField0_ & 0x00000001) == 0x00000001);
     1151      public boolean hasType() {
     1152        return instance.hasType();
    13631153      }
    13641154      /**
    13651155       * <code>required string type = 1;</code>
    13661156       */
    1367       @Override
    1368         public java.lang.String getType() {
    1369         java.lang.Object ref = type_;
    1370         if (!(ref instanceof java.lang.String)) {
    1371           com.google.protobuf.ByteString bs =
    1372               (com.google.protobuf.ByteString) ref;
    1373           java.lang.String s = bs.toStringUtf8();
    1374           if (bs.isValidUtf8()) {
    1375             type_ = s;
    1376           }
    1377           return s;
    1378         } else {
    1379           return (java.lang.String) ref;
    1380         }
     1157      public java.lang.String getType() {
     1158        return instance.getType();
    13811159      }
    13821160      /**
    13831161       * <code>required string type = 1;</code>
    13841162       */
    1385       @Override
    1386         public com.google.protobuf.ByteString
     1163      public com.google.protobuf.ByteString
    13871164          getTypeBytes() {
    1388         java.lang.Object ref = type_;
    1389         if (ref instanceof String) {
    1390           com.google.protobuf.ByteString b =
    1391               com.google.protobuf.ByteString.copyFromUtf8(
    1392                   (java.lang.String) ref);
    1393           type_ = b;
    1394           return b;
    1395         } else {
    1396           return (com.google.protobuf.ByteString) ref;
    1397         }
     1165        return instance.getTypeBytes();
    13981166      }
    13991167      /**
    … …  
    14021170      public Builder setType(
    14031171          java.lang.String value) {
    1404         if (value == null) {
    1405     throw new NullPointerException();
    1406   }
    1407   bitField0_ |= 0x00000001;
    1408         type_ = value;
    1409 
     1172        copyOnWrite();
     1173        instance.setType(value);
    14101174        return this;
    14111175      }
    … …  
    14141178       */
    14151179      public Builder clearType() {
    1416         bitField0_ = (bitField0_ & ~0x00000001);
    1417         type_ = getDefaultInstance().getType();
    1418 
     1180        copyOnWrite();
     1181        instance.clearType();
    14191182        return this;
    14201183      }
    … …  
    14241187      public Builder setTypeBytes(
    14251188          com.google.protobuf.ByteString value) {
    1426         if (value == null) {
    1427     throw new NullPointerException();
    1428   }
    1429   bitField0_ |= 0x00000001;
    1430         type_ = value;
    1431 
    1432         return this;
    1433       }
    1434 
    1435       private com.google.protobuf.ByteString indexdata_ = com.google.protobuf.ByteString.EMPTY;
     1189        copyOnWrite();
     1190        instance.setTypeBytes(value);
     1191        return this;
     1192      }
     1193
    14361194      /**
    14371195       * <code>optional bytes indexdata = 2;</code>
    14381196       */
    1439       @Override
    1440         public boolean hasIndexdata() {
    1441         return ((bitField0_ & 0x00000002) == 0x00000002);
     1197      public boolean hasIndexdata() {
     1198        return instance.hasIndexdata();
    14421199      }
    14431200      /**
    14441201       * <code>optional bytes indexdata = 2;</code>
    14451202       */
    1446       @Override
    1447         public com.google.protobuf.ByteString getIndexdata() {
    1448         return indexdata_;
     1203      public com.google.protobuf.ByteString getIndexdata() {
     1204        return instance.getIndexdata();
    14491205      }
    14501206      /**
    … …  
    14521208       */
    14531209      public Builder setIndexdata(com.google.protobuf.ByteString value) {
    1454         if (value == null) {
    1455     throw new NullPointerException();
    1456   }
    1457   bitField0_ |= 0x00000002;
    1458         indexdata_ = value;
    1459 
     1210        copyOnWrite();
     1211        instance.setIndexdata(value);
    14601212        return this;
    14611213      }
    … …  
    14641216       */
    14651217      public Builder clearIndexdata() {
    1466         bitField0_ = (bitField0_ & ~0x00000002);
    1467         indexdata_ = getDefaultInstance().getIndexdata();
    1468 
    1469         return this;
    1470       }
    1471 
    1472       private int datasize_ ;
     1218        copyOnWrite();
     1219        instance.clearIndexdata();
     1220        return this;
     1221      }
     1222
    14731223      /**
    14741224       * <code>required int32 datasize = 3;</code>
    14751225       */
    1476       @Override
    1477         public boolean hasDatasize() {
    1478         return ((bitField0_ & 0x00000004) == 0x00000004);
     1226      public boolean hasDatasize() {
     1227        return instance.hasDatasize();
    14791228      }
    14801229      /**
    14811230       * <code>required int32 datasize = 3;</code>
    14821231       */
    1483       @Override
    1484         public int getDatasize() {
    1485         return datasize_;
     1232      public int getDatasize() {
     1233        return instance.getDatasize();
    14861234      }
    14871235      /**
    … …  
    14891237       */
    14901238      public Builder setDatasize(int value) {
    1491         bitField0_ |= 0x00000004;
    1492         datasize_ = value;
    1493 
     1239        copyOnWrite();
     1240        instance.setDatasize(value);
    14941241        return this;
    14951242      }
    … …  
    14981245       */
    14991246      public Builder clearDatasize() {
    1500         bitField0_ = (bitField0_ & ~0x00000004);
    1501         datasize_ = 0;
    1502 
     1247        copyOnWrite();
     1248        instance.clearDatasize();
    15031249        return this;
    15041250      }
    … …  
    15061252      // @@protoc_insertion_point(builder_scope:OSMPBF.BlobHeader)
    15071253    }
    1508 
     1254    private byte memoizedIsInitialized = -1;
     1255    @java.lang.SuppressWarnings({"unchecked", "fallthrough"})
     1256    protected final java.lang.Object dynamicMethod(
     1257        com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,
     1258        java.lang.Object arg0, java.lang.Object arg1) {
     1259      switch (method) {
     1260        case NEW_MUTABLE_INSTANCE: {
     1261          return new crosby.binary.Fileformat.BlobHeader();
     1262        }
     1263        case IS_INITIALIZED: {
     1264          byte isInitialized = memoizedIsInitialized;
     1265          if (isInitialized == 1) return DEFAULT_INSTANCE;
     1266          if (isInitialized == 0) return null;
     1267
     1268          boolean shouldMemoize = ((Boolean) arg0).booleanValue();
     1269          if (!hasType()) {
     1270            if (shouldMemoize) {
     1271              memoizedIsInitialized = 0;
     1272            }
     1273            return null;
     1274          }
     1275          if (!hasDatasize()) {
     1276            if (shouldMemoize) {
     1277              memoizedIsInitialized = 0;
     1278            }
     1279            return null;
     1280          }
     1281          if (shouldMemoize) memoizedIsInitialized = 1;
     1282          return DEFAULT_INSTANCE;
     1283
     1284        }
     1285        case MAKE_IMMUTABLE: {
     1286          return null;
     1287        }
     1288        case NEW_BUILDER: {
     1289          return new Builder();
     1290        }
     1291        case VISIT: {
     1292          Visitor visitor = (Visitor) arg0;
     1293          crosby.binary.Fileformat.BlobHeader other = (crosby.binary.Fileformat.BlobHeader) arg1;
     1294          type_ = visitor.visitString(
     1295              hasType(), type_,
     1296              other.hasType(), other.type_);
     1297          indexdata_ = visitor.visitByteString(
     1298              hasIndexdata(), indexdata_,
     1299              other.hasIndexdata(), other.indexdata_);
     1300          datasize_ = visitor.visitInt(
     1301              hasDatasize(), datasize_,
     1302              other.hasDatasize(), other.datasize_);
     1303          if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor
     1304              .INSTANCE) {
     1305            bitField0_ |= other.bitField0_;
     1306          }
     1307          return this;
     1308        }
     1309        case MERGE_FROM_STREAM: {
     1310          com.google.protobuf.CodedInputStream input =
     1311              (com.google.protobuf.CodedInputStream) arg0;
     1312          com.google.protobuf.ExtensionRegistryLite extensionRegistry =
     1313              (com.google.protobuf.ExtensionRegistryLite) arg1;
     1314          try {
     1315            boolean done = false;
     1316            while (!done) {
     1317              int tag = input.readTag();
     1318              switch (tag) {
     1319                case 0:
     1320                  done = true;
     1321                  break;
     1322                default: {
     1323                  if (!parseUnknownField(tag, input)) {
     1324                    done = true;
     1325                  }
     1326                  break;
     1327                }
     1328                case 10: {
     1329                  java.lang.String s = input.readString();
     1330                  bitField0_ |= 0x00000001;
     1331                  type_ = s;
     1332                  break;
     1333                }
     1334                case 18: {
     1335                  bitField0_ |= 0x00000002;
     1336                  indexdata_ = input.readBytes();
     1337                  break;
     1338                }
     1339                case 24: {
     1340                  bitField0_ |= 0x00000004;
     1341                  datasize_ = input.readInt32();
     1342                  break;
     1343                }
     1344              }
     1345            }
     1346          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
     1347            throw new RuntimeException(e.setUnfinishedMessage(this));
     1348          } catch (java.io.IOException e) {
     1349            throw new RuntimeException(
     1350                new com.google.protobuf.InvalidProtocolBufferException(
     1351                    e.getMessage()).setUnfinishedMessage(this));
     1352          } finally {
     1353          }
     1354        }
     1355        // fall through
     1356        case GET_DEFAULT_INSTANCE: {
     1357          return DEFAULT_INSTANCE;
     1358        }
     1359        case GET_PARSER: {
     1360          if (PARSER == null) {    synchronized (crosby.binary.Fileformat.BlobHeader.class) {
     1361              if (PARSER == null) {
     1362                PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
     1363              }
     1364            }
     1365          }
     1366          return PARSER;
     1367        }
     1368      }
     1369      throw new UnsupportedOperationException();
     1370    }
     1371
     1372
     1373    // @@protoc_insertion_point(class_scope:OSMPBF.BlobHeader)
     1374    private static final crosby.binary.Fileformat.BlobHeader DEFAULT_INSTANCE;
    15091375    static {
    1510       defaultInstance = new BlobHeader(true);
    1511       defaultInstance.initFields();
    1512     }
    1513 
    1514     // @@protoc_insertion_point(class_scope:OSMPBF.BlobHeader)
     1376      DEFAULT_INSTANCE = new BlobHeader();
     1377      DEFAULT_INSTANCE.makeImmutable();
     1378    }
     1379
     1380    public static crosby.binary.Fileformat.BlobHeader getDefaultInstance() {
     1381      return DEFAULT_INSTANCE;
     1382    }
     1383
     1384    private static volatile com.google.protobuf.Parser<BlobHeader> PARSER;
     1385
     1386    public static com.google.protobuf.Parser<BlobHeader> parser() {
     1387      return DEFAULT_INSTANCE.getParserForType();
     1388    }
    15151389  }
    15161390
Note: See TracChangeset for help on using the changeset viewer.