org.jsimpledb..ReferencePath.swp Maven / Gradle / Ivy
Show all versions of jsimpledb-main Show documentation
b0VIM 7.4 ?zXVg? m| archie retina.dellroad.org ~archie/proj/jsimpledb/jsimpledb/jsimpledb-main/src/main/java/org/jsimpledb/ReferencePath.java utf-8
U3210 #"! U tp
^ _ 1 a ! ? ?
? ( ? ? ? ? F M ad ? ^ ? ? ? ? ? ? ? { N " ? ? ? ? ? ? ? c J * ) % ?
?
?
,
? 9 0 - & ? ) ?
?
?
s
P
M
F
? [ ? ? ? ? ? ? = : 1 ? ? ? ? ? O ? ? ? ? ? ? q n E ? ? ? i ? z 1 ? ? x ? ? ? ? / , ? ? ? ? ? ? final Class startType; public class ReferencePath { */ * @see JSimpleDB#parseReferencePath JSimpleDB.parseReferencePath() * * Reference paths are created via {@link JSimpleDB#parseReferencePath JSimpleDB.parseReferencePath()}. * * * the storage ID may be explicitly specified as a suffix, for example, {@code "name#123"}. * In cases where multiple sub-types of a common super-type type have fields with the same name but different storage IDs, *
* * {@code friendNameChanged()} necessarily has generic type {@code NamedPerson}, not {@code Person}. * {@link org.jsimpledb.change.SimpleFieldChange} parameter to the method * with a field named {@code "name"}. Note also in the example above the * still work as long as there is no ambiguity, i.e., in this example, there are no other sub-types of {@code Person} * has type {@code Person}, and {@code "name"} is a field of {@code NamedPerson}, not {@code Person}. However, this will * Here the path {@code "friends.element.name"} is technically incorrect because {@code "friends.element"} *
* * In some cases, a field may not exist in a Java object type, but it does exist in a some sub-type of that type. For example: ** * Fields of Sub-Types *
* * named {@code "element"}, while for map fields the sub-fields are named {@code "key"} and {@code "value"}. * being traversed should appear, e.g., {@code "mymap.key.somefield"}. For set and list fields, the (only) sub-field is * When a complex field appears in a reference path, both the name of the complex field and the specific sub-field *
* * the parent of a {@code Person}. * For example, path {@code "parent.age"} starting from object type {@code Person} might refer to the age of *
* * All of the fields except the last must be reference fields. * fields and final target field in a {@link String} form consisting of field names separated by period ({@code "."}) characters. * Reference paths can be described by the combination of (a) the starting Java object type, and (b) the path of reference *
* * * instance of the target type can be reached from an instance of the starting type. *
- * A Reference path consists of: *
* * Reference paths. /** import org.slf4j.LoggerFactory; import org.slf4j.Logger; import org.jsimpledb.util.CastFunction; import java.util.Map; import java.util.HashMap; import java.util.ArrayList; import java.util.ArrayDeque; import com.google.common.reflect.TypeToken; import com.google.common.collect.Iterables; import com.google.common.base.Preconditions; import com.google.common.base.Function; package org.jsimpledb; */ * Copyright (C) 2015 Archie L. Cobbs. All rights reserved. /* ad ? - F ? ? ? ? ? ? ~ ] W V N ? ? ? | 9 3 2 * ? ? ? d ] ? ? ? ? ? 3 ? ? ^ V / ? ? ? ? ? | q " ? 2 + ? ? ? x D ? ? ? ? ? ? } o P 6 0 . - ' ? ? ? ? ? > 1 0 * ? ? ? d c 7 } } } return jclass.type; } } } } return jclass.type; public Class apply(JClass } } } } } } return jclass.type; } } } r } } } } } } } } return jfield.typeToken; public TypeToken apply(JReferenceField } } } } } } return jfield.typeToken; } } } return } } } } } return this.path; public String toString() { @Override */ * Get the {@link String} form of the path associated with this instance. /** } return storageIds; storageIds[i] = this.referenceFieldInfos.get(i).storageId; for (int i = 0; i < storageIds.length; i++) final int[] storageIds = new int[this.referenceFieldInfos.size()]; public int[] getReferenceFields() { */ * @return zero or more reference field storage IDs * * the last field is field in some object type that refers to the {@linkplain #getTargetType target object type}. * Otherwise, the first field is a field in the {@linkplain #getStartType starting object type} and *
* * The path may be empty, i.e., zero references are traversed in the path. *
* * Get the storage IDs of the reference fields in this path. /** } return this.targetSuperFieldInfo != null ? this.targetSuperFieldInfo.storageId : 0; public int getTargetSuperField() { */ * @return target field's complex super-field storage ID, or zero if the target field is not a complex sub-field * * a sub-field, in the case that the target field is a sub-field of a complex field. * Get the storage ID associated with the complex field containing the {@linkplain #getTargetField target field} /** } return this.targetFieldInfo.storageId; public int getTargetField() { */ * @return the storage ID of the field at which this reference path ends * * This is just the storage ID of the last field in the path. *
* * Get the storage ID associated with the target field in the {@linkplain #getTargetType target object type}. /** } return this.targetFieldInfo.getTypeToken(this.targetType); public TypeToken getTargetFieldType() { */ * @return the type of the field at which this reference path ends * * Get the Java type corresponding to the field at which this path ends. /** } return this.targetTypes; public Set ad ?
? h @ ? ? 8 ` I ?
?
|
P
? ? G 9 ? ? g ?
?
?
?
8
7
? ? @ ? ? e d M " ? ? w T ? ? ? u 1 ? x b G 5 ? ? > ( ? ? & ? ? ? U G F ] } this.log.debug("RefPath: [" + searchName + "." + subFieldName + "] new matching fields=" + matchingFields); if (this.log.isDebugEnabled()) // Logging entry.setValue(((JComplexField)entry.getValue()).getSubField(subFieldName)); for (Map.Entry * * Get the Java type of the object at which this path ends. /** } return this.startType; public Class getStartType() { */ * @return the Java type at which this reference path starts * * field exists only in a sub-type. * equal the {@linkplain #getTargetType target object type}, or possibly a super-type if the target * If there are zero {@linkplain #getReferenceFields reference fields} in this path, then this will * * * Get the Java type of the object at which this path starts. /** } } + " targetFieldType=" + this.getTargetFieldType() + " references=" + this.referenceFieldInfos); + " targetFieldInfo=" + this.targetFieldInfo + " targetSuperFieldInfo=" + this.targetSuperFieldInfo this.log.debug("RefPath: DONE: targetTypes=" + this.targetTypes + " targetType=" + this.targetType if (this.log.isDebugEnabled()) { // Logging this.targetSuperFieldInfo = superFieldInfo; this.targetFieldInfo = fieldInfo; this.targetType = Util.findLowestCommonAncestorOfClasses(this.targetTypes).getRawType(); this.targetTypes = Collections.unmodifiableSet(currentTypes); // Done } this.log.debug("RefPath: step through reference, new currentTypes=" + currentTypes); if (this.log.isDebugEnabled()) // Logging currentTypes.add(((JReferenceField)jfield).typeToken.getRawType(); for (JField jfield : matchingFields.values()) currentTypes.clear(); // Advance through the reference this.referenceFieldInfos.add(referenceFieldInfo); // Add reference field to the reference field list final JReferenceFieldInfo referenceFieldInfo = (JReferenceFieldInfo)fieldInfo; throw new IllegalArgumentException(errorPrefix + description + " is not a reference field"); if (!(fieldInfo instanceof JReferenceFieldInfo)) // Field is not last, so it must be a reference field } break; } + "; specify the complex field itself instead"); throw new IllegalArgumentException(errorPrefix + "path may not end on " + description if (superFieldInfo != null && Boolean.FALSE.equals(lastIsSubField)) { if (fieldNames.isEmpty()) { // Last field? ad ?
?
? ? ? ? l f e ] ? " ?
?
?
d
* * if the target field exis * * if the target field exi * * if the target field exists only in a sub-type. * return only the Java typ * * if the target field exists only in a sub-type. * return only the Java type of the {@linkplain #getStartType starting object type}, or possibly a sub-type * If there are zero {@linkplain #getReferenceFields reference fields} in this path, then this method will * * * Get the possible Java types of the object at which this path ends. /** } return this.targetType; public Class getTargetType() { */ * @return the Java type at which this reference path ends * ad x X 1 ? ? V ? > ? ? ? ? ? } E ?
c
D
? ? ? : 9 ! ? ? Y ?
?
?
h
g
<
? ? ? ? o ? ? ? ? O ? ? ? ? ? X J ? ? Y O N 1 ? ? O N ? ? ? ? j ? m [
? ? ? ? " ! ? m final HashMap