FieldSortKey(JSimpleField jfield) { super((jfield.getParentField() != null ? DefaultFieldFactory.createCaptionByPropertyId(jfield.getParentField().getName()) + "." : "") + DefaultFieldFactory.createCaptionByPropertyId(jfield.getName())); this.storageId = jfield.getStorageId(); this.isSubField = jfield.getParentField() != null; this.fieldName = (this.isSubField ? jfield.getParentField().getName() + "." : "") + jfield.getName(); this.fieldType = jfield.getTypeToken().wrap().getRawType(); }
@Override public NavigableSetConverter<?, ?> getConverter(JTransaction jtx) { final Converter<?, ?> elementConverter = this.elementField.getConverter(jtx); return elementConverter != null ? this.createConverter(elementConverter) : null; }
@Override public JObject getValue(JObject jobj) { return (JObject)super.getValue(jobj); }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public Property<?> caseJSimpleField(JSimpleField jfield) { return new MethodProperty(jfield.getTypeToken().getRawType(), jobj, jfield.getGetter(), jfield.getSetter()); } @Override
final Class<?> propertyType = jfield.getTypeToken().getRawType(); field = new ReferenceFieldField(this.jtx, this.session, jfield.getName(), jfield.getTypeToken().getRawType()); else if (Enum.class.isAssignableFrom(propertyType)) { // use ComboBox for Enum's final EnumComboBox comboBox = this.createEnumComboBox(propertyType.asSubclass(Enum.class)); textField.setNullRepresentation(""); textField.setNullSettingAllowed(false); final FieldType<?> fieldType = jfield.getFieldType(); textField.setConverter(this.buildSimpleFieldConverter(fieldType)); field = textField;
@Override <T> void addChangeParameterTypes(List<TypeToken<?>> types, Class<T> targetType) { this.addChangeParameterTypes(types, targetType, this.keyField.getTypeToken(), this.valueField.getTypeToken()); }
@Override public Integer caseJSimpleField(JSimpleField field1) { if (!(jfield2 instanceof JSimpleField)) return 0; final JSimpleField field2 = (JSimpleField)jfield2; final FieldType<?> fieldType1 = field1.getFieldType(); final FieldType<?> fieldType2 = field2.getFieldType(); if (!fieldType1.equals(fieldType2)) return 0; Object value1 = field1.getValue(jobj1); Object value2 = field2.getValue(jobj2); final Converter<?, ?> converter1 = field1.getConverter(jobj1.getTransaction()); if (converter1 != null) value1 = this.convert(converter1.reverse(), value1); final Converter<?, ?> converter2 = field2.getConverter(jobj2.getTransaction()); if (converter2 != null) value2 = this.convert(converter2.reverse(), value2); return this.compare(fieldType1, value1, value2); }
@Override public Field<?> caseJSimpleField(JSimpleField jfield) { final boolean allowNull = jfield.getGetter().getAnnotation(NotNull.class) == null && !jfield.getTypeToken().isPrimitive(); return new SimpleFieldFieldBuilder(JObjectEditorWindow.this.jobj.getTransaction(), jfield, JObjectEditorWindow.this.session, allowNull).buildField(); } @Override
ComplexSubFieldIndexInfo(JSimpleField jfield) { super(jfield); assert jfield.parent instanceof JComplexField; this.parentStorageId = jfield.getParentField().storageId; }
void initialize(Permazen jdb, SchemaCompositeIndex schemaIndex) { super.initialize(jdb, schemaIndex); for (JSimpleField jfield : this.jfields) schemaIndex.getIndexedFields().add(jfield.getStorageId()); }
@Override <T> void addChangeParameterTypes(List<TypeToken<?>> types, Class<T> targetType) { this.addChangeParameterTypes(types, targetType, this.typeToken); }
enumType != null ? new JEnumField(this.jdb, fieldName, storageId, enumType, annotation, fieldDescription, getter, setter) : new JSimpleField(this.jdb, fieldName, storageId, fieldTypeToken, nonReferenceType, annotation.indexed(), annotation, fieldDescription, getter, setter); } catch (IllegalArgumentException e) {
/** * Constructor. * * @param jtx target transaction used by {@link io.permazen.vaadin.JObjectChooser} * @param jfield the database {@link JSimpleField} for which to build a Vaadin {@link Field} * @param session session used by {@link io.permazen.vaadin.JObjectChooser} * @param allowNull whether null values are allowed */ public SimpleFieldFieldBuilder(JTransaction jtx, JSimpleField jfield, ParseSession session, boolean allowNull) { Preconditions.checkArgument(jtx != null, "null jtx"); Preconditions.checkArgument(jfield != null, "null jfield"); Preconditions.checkArgument(session != null, "null session"); this.jtx = jtx; this.jfield = jfield; this.session = session; this.allowNull = allowNull && !jfield.getTypeToken().isPrimitive(); }
public JComplexField getSuperField() { return this.jfield instanceof JSimpleField ? ((JSimpleField)this.jfield).getParentField() : null; }
abstract <T, E> void addChangeParameterTypes(List<TypeToken<?>> types, Class<T> targetType, TypeToken<E> elementType);
@Override public ListConverter<?, ?> getConverter(JTransaction jtx) { final Converter<?, ?> elementConverter = this.elementField.getConverter(jtx); return elementConverter != null ? this.createConverter(elementConverter) : null; }
@Override SimpleFieldIndexInfo toIndexInfo() { if (!this.indexed) return null; final JComplexField parentField = this.getParentField(); return parentField != null ? parentField.toIndexInfo(this) : new RegularSimpleFieldIndexInfo(this); }
@Override public Component caseJSimpleField(JSimpleField field) { return ObjFieldPropertyDef.this.handleValue(field.getValue(jobj)); }
@Override public TypeToken<?> getTypeToken() { return this.buildTypeToken(this.keyField.getTypeToken().wrap(), this.valueField.getTypeToken().wrap()); }
@Override public NavigableMapConverter<?, ?, ?, ?> getConverter(JTransaction jtx) { Converter<?, ?> keyConverter = this.keyField.getConverter(jtx); Converter<?, ?> valueConverter = this.valueField.getConverter(jtx); if (keyConverter == null && valueConverter == null) return null; if (keyConverter == null) keyConverter = Converter.<Object>identity(); if (valueConverter == null) valueConverter = Converter.<Object>identity(); return this.createConverter(keyConverter, valueConverter); }