← Back to branch summary

~ubuntu-branches/debian/stretch/protobuf/stretch

« back to all changes in this revision

Viewing changes to java/src/main/java/com/google/protobuf/GeneratedMessage.java

  • Committer: Package Import Robot
  • Author(s): Robert S. Edmonds
  • Date: 2014-09-11 22:50:10 UTC
  • mfrom: (10.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20140911225010-wt4yo9dpc1fzuq5g
Tags: 2.6.0-3
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/src/main/java/com/google/protobuf/GeneratedMessage.java
33
33
import com.google.protobuf.Descriptors.Descriptor;
34
34
import com.google.protobuf.Descriptors.EnumValueDescriptor;
35
35
import com.google.protobuf.Descriptors.FieldDescriptor;
 
36
import com.google.protobuf.Descriptors.FileDescriptor;
 
37
import com.google.protobuf.Descriptors.OneofDescriptor;
36
38
 
37
39
import java.io.IOException;
38
40
import java.io.ObjectStreamException;
71
73
  protected GeneratedMessage(Builder<?> builder) {
72
74
  }
73
75
 
74
 
  public Parser<? extends Message> getParserForType() {
 
76
  public Parser<? extends GeneratedMessage> getParserForType() {
75
77
    throw new UnsupportedOperationException(
76
78
        "This is supposed to be overridden by subclasses.");
77
79
  }
154
156
  }
155
157
 
156
158
  //@Override (Java 1.6 override semantics, but we must support 1.5)
 
159
  public boolean hasOneof(final OneofDescriptor oneof) {
 
160
    return internalGetFieldAccessorTable().getOneof(oneof).has(this);
 
161
  }
 
162
 
 
163
  //@Override (Java 1.6 override semantics, but we must support 1.5)
 
164
  public FieldDescriptor getOneofFieldDescriptor(final OneofDescriptor oneof) {
 
165
    return internalGetFieldAccessorTable().getOneof(oneof).get(this);
 
166
  }
 
167
 
 
168
  //@Override (Java 1.6 override semantics, but we must support 1.5)
157
169
  public boolean hasField(final FieldDescriptor field) {
158
170
    return internalGetFieldAccessorTable().getField(field).has(this);
159
171
  }
193
205
    return unknownFields.mergeFieldFrom(tag, input);
194
206
  }
195
207
 
 
208
 
196
209
  /**
197
210
   * Used by parsing constructors in generated classes.
198
211
   */
345
358
    }
346
359
 
347
360
    //@Override (Java 1.6 override semantics, but we must support 1.5)
 
361
    public boolean hasOneof(final OneofDescriptor oneof) {
 
362
      return internalGetFieldAccessorTable().getOneof(oneof).has(this);
 
363
    }
 
364
 
 
365
    //@Override (Java 1.6 override semantics, but we must support 1.5)
 
366
    public FieldDescriptor getOneofFieldDescriptor(final OneofDescriptor oneof) {
 
367
      return internalGetFieldAccessorTable().getOneof(oneof).get(this);
 
368
    }
 
369
 
 
370
    //@Override (Java 1.6 override semantics, but we must support 1.5)
348
371
    public boolean hasField(final FieldDescriptor field) {
349
372
      return internalGetFieldAccessorTable().getField(field).has(this);
350
373
    }
374
397
    }
375
398
 
376
399
    //@Override (Java 1.6 override semantics, but we must support 1.5)
 
400
    public BuilderType clearOneof(final OneofDescriptor oneof) {
 
401
      internalGetFieldAccessorTable().getOneof(oneof).clear(this);
 
402
      return (BuilderType) this;
 
403
    }
 
404
 
 
405
    //@Override (Java 1.6 override semantics, but we must support 1.5)
377
406
    public int getRepeatedFieldCount(final FieldDescriptor field) {
378
407
      return internalGetFieldAccessorTable().getField(field)
379
408
          .getRepeatedCount(this);
507
536
 
508
537
  public interface ExtendableMessageOrBuilder<
509
538
      MessageType extends ExtendableMessage> extends MessageOrBuilder {
 
539
    // Re-define for return type covariance.
 
540
    Message getDefaultInstanceForType();
510
541
 
511
542
    /** Check if a singular extension is present. */
512
543
    <Type> boolean hasExtension(
513
 
        GeneratedExtension<MessageType, Type> extension);
 
544
        Extension<MessageType, Type> extension);
514
545
 
515
546
    /** Get the number of elements in a repeated extension. */
516
547
    <Type> int getExtensionCount(
517
 
        GeneratedExtension<MessageType, List<Type>> extension);
 
548
        Extension<MessageType, List<Type>> extension);
518
549
 
519
550
    /** Get the value of an extension. */
520
 
    <Type> Type getExtension(GeneratedExtension<MessageType, Type> extension);
 
551
    <Type> Type getExtension(
 
552
        Extension<MessageType, Type> extension);
521
553
 
522
554
    /** Get one element of a repeated extension. */
523
555
    <Type> Type getExtension(
524
 
        GeneratedExtension<MessageType, List<Type>> extension,
 
556
        Extension<MessageType, List<Type>> extension,
525
557
        int index);
526
558
  }
527
559
 
578
610
    }
579
611
 
580
612
    private void verifyExtensionContainingType(
581
 
        final GeneratedExtension<MessageType, ?> extension) {
 
613
        final Extension<MessageType, ?> extension) {
582
614
      if (extension.getDescriptor().getContainingType() !=
583
615
          getDescriptorForType()) {
584
616
        // This can only happen if someone uses unchecked operations.
593
625
    /** Check if a singular extension is present. */
594
626
    //@Override (Java 1.6 override semantics, but we must support 1.5)
595
627
    public final <Type> boolean hasExtension(
596
 
        final GeneratedExtension<MessageType, Type> extension) {
 
628
        final Extension<MessageType, Type> extension) {
597
629
      verifyExtensionContainingType(extension);
598
630
      return extensions.hasField(extension.getDescriptor());
599
631
    }
601
633
    /** Get the number of elements in a repeated extension. */
602
634
    //@Override (Java 1.6 override semantics, but we must support 1.5)
603
635
    public final <Type> int getExtensionCount(
604
 
        final GeneratedExtension<MessageType, List<Type>> extension) {
 
636
        final Extension<MessageType, List<Type>> extension) {
605
637
      verifyExtensionContainingType(extension);
606
638
      final FieldDescriptor descriptor = extension.getDescriptor();
607
639
      return extensions.getRepeatedFieldCount(descriptor);
611
643
    //@Override (Java 1.6 override semantics, but we must support 1.5)
612
644
    @SuppressWarnings("unchecked")
613
645
    public final <Type> Type getExtension(
614
 
        final GeneratedExtension<MessageType, Type> extension) {
 
646
        final Extension<MessageType, Type> extension) {
615
647
      verifyExtensionContainingType(extension);
616
648
      FieldDescriptor descriptor = extension.getDescriptor();
617
649
      final Object value = extensions.getField(descriptor);
634
666
    //@Override (Java 1.6 override semantics, but we must support 1.5)
635
667
    @SuppressWarnings("unchecked")
636
668
    public final <Type> Type getExtension(
637
 
        final GeneratedExtension<MessageType, List<Type>> extension,
 
669
        final Extension<MessageType, List<Type>> extension,
638
670
        final int index) {
639
671
      verifyExtensionContainingType(extension);
640
672
      FieldDescriptor descriptor = extension.getDescriptor();
658
690
        UnknownFieldSet.Builder unknownFields,
659
691
        ExtensionRegistryLite extensionRegistry,
660
692
        int tag) throws IOException {
661
 
      return AbstractMessage.Builder.mergeFieldFrom(
662
 
        input, unknownFields, extensionRegistry, getDescriptorForType(),
663
 
        null, extensions, tag);
 
693
      return MessageReflection.mergeFieldFrom(
 
694
          input, unknownFields, extensionRegistry, getDescriptorForType(),
 
695
          new MessageReflection.ExtensionAdapter(extensions), tag);
664
696
    }
665
697
 
 
698
 
666
699
    /**
667
700
     * Used by parsing constructors in generated classes.
668
701
     */
868
901
      super(parent);
869
902
    }
870
903
 
 
904
    // For immutable message conversion.
 
905
    void internalSetExtensionSet(FieldSet<FieldDescriptor> extensions) {
 
906
      this.extensions = extensions;
 
907
    }
 
908
 
871
909
    @Override
872
910
    public BuilderType clear() {
873
911
      extensions = FieldSet.emptySet();
890
928
    }
891
929
 
892
930
    private void verifyExtensionContainingType(
893
 
        final GeneratedExtension<MessageType, ?> extension) {
 
931
        final Extension<MessageType, ?> extension) {
894
932
      if (extension.getDescriptor().getContainingType() !=
895
933
          getDescriptorForType()) {
896
934
        // This can only happen if someone uses unchecked operations.
905
943
    /** Check if a singular extension is present. */
906
944
    //@Override (Java 1.6 override semantics, but we must support 1.5)
907
945
    public final <Type> boolean hasExtension(
908
 
        final GeneratedExtension<MessageType, Type> extension) {
 
946
        final Extension<MessageType, Type> extension) {
909
947
      verifyExtensionContainingType(extension);
910
948
      return extensions.hasField(extension.getDescriptor());
911
949
    }
913
951
    /** Get the number of elements in a repeated extension. */
914
952
    //@Override (Java 1.6 override semantics, but we must support 1.5)
915
953
    public final <Type> int getExtensionCount(
916
 
        final GeneratedExtension<MessageType, List<Type>> extension) {
 
954
        final Extension<MessageType, List<Type>> extension) {
917
955
      verifyExtensionContainingType(extension);
918
956
      final FieldDescriptor descriptor = extension.getDescriptor();
919
957
      return extensions.getRepeatedFieldCount(descriptor);
922
960
    /** Get the value of an extension. */
923
961
    //@Override (Java 1.6 override semantics, but we must support 1.5)
924
962
    public final <Type> Type getExtension(
925
 
        final GeneratedExtension<MessageType, Type> extension) {
 
963
        final Extension<MessageType, Type> extension) {
926
964
      verifyExtensionContainingType(extension);
927
965
      FieldDescriptor descriptor = extension.getDescriptor();
928
966
      final Object value = extensions.getField(descriptor);
944
982
    /** Get one element of a repeated extension. */
945
983
    //@Override (Java 1.6 override semantics, but we must support 1.5)
946
984
    public final <Type> Type getExtension(
947
 
        final GeneratedExtension<MessageType, List<Type>> extension,
 
985
        final Extension<MessageType, List<Type>> extension,
948
986
        final int index) {
949
987
      verifyExtensionContainingType(extension);
950
988
      FieldDescriptor descriptor = extension.getDescriptor();
954
992
 
955
993
    /** Set the value of an extension. */
956
994
    public final <Type> BuilderType setExtension(
957
 
        final GeneratedExtension<MessageType, Type> extension,
 
995
        final Extension<MessageType, Type> extension,
958
996
        final Type value) {
959
997
      verifyExtensionContainingType(extension);
960
998
      ensureExtensionsIsMutable();
966
1004
 
967
1005
    /** Set the value of one element of a repeated extension. */
968
1006
    public final <Type> BuilderType setExtension(
969
 
        final GeneratedExtension<MessageType, List<Type>> extension,
 
1007
        final Extension<MessageType, List<Type>> extension,
970
1008
        final int index, final Type value) {
971
1009
      verifyExtensionContainingType(extension);
972
1010
      ensureExtensionsIsMutable();
980
1018
 
981
1019
    /** Append a value to a repeated extension. */
982
1020
    public final <Type> BuilderType addExtension(
983
 
        final GeneratedExtension<MessageType, List<Type>> extension,
 
1021
        final Extension<MessageType, List<Type>> extension,
984
1022
        final Type value) {
985
1023
      verifyExtensionContainingType(extension);
986
1024
      ensureExtensionsIsMutable();
993
1031
 
994
1032
    /** Clear an extension. */
995
1033
    public final <Type> BuilderType clearExtension(
996
 
        final GeneratedExtension<MessageType, ?> extension) {
 
1034
        final Extension<MessageType, ?> extension) {
997
1035
      verifyExtensionContainingType(extension);
998
1036
      ensureExtensionsIsMutable();
999
1037
      extensions.clearField(extension.getDescriptor());
1030
1068
        final UnknownFieldSet.Builder unknownFields,
1031
1069
        final ExtensionRegistryLite extensionRegistry,
1032
1070
        final int tag) throws IOException {
1033
 
      return AbstractMessage.Builder.mergeFieldFrom(
1034
 
        input, unknownFields, extensionRegistry, getDescriptorForType(),
1035
 
        this, null, tag);
 
1071
      return MessageReflection.mergeFieldFrom(
 
1072
          input, unknownFields, extensionRegistry, getDescriptorForType(),
 
1073
          new MessageReflection.BuilderAdapter(this), tag);
1036
1074
    }
1037
1075
 
1038
1076
    // ---------------------------------------------------------------
1172
1210
   * Gets the descriptor for an extension. The implementation depends on whether
1173
1211
   * the extension is scoped in the top level of a file or scoped in a Message.
1174
1212
   */
1175
 
  private static interface ExtensionDescriptorRetriever {
 
1213
  static interface ExtensionDescriptorRetriever {
1176
1214
    FieldDescriptor getDescriptor();
1177
1215
  }
1178
1216
 
1187
1225
    // the outer class's descriptor, from which the extension descriptor is
1188
1226
    // obtained.
1189
1227
    return new GeneratedExtension<ContainingType, Type>(
1190
 
        new ExtensionDescriptorRetriever() {
 
1228
        new CachedDescriptorRetriever() {
1191
1229
          //@Override (Java 1.6 override semantics, but we must support 1.5)
1192
 
          public FieldDescriptor getDescriptor() {
 
1230
          public FieldDescriptor loadDescriptor() {
1193
1231
            return scope.getDescriptorForType().getExtensions()
1194
1232
                .get(descriptorIndex);
1195
1233
          }
1196
1234
        },
1197
1235
        singularType,
1198
 
        defaultInstance);
 
1236
        defaultInstance,
 
1237
        Extension.ExtensionType.IMMUTABLE);
1199
1238
  }
1200
1239
 
1201
1240
  /** For use by generated code only. */
1209
1248
    return new GeneratedExtension<ContainingType, Type>(
1210
1249
        null,  // ExtensionDescriptorRetriever is initialized in internalInit();
1211
1250
        singularType,
1212
 
        defaultInstance);
 
1251
        defaultInstance,
 
1252
        Extension.ExtensionType.IMMUTABLE);
 
1253
  }
 
1254
 
 
1255
  private abstract static class CachedDescriptorRetriever
 
1256
      implements ExtensionDescriptorRetriever {
 
1257
    private volatile FieldDescriptor descriptor;
 
1258
    protected abstract FieldDescriptor loadDescriptor();
 
1259
    
 
1260
    public FieldDescriptor getDescriptor() {
 
1261
      if (descriptor == null) {
 
1262
        synchronized (this) {
 
1263
          if (descriptor == null) {
 
1264
            descriptor = loadDescriptor();
 
1265
          }
 
1266
        }
 
1267
      }
 
1268
      return descriptor;
 
1269
    }
 
1270
  }
 
1271
 
 
1272
  /**
 
1273
   * Used in proto1 generated code only.
 
1274
   *
 
1275
   * After enabling bridge, we can define proto2 extensions (the extended type
 
1276
   * is a proto2 mutable message) in a proto1 .proto file. For these extensions
 
1277
   * we should generate proto2 GeneratedExtensions.
 
1278
   */
 
1279
  public static <ContainingType extends Message, Type>
 
1280
      GeneratedExtension<ContainingType, Type>
 
1281
      newMessageScopedGeneratedExtension(
 
1282
          final Message scope, final String name,
 
1283
          final Class singularType, final Message defaultInstance) {
 
1284
    // For extensions scoped within a Message, we use the Message to resolve
 
1285
    // the outer class's descriptor, from which the extension descriptor is
 
1286
    // obtained.
 
1287
    return new GeneratedExtension<ContainingType, Type>(
 
1288
        new CachedDescriptorRetriever() {
 
1289
          protected FieldDescriptor loadDescriptor() {
 
1290
            return scope.getDescriptorForType().findFieldByName(name);
 
1291
          }
 
1292
        },
 
1293
        singularType,
 
1294
        defaultInstance,
 
1295
        Extension.ExtensionType.MUTABLE);
 
1296
  }
 
1297
 
 
1298
  /**
 
1299
   * Used in proto1 generated code only.
 
1300
   *
 
1301
   * After enabling bridge, we can define proto2 extensions (the extended type
 
1302
   * is a proto2 mutable message) in a proto1 .proto file. For these extensions
 
1303
   * we should generate proto2 GeneratedExtensions.
 
1304
   */
 
1305
  public static <ContainingType extends Message, Type>
 
1306
     GeneratedExtension<ContainingType, Type>
 
1307
     newFileScopedGeneratedExtension(
 
1308
         final Class singularType, final Message defaultInstance,
 
1309
         final String descriptorOuterClass, final String extensionName) {
 
1310
    // For extensions scoped within a file, we load the descriptor outer
 
1311
    // class and rely on it to get the FileDescriptor which then can be
 
1312
    // used to obtain the extension's FieldDescriptor.
 
1313
    return new GeneratedExtension<ContainingType, Type>(
 
1314
        new CachedDescriptorRetriever() {
 
1315
          protected FieldDescriptor loadDescriptor() {
 
1316
            try {
 
1317
              Class clazz =
 
1318
                  singularType.getClassLoader().loadClass(descriptorOuterClass);
 
1319
              FileDescriptor file =
 
1320
                  (FileDescriptor) clazz.getField("descriptor").get(null);
 
1321
              return file.findExtensionByName(extensionName);
 
1322
            } catch (Exception e) {
 
1323
              throw new RuntimeException(
 
1324
                  "Cannot load descriptors: " + descriptorOuterClass +
 
1325
                  " is not a valid descriptor class name", e);
 
1326
            }
 
1327
          }
 
1328
        },
 
1329
        singularType,
 
1330
        defaultInstance,
 
1331
        Extension.ExtensionType.MUTABLE);
1213
1332
  }
1214
1333
 
1215
1334
  /**
1237
1356
   * these static singletons as parameters to the extension accessors defined
1238
1357
   * in {@link ExtendableMessage} and {@link ExtendableBuilder}.
1239
1358
   */
1240
 
  public static final class GeneratedExtension<
1241
 
      ContainingType extends Message, Type> {
 
1359
  public static class GeneratedExtension<
 
1360
      ContainingType extends Message, Type> extends
 
1361
      Extension<ContainingType, Type> {
1242
1362
    // TODO(kenton):  Find ways to avoid using Java reflection within this
1243
1363
    //   class.  Also try to avoid suppressing unchecked warnings.
1244
1364
 
1254
1374
    // In the case of non-nested extensions, we initialize the
1255
1375
    // ExtensionDescriptorRetriever to null and rely on the outer class's static
1256
1376
    // initializer to call internalInit() after the descriptor has been parsed.
1257
 
    private GeneratedExtension(ExtensionDescriptorRetriever descriptorRetriever,
1258
 
                               Class singularType,
1259
 
                               Message messageDefaultInstance) {
 
1377
    GeneratedExtension(ExtensionDescriptorRetriever descriptorRetriever,
 
1378
        Class singularType,
 
1379
        Message messageDefaultInstance,
 
1380
        ExtensionType extensionType) {
1260
1381
      if (Message.class.isAssignableFrom(singularType) &&
1261
1382
          !singularType.isInstance(messageDefaultInstance)) {
1262
1383
        throw new IllegalArgumentException(
1275
1396
        this.enumValueOf = null;
1276
1397
        this.enumGetValueDescriptor = null;
1277
1398
      }
 
1399
      this.extensionType = extensionType;
1278
1400
    }
1279
1401
 
1280
1402
    /** For use by generated code only. */
1295
1417
    private final Message messageDefaultInstance;
1296
1418
    private final Method enumValueOf;
1297
1419
    private final Method enumGetValueDescriptor;
 
1420
    private final ExtensionType extensionType;
1298
1421
 
1299
1422
    public FieldDescriptor getDescriptor() {
1300
1423
      if (descriptorRetriever == null) {
1312
1435
      return messageDefaultInstance;
1313
1436
    }
1314
1437
 
 
1438
    protected ExtensionType getExtensionType() {
 
1439
      return extensionType;
 
1440
    }
 
1441
 
1315
1442
    /**
1316
1443
     * Convert from the type used by the reflection accessors to the type used
1317
1444
     * by native accessors.  E.g., for enums, the reflection accessors use
1318
1445
     * EnumValueDescriptors but the native accessors use the generated enum
1319
1446
     * type.
1320
1447
     */
 
1448
    // @Override
1321
1449
    @SuppressWarnings("unchecked")
1322
 
    private Object fromReflectionType(final Object value) {
 
1450
    protected Object fromReflectionType(final Object value) {
1323
1451
      FieldDescriptor descriptor = getDescriptor();
1324
1452
      if (descriptor.isRepeated()) {
1325
1453
        if (descriptor.getJavaType() == FieldDescriptor.JavaType.MESSAGE ||
1342
1470
     * Like {@link #fromReflectionType(Object)}, but if the type is a repeated
1343
1471
     * type, this converts a single element.
1344
1472
     */
1345
 
    private Object singularFromReflectionType(final Object value) {
 
1473
    // @Override
 
1474
    protected Object singularFromReflectionType(final Object value) {
1346
1475
      FieldDescriptor descriptor = getDescriptor();
1347
1476
      switch (descriptor.getJavaType()) {
1348
1477
        case MESSAGE:
1349
1478
          if (singularType.isInstance(value)) {
1350
1479
            return value;
1351
1480
          } else {
1352
 
            // It seems the copy of the embedded message stored inside the
1353
 
            // extended message is not of the exact type the user was
1354
 
            // expecting.  This can happen if a user defines a
1355
 
            // GeneratedExtension manually and gives it a different type.
1356
 
            // This should not happen in normal use.  But, to be nice, we'll
1357
 
            // copy the message to whatever type the caller was expecting.
1358
1481
            return messageDefaultInstance.newBuilderForType()
1359
 
                           .mergeFrom((Message) value).build();
 
1482
                .mergeFrom((Message) value).build();
1360
1483
          }
1361
1484
        case ENUM:
1362
1485
          return invokeOrDie(enumValueOf, null, (EnumValueDescriptor) value);
1371
1494
     * EnumValueDescriptors but the native accessors use the generated enum
1372
1495
     * type.
1373
1496
     */
 
1497
    // @Override
1374
1498
    @SuppressWarnings("unchecked")
1375
 
    private Object toReflectionType(final Object value) {
 
1499
    protected Object toReflectionType(final Object value) {
1376
1500
      FieldDescriptor descriptor = getDescriptor();
1377
1501
      if (descriptor.isRepeated()) {
1378
1502
        if (descriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) {
1394
1518
     * Like {@link #toReflectionType(Object)}, but if the type is a repeated
1395
1519
     * type, this converts a single element.
1396
1520
     */
1397
 
    private Object singularToReflectionType(final Object value) {
 
1521
    // @Override
 
1522
    protected Object singularToReflectionType(final Object value) {
1398
1523
      FieldDescriptor descriptor = getDescriptor();
1399
1524
      switch (descriptor.getJavaType()) {
1400
1525
        case ENUM:
1403
1528
          return value;
1404
1529
      }
1405
1530
    }
 
1531
 
 
1532
    // @Override
 
1533
    public int getNumber() {
 
1534
      return getDescriptor().getNumber();
 
1535
    }
 
1536
 
 
1537
    // @Override
 
1538
    public WireFormat.FieldType getLiteType() {
 
1539
      return getDescriptor().getLiteType();
 
1540
    }
 
1541
 
 
1542
    // @Override
 
1543
    public boolean isRepeated() {
 
1544
      return getDescriptor().isRepeated();
 
1545
    }
 
1546
 
 
1547
    // @Override
 
1548
    @SuppressWarnings("unchecked")
 
1549
    public Type getDefaultValue() {
 
1550
      if (isRepeated()) {
 
1551
        return (Type) Collections.emptyList();
 
1552
      }
 
1553
      if (getDescriptor().getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
 
1554
        return (Type) messageDefaultInstance;
 
1555
      }
 
1556
      return (Type) singularFromReflectionType(
 
1557
          getDescriptor().getDefaultValue());
 
1558
    }
1406
1559
  }
1407
1560
 
1408
1561
  // =================================================================
1477
1630
      this.descriptor = descriptor;
1478
1631
      this.camelCaseNames = camelCaseNames;
1479
1632
      fields = new FieldAccessor[descriptor.getFields().size()];
 
1633
      oneofs = new OneofAccessor[descriptor.getOneofs().size()];
1480
1634
      initialized = false;
1481
1635
    }
1482
1636
 
1493
1647
      if (initialized) { return this; }
1494
1648
      synchronized (this) {
1495
1649
        if (initialized) { return this; }
1496
 
        for (int i = 0; i < fields.length; i++) {
 
1650
        int fieldsSize = fields.length;
 
1651
        for (int i = 0; i < fieldsSize; i++) {
1497
1652
          FieldDescriptor field = descriptor.getFields().get(i);
 
1653
          String containingOneofCamelCaseName = null;
 
1654
          if (field.getContainingOneof() != null) {
 
1655
            containingOneofCamelCaseName =
 
1656
                camelCaseNames[fieldsSize + field.getContainingOneof().getIndex()];
 
1657
          }
1498
1658
          if (field.isRepeated()) {
1499
1659
            if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
1500
1660
              fields[i] = new RepeatedMessageFieldAccessor(
1509
1669
          } else {
1510
1670
            if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
1511
1671
              fields[i] = new SingularMessageFieldAccessor(
1512
 
                  field, camelCaseNames[i], messageClass, builderClass);
 
1672
                  field, camelCaseNames[i], messageClass, builderClass,
 
1673
                  containingOneofCamelCaseName);
1513
1674
            } else if (field.getJavaType() == FieldDescriptor.JavaType.ENUM) {
1514
1675
              fields[i] = new SingularEnumFieldAccessor(
1515
 
                  field, camelCaseNames[i], messageClass, builderClass);
 
1676
                  field, camelCaseNames[i], messageClass, builderClass,
 
1677
                  containingOneofCamelCaseName);
1516
1678
            } else {
1517
1679
              fields[i] = new SingularFieldAccessor(
1518
 
                  field, camelCaseNames[i], messageClass, builderClass);
 
1680
                  field, camelCaseNames[i], messageClass, builderClass,
 
1681
                  containingOneofCamelCaseName);
1519
1682
            }
1520
1683
          }
1521
1684
        }
 
1685
 
 
1686
        int oneofsSize = oneofs.length;
 
1687
        for (int i = 0; i < oneofsSize; i++) {
 
1688
          oneofs[i] = new OneofAccessor(
 
1689
              descriptor, camelCaseNames[i + fieldsSize],
 
1690
              messageClass, builderClass);
 
1691
        }
1522
1692
        initialized = true;
1523
1693
        camelCaseNames = null;
1524
1694
        return this;
1528
1698
    private final Descriptor descriptor;
1529
1699
    private final FieldAccessor[] fields;
1530
1700
    private String[] camelCaseNames;
 
1701
    private final OneofAccessor[] oneofs;
1531
1702
    private volatile boolean initialized;
1532
1703
 
1533
1704
    /** Get the FieldAccessor for a particular field. */
1544
1715
      return fields[field.getIndex()];
1545
1716
    }
1546
1717
 
 
1718
    /** Get the OneofAccessor for a particular oneof. */
 
1719
    private OneofAccessor getOneof(final OneofDescriptor oneof) {
 
1720
      if (oneof.getContainingType() != descriptor) {
 
1721
        throw new IllegalArgumentException(
 
1722
          "OneofDescriptor does not match message type.");
 
1723
      }
 
1724
      return oneofs[oneof.getIndex()];
 
1725
    }
 
1726
 
1547
1727
    /**
1548
1728
     * Abstract interface that provides access to a single field.  This is
1549
1729
     * implemented differently depending on the field type and cardinality.
1566
1746
      Message.Builder getBuilder(GeneratedMessage.Builder builder);
1567
1747
    }
1568
1748
 
 
1749
    /** OneofAccessor provides access to a single oneof. */
 
1750
    private static class OneofAccessor {
 
1751
      OneofAccessor(
 
1752
          final Descriptor descriptor, final String camelCaseName,
 
1753
          final Class<? extends GeneratedMessage> messageClass,
 
1754
          final Class<? extends Builder> builderClass) {
 
1755
        this.descriptor = descriptor;
 
1756
        caseMethod =
 
1757
            getMethodOrDie(messageClass, "get" + camelCaseName + "Case");
 
1758
        caseMethodBuilder =
 
1759
            getMethodOrDie(builderClass, "get" + camelCaseName + "Case");
 
1760
        clearMethod = getMethodOrDie(builderClass, "clear" + camelCaseName);
 
1761
      }
 
1762
 
 
1763
      private final Descriptor descriptor;
 
1764
      private final Method caseMethod;
 
1765
      private final Method caseMethodBuilder;
 
1766
      private final Method clearMethod;
 
1767
 
 
1768
      public boolean has(final GeneratedMessage message) {
 
1769
        if (((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber() == 0) {
 
1770
          return false;
 
1771
        }
 
1772
        return true;
 
1773
      }
 
1774
 
 
1775
      public boolean has(GeneratedMessage.Builder builder) {
 
1776
        if (((Internal.EnumLite) invokeOrDie(caseMethodBuilder, builder)).getNumber() == 0) {
 
1777
          return false;
 
1778
        }
 
1779
        return true;
 
1780
      }
 
1781
 
 
1782
      public FieldDescriptor get(final GeneratedMessage message) {
 
1783
        int fieldNumber = ((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber();
 
1784
        if (fieldNumber > 0) {
 
1785
          return descriptor.findFieldByNumber(fieldNumber);
 
1786
        }
 
1787
        return null;
 
1788
      }
 
1789
 
 
1790
      public FieldDescriptor get(GeneratedMessage.Builder builder) {
 
1791
        int fieldNumber = ((Internal.EnumLite) invokeOrDie(caseMethodBuilder, builder)).getNumber();
 
1792
        if (fieldNumber > 0) {
 
1793
          return descriptor.findFieldByNumber(fieldNumber);
 
1794
        }
 
1795
        return null;
 
1796
      }
 
1797
 
 
1798
      public void clear(final Builder builder) {
 
1799
        invokeOrDie(clearMethod, builder);
 
1800
      }
 
1801
    }
 
1802
    
 
1803
    private static boolean supportFieldPresence(FileDescriptor file) {
 
1804
      return true;
 
1805
    }
 
1806
 
1569
1807
    // ---------------------------------------------------------------
1570
1808
 
1571
1809
    private static class SingularFieldAccessor implements FieldAccessor {
1572
1810
      SingularFieldAccessor(
1573
1811
          final FieldDescriptor descriptor, final String camelCaseName,
1574
1812
          final Class<? extends GeneratedMessage> messageClass,
1575
 
          final Class<? extends Builder> builderClass) {
 
1813
          final Class<? extends Builder> builderClass,
 
1814
          final String containingOneofCamelCaseName) {
 
1815
        field = descriptor;
 
1816
        isOneofField = descriptor.getContainingOneof() != null;
 
1817
        hasHasMethod = supportFieldPresence(descriptor.getFile())
 
1818
            || (!isOneofField && descriptor.getJavaType() == FieldDescriptor.JavaType.MESSAGE);
1576
1819
        getMethod = getMethodOrDie(messageClass, "get" + camelCaseName);
1577
1820
        getMethodBuilder = getMethodOrDie(builderClass, "get" + camelCaseName);
1578
1821
        type = getMethod.getReturnType();
1579
1822
        setMethod = getMethodOrDie(builderClass, "set" + camelCaseName, type);
1580
1823
        hasMethod =
1581
 
            getMethodOrDie(messageClass, "has" + camelCaseName);
 
1824
            hasHasMethod ? getMethodOrDie(messageClass, "has" + camelCaseName) : null;
1582
1825
        hasMethodBuilder =
1583
 
            getMethodOrDie(builderClass, "has" + camelCaseName);
 
1826
            hasHasMethod ? getMethodOrDie(builderClass, "has" + camelCaseName) : null;
1584
1827
        clearMethod = getMethodOrDie(builderClass, "clear" + camelCaseName);
 
1828
        caseMethod = isOneofField ? getMethodOrDie(
 
1829
            messageClass, "get" + containingOneofCamelCaseName + "Case") : null;
 
1830
        caseMethodBuilder = isOneofField ? getMethodOrDie(
 
1831
            builderClass, "get" + containingOneofCamelCaseName + "Case") : null;
1585
1832
      }
1586
1833
 
1587
1834
      // Note:  We use Java reflection to call public methods rather than
1594
1841
      protected final Method hasMethod;
1595
1842
      protected final Method hasMethodBuilder;
1596
1843
      protected final Method clearMethod;
 
1844
      protected final Method caseMethod;
 
1845
      protected final Method caseMethodBuilder;
 
1846
      protected final FieldDescriptor field;
 
1847
      protected final boolean isOneofField;
 
1848
      protected final boolean hasHasMethod;
 
1849
      
 
1850
      private int getOneofFieldNumber(final GeneratedMessage message) {
 
1851
        return ((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber();
 
1852
      }
 
1853
      
 
1854
      private int getOneofFieldNumber(final GeneratedMessage.Builder builder) {
 
1855
        return ((Internal.EnumLite) invokeOrDie(caseMethodBuilder, builder)).getNumber();
 
1856
      }
1597
1857
 
1598
1858
      public Object get(final GeneratedMessage message) {
1599
1859
        return invokeOrDie(getMethod, message);
1623
1883
          "addRepeatedField() called on a singular field.");
1624
1884
      }
1625
1885
      public boolean has(final GeneratedMessage message) {
 
1886
        if (!hasHasMethod) {
 
1887
          if (isOneofField) {
 
1888
            return getOneofFieldNumber(message) == field.getNumber();
 
1889
          }
 
1890
          return !get(message).equals(field.getDefaultValue());
 
1891
        }
1626
1892
        return (Boolean) invokeOrDie(hasMethod, message);
1627
1893
      }
1628
1894
      public boolean has(GeneratedMessage.Builder builder) {
 
1895
        if (!hasHasMethod) {
 
1896
          if (isOneofField) {
 
1897
            return getOneofFieldNumber(builder) == field.getNumber();
 
1898
          }
 
1899
          return !get(builder).equals(field.getDefaultValue());
 
1900
        }
1629
1901
        return (Boolean) invokeOrDie(hasMethodBuilder, builder);
1630
1902
      }
1631
1903
      public int getRepeatedCount(final GeneratedMessage message) {
1751
2023
      SingularEnumFieldAccessor(
1752
2024
          final FieldDescriptor descriptor, final String camelCaseName,
1753
2025
          final Class<? extends GeneratedMessage> messageClass,
1754
 
          final Class<? extends Builder> builderClass) {
1755
 
        super(descriptor, camelCaseName, messageClass, builderClass);
 
2026
          final Class<? extends Builder> builderClass,
 
2027
          final String containingOneofCamelCaseName) {
 
2028
        super(descriptor, camelCaseName, messageClass, builderClass, containingOneofCamelCaseName);
1756
2029
 
1757
2030
        valueOfMethod = getMethodOrDie(type, "valueOf",
1758
2031
                                       EnumValueDescriptor.class);
1847
2120
      SingularMessageFieldAccessor(
1848
2121
          final FieldDescriptor descriptor, final String camelCaseName,
1849
2122
          final Class<? extends GeneratedMessage> messageClass,
1850
 
          final Class<? extends Builder> builderClass) {
1851
 
        super(descriptor, camelCaseName, messageClass, builderClass);
 
2123
          final Class<? extends Builder> builderClass,
 
2124
          final String containingOneofCamelCaseName) {
 
2125
        super(descriptor, camelCaseName, messageClass, builderClass, containingOneofCamelCaseName);
1852
2126
 
1853
2127
        newBuilderMethod = getMethodOrDie(type, "newBuilder");
1854
2128
        getBuilderMethodBuilder =