jdk-sandbox: comparison src/jdk.jfr/share/classes/jdk/jfr/consumer/RecordedObject.java

equal deleted inserted replaced

-:df39f8d8f4d6
+:bcbc53560c77
 return o;
 }
 }
 final Object[] objects;
-protected final List<ValueDescriptor> descriptors;
+final ObjectContext objectContext;
-protected final TimeConverter timeConverter;
 // package private, not to be subclassed outside this package
-RecordedObject(List<ValueDescriptor> descriptors, Object[] objects, TimeConverter timeConverter) {
+RecordedObject(ObjectContext objectContext, Object[] objects) {
-this.descriptors = descriptors;
+this.objectContext = objectContext;
 this.objects = objects;
-this.timeConverter = timeConverter;
 }
 // package private
 final <T> T getTyped(String name, Class<T> clazz, T defaultValue) {
 // Unnecessary to check field presence twice, but this
 *
 * @see #getFields()
 */
 public boolean hasField(String name) {
 Objects.requireNonNull(name);
-for (ValueDescriptor v : descriptors) {
+for (ValueDescriptor v : objectContext.fields) {
 if (v.getName().equals(name)) {
 return true;
 }
 }
 int dotIndex = name.indexOf(".");
 if (dotIndex > 0) {
 String structName = name.substring(0, dotIndex);
-for (ValueDescriptor v : descriptors) {
+for (ValueDescriptor v : objectContext.fields) {
 if (!v.getFields().isEmpty() && v.getName().equals(structName)) {
 RecordedObject child = getValue(structName);
 if (child != null) {
 return child.hasField(name.substring(dotIndex + 1));
 }
 }
 private Object getValue(String name, boolean allowUnsigned) {
 Objects.requireNonNull(name);
 int index = 0;
-for (ValueDescriptor v : descriptors) {
+for (ValueDescriptor v : objectContext.fields) {
 if (name.equals(v.getName())) {
 Object object = objectAt(index);
 if (object == null) {
 // error or missing
 return null;
 if (v.isArray()) {
 // struct array
 return structifyArray(v, array, 0);
 }
 // struct
-return new RecordedObject(v.getFields(), (Object[]) object, timeConverter);
+return new RecordedObject(objectContext.getInstance(v), (Object[]) object);
 }
 }
 index++;
 }
 int dotIndex = name.indexOf(".");
 if (dotIndex > 0) {
 String structName = name.substring(0, dotIndex);
-for (ValueDescriptor v : descriptors) {
+for (ValueDescriptor v : objectContext.fields) {
 if (!v.getFields().isEmpty() && v.getName().equals(structName)) {
 RecordedObject child = getValue(structName);
 String subName = name.substring(dotIndex + 1);
 if (child != null) {
 return child.getValue(subName, allowUnsigned);
 // This is to prevent a call to getString on a thread field, that is
 // null to succeed.
 private <T> T getTypedValue(String name, String typeName) {
 Objects.requireNonNull(name);
 // Validate name and type first
-getValueDescriptor(descriptors, name, typeName);
+getValueDescriptor(objectContext.fields, name, typeName);
 return getValue(name);
 }
 private Object[] structifyArray(ValueDescriptor v, Object[] array, int dimension) {
 if (array == null) {
 return null;
 }
 Object[] structArray = new Object[array.length];
+ObjectContext objContext = objectContext.getInstance(v);
 for (int i = 0; i < structArray.length; i++) {
 Object arrayElement = array[i];
 if (dimension == 0) {
 // No general way to handle structarrays
 // without invoking ObjectFactory for every instance (which may require id)
 if (isStackFrameType(v.getTypeName())) {
-structArray[i] = new RecordedFrame(v.getFields(), (Object[]) arrayElement, timeConverter);
+structArray[i] = new RecordedFrame(objContext, (Object[]) arrayElement);
 } else {
-structArray[i] = new RecordedObject(v.getFields(), (Object[]) arrayElement, timeConverter);
+structArray[i] = new RecordedObject(objContext, (Object[]) arrayElement);
 }
 } else {
 structArray[i] = structifyArray(v, (Object[]) arrayElement, dimension - 1);
 }
 }
 * Returns an immutable list of the fields for this object.
 *
 * @return the fields, not {@code null}
 */
 public List<ValueDescriptor> getFields() {
-return descriptors;
+return objectContext.fields;
 }
 /**
 * Returns the value of a field of type {@code boolean}.
 * <p>
 }
 throw newIllegalArgumentException(name, "java,time.Duration");
 }
 private Duration getDuration(long timespan, String name) throws InternalError {
-ValueDescriptor v = getValueDescriptor(descriptors, name, null);
+ValueDescriptor v = getValueDescriptor(objectContext.fields, name, null);
 if (timespan == Long.MIN_VALUE) {
 return Duration.ofSeconds(Long.MIN_VALUE, 0);
 }
 Timespan ts = v.getAnnotation(Timespan.class);
 if (ts != null) {
 case Timespan.MILLISECONDS:
 return Duration.ofMillis(timespan);
 case Timespan.NANOSECONDS:
 return Duration.ofNanos(timespan);
 case Timespan.TICKS:
-return Duration.ofNanos(timeConverter.convertTimespan(timespan));
+return Duration.ofNanos(objectContext.timeConverter.convertTimespan(timespan));
 }
 throw new IllegalArgumentException("Attempt to get " + v.getTypeName() + " field \"" + name + "\" with illegal timespan unit " + ts.value());
 }
 throw new IllegalArgumentException("Attempt to get " + v.getTypeName() + " field \"" + name + "\" with missing @Timespan");
 }
 }
 throw newIllegalArgumentException(name, "java.time.Instant");
 }
 private Instant getInstant(long timestamp, String name) {
-ValueDescriptor v = getValueDescriptor(descriptors, name, null);
+ValueDescriptor v = getValueDescriptor(objectContext.fields, name, null);
 Timestamp ts = v.getAnnotation(Timestamp.class);
 if (ts != null) {
 if (timestamp == Long.MIN_VALUE) {
 return Instant.MIN;
 }
 switch (ts.value()) {
 case Timestamp.MILLISECONDS_SINCE_EPOCH:
 return Instant.ofEpochMilli(timestamp);
 case Timestamp.TICKS:
-return Instant.ofEpochSecond(0, timeConverter.convertTimestamp(timestamp));
+return Instant.ofEpochSecond(0, objectContext.timeConverter.convertTimestamp(timestamp));
 }
 throw new IllegalArgumentException("Attempt to get " + v.getTypeName() + " field \"" + name + "\" with illegal timestamp unit " + ts.value());
 }
 throw new IllegalArgumentException("Attempt to get " + v.getTypeName() + " field \"" + name + "\" with missing @Timestamp");
 }
 OffsetDateTime getOffsetDateTime(String name) {
 Instant instant = getInstant(name);
 if (instant.equals(Instant.MIN)) {
 return OffsetDateTime.MIN;
 }
-return OffsetDateTime.ofInstant(getInstant(name), timeConverter.getZoneOffset());
+return OffsetDateTime.ofInstant(getInstant(name), objectContext.timeConverter.getZoneOffset());
 }
 private static IllegalArgumentException newIllegalArgumentException(String name, String typeName) {
 return new IllegalArgumentException("Attempt to get field \"" + name + "\" with illegal data type conversion " + typeName);
 }

branch	JEP-349-branch
changeset 57460	bcbc53560c77
parent 57452	6fabe73e5d9a
child 58145	bc54ed8d908a