overrides = multipleOverrides.value();
/** * @param mergeWithAnnotations Whether to use Java annotations for this * element, if present and not disabled by the XMLContext defaults. * In some contexts (such as an association mapping) merging with * annotations is never allowed. */ private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List<AttributeOverride> attributes, boolean mergeWithAnnotations) { if ( mergeWithAnnotations && defaults.canUseJavaAnnotations() ) { AttributeOverride annotation = getPhysicalAnnotation( AttributeOverride.class ); addAttributeOverrideIfNeeded( annotation, attributes ); AttributeOverrides annotations = getPhysicalAnnotation( AttributeOverrides.class ); if ( annotations != null ) { for ( AttributeOverride current : annotations.value() ) { addAttributeOverrideIfNeeded( current, attributes ); } } } if ( attributes.size() > 0 ) { AnnotationDescriptor ad = new AnnotationDescriptor( AttributeOverrides.class ); ad.setValue( "value", attributes.toArray( new AttributeOverride[attributes.size()] ) ); return AnnotationFactory.create( ad ); } else { return null; } }
private boolean mappingDefinedAttributeOverrideOnMapKey(XProperty property) { if ( property.isAnnotationPresent( AttributeOverride.class ) ) { return namedMapKey( property.getAnnotation( AttributeOverride.class ) ); } if ( property.isAnnotationPresent( AttributeOverrides.class ) ) { final AttributeOverrides annotations = property.getAnnotation( AttributeOverrides.class ); for ( AttributeOverride attributeOverride : annotations.value() ) { if ( namedMapKey( attributeOverride ) ) { return true; } } } return false; }
public static final AttributeOverride[] getAttributeOverrides(AnnotatedElement ae) { AttributeOverride[] overrides = null; AttributeOverrides aos = ae.getAnnotation(AttributeOverrides.class); if (aos != null) { overrides = aos.value(); } if (overrides == null || overrides.length == 0) { AttributeOverride override = ae.getAnnotation(AttributeOverride.class); if (override != null) { overrides = new AttributeOverride[1]; overrides[0] = override; } else { overrides = new AttributeOverride[0]; } } return overrides; }
/** * When there's a single attribute override, we still wrap it with an * AttributeOverrides annotation. */ @Test public void testSingleAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm21.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }
/** * Tests that map-key-attribute-override and attribute-override elements * both end up in the AttributeOverrides annotation. */ @Test public void testMixedAttributeOverrides() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm23.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); assertEquals( "field2", overrides[1].name() ); assertEquals( "col2", overrides[1].column().name() ); }
/** * When there's a single map key attribute override, we still wrap it with * an AttributeOverrides annotation. */ @Test public void testSingleMapKeyAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm10.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( MapKey.class ); assertAnnotationNotPresent( MapKeyClass.class ); assertAnnotationNotPresent( MapKeyTemporal.class ); assertAnnotationNotPresent( MapKeyEnumerated.class ); assertAnnotationNotPresent( MapKeyColumn.class ); assertAnnotationNotPresent( MapKeyJoinColumns.class ); assertAnnotationNotPresent( MapKeyJoinColumn.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }
/** * When there's a single map key attribute override, we still wrap it with * an AttributeOverrides annotation. */ @Test public void testSingleMapKeyAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "many-to-many.orm10.xml" ); assertAnnotationPresent( ManyToMany.class ); assertAnnotationNotPresent( MapKey.class ); assertAnnotationNotPresent( MapKeyClass.class ); assertAnnotationNotPresent( MapKeyTemporal.class ); assertAnnotationNotPresent( MapKeyEnumerated.class ); assertAnnotationNotPresent( MapKeyColumn.class ); assertAnnotationNotPresent( MapKeyJoinColumns.class ); assertAnnotationNotPresent( MapKeyJoinColumn.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }
/** * Bind type annotations. */ private void bindTypeAnnotations() { // TODO:: need to check @Embeddable attributes as well! // TODO:: need to Handle association override in // RelationMetadataProcessor. for (Class<? extends Annotation> ann : validJPAAnnotations) { if (getJavaType().isAnnotationPresent(ann)) { checkForValid(); Annotation annotation = getJavaType().getAnnotation(ann); if (ann.isAssignableFrom(AttributeOverride.class)) { bindAttribute(annotation); } else if (ann.isAssignableFrom(AttributeOverrides.class)) { AttributeOverride[] attribAnns = ((AttributeOverrides) annotation).value(); for (AttributeOverride attribOverann : attribAnns) { bindAttribute(attribOverann); } } } } }
private static Map<String, Column[]> buildColumnOverride(XAnnotatedElement element, String path) { Map<String, Column[]> columnOverride = new HashMap<String, Column[]>(); if ( element == null ) return columnOverride; AttributeOverride singleOverride = element.getAnnotation( AttributeOverride.class ); AttributeOverrides multipleOverrides = element.getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides; if ( singleOverride != null ) { overrides = new AttributeOverride[] { singleOverride }; } else if ( multipleOverrides != null ) { overrides = multipleOverrides.value(); } else { overrides = null; } //fill overridden columns if ( overrides != null ) { for (AttributeOverride depAttr : overrides) { columnOverride.put( StringHelper.qualify( path, depAttr.name() ), new Column[] { depAttr.column() } ); } } return columnOverride; }
private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List<AttributeOverride> attributes) { if ( defaults.canUseJavaAnnotations() ) { AttributeOverride annotation = getJavaAnnotation( AttributeOverride.class ); addAttributeOverrideIfNeeded( annotation, attributes ); AttributeOverrides annotations = getJavaAnnotation( AttributeOverrides.class ); if ( annotations != null ) { for (AttributeOverride current : annotations.value()) { addAttributeOverrideIfNeeded( current, attributes ); } } } if ( attributes.size() > 0 ) { AnnotationDescriptor ad = new AnnotationDescriptor( AttributeOverrides.class ); ad.setValue( "value", attributes.toArray( new AttributeOverride[attributes.size()] ) ); return AnnotationFactory.create( ad ); } else { return null; } }
private Optional<Stream<AttributeOverride>> getMappingOverride(AttributeOverrides multiple) { if (multiple == null) { return Optional.empty(); } if (multiple.value().length == 0) { logger.warn("An @AttributeOverrides has no @AttributeOverride elements."); return Optional.empty(); } return Optional.of(Stream.of(multiple.value())); }
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() );
public static final AttributeOverride[] getAttributeOverrides(final AnnotatedElement ae) { AttributeOverride[] overrides = null; final AttributeOverrides aos = ae.getAnnotation(AttributeOverrides.class); if (aos != null) { overrides = aos.value(); } if (overrides == null || overrides.length == 0) { final AttributeOverride override = ae.getAnnotation(AttributeOverride.class); if (override != null) { overrides = new AttributeOverride[1]; overrides[0] = override; } else { overrides = new AttributeOverride[0]; } } return overrides; }
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() );
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() );
private void overrideAttributes(AttributeOverrides overrides, Map<String, FieldEntry> embeddedFields) { AttributeOverride[] overriddenAttributes = overrides.value(); for (AttributeOverride overriddenAttribute : overriddenAttributes) { embeddedFields.put(overriddenAttribute.name(), new FieldEntry(overriddenAttribute.name(), overriddenAttribute.column().name())); } }
private boolean mappingDefinedAttributeOverrideOnMapKey(XProperty property) { if ( property.isAnnotationPresent( AttributeOverride.class ) ) { return namedMapKey( property.getAnnotation( AttributeOverride.class ) ); } if ( property.isAnnotationPresent( AttributeOverrides.class ) ) { final AttributeOverrides annotations = property.getAnnotation( AttributeOverrides.class ); for ( AttributeOverride attributeOverride : annotations.value() ) { if ( namedMapKey( attributeOverride ) ) { return true; } } } return false; }
private String determineDBFieldName(final IntermediateModelElement property, final JPAPath jpaPath) { final Attribute<?, ?> jpaAttribute = jpaManagedType.getAttribute(property.getInternalName()); if (jpaAttribute.getJavaMember() instanceof AnnotatedElement) { final AnnotatedElement a = (AnnotatedElement) jpaAttribute.getJavaMember(); final AttributeOverrides overwriteList = a.getAnnotation(AttributeOverrides.class); if (overwriteList != null) { for (final AttributeOverride overwrite : overwriteList.value()) { if (overwrite.name().equals(jpaPath.getLeaf().getInternalName())) return overwrite.column().name(); } } else { final AttributeOverride overwrite = a.getAnnotation(AttributeOverride.class); if (overwrite != null && overwrite.name().equals(jpaPath.getLeaf().getInternalName())) { return overwrite.column().name(); } } } return jpaPath.getDBFieldName(); }
/** * INTERNAL: (Overridden in XMLClassAccessor) * Process the @AttributeOverrides and @AttributeOverride for an Entity (or * MappedSuperclass) that inherits from a MappedSuperclass. */ protected void processAttributeOverrides() { // Look for an @AttributeOverrides. AttributeOverrides attributeOverrides = getAnnotation(AttributeOverrides.class); if (attributeOverrides != null) { for (AttributeOverride attributeOverride : attributeOverrides.value()) { processAttributeOverride(new MetadataColumn(attributeOverride, getAnnotatedElement())); } } // Look for an @AttributeOverride. AttributeOverride attributeOverride = getAnnotation(AttributeOverride.class); if (attributeOverride != null) { processAttributeOverride(new MetadataColumn(attributeOverride, getAnnotatedElement())); } }