Package org.eclipse.persistence.internal.jpa.metadata.accessors.objects

Examples of org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotation


        for (ConverterMetadata converter : m_converters) {
            m_project.addConverter(converter);
        }
       
        // Check for a Converter annotation.
        MetadataAnnotation converter = getAnnotation(Converter.class);
        if (converter != null) {
            m_project.addConverter(new ConverterMetadata(converter, getAccessibleObject()));
        }
    }
View Full Code Here


        for (ObjectTypeConverterMetadata objectTypeConverter : m_objectTypeConverters) {
            m_project.addConverter(objectTypeConverter);
        }
       
        // Check for an ObjectTypeConverter annotation.
        MetadataAnnotation objectTypeConverter = getAnnotation(ObjectTypeConverter.class);
        if (objectTypeConverter != null) {
            m_project.addConverter(new ObjectTypeConverterMetadata(objectTypeConverter, getAccessibleObject()));
        }
    }
View Full Code Here

        for (StructConverterMetadata structConverter : m_structConverters) {
            m_project.addConverter(structConverter);
        }
       
        // Check for a StructConverter annotation.
        MetadataAnnotation converter = getAnnotation(StructConverter.class);
        if (converter != null) {
            m_project.addConverter(new StructConverterMetadata(converter, getAccessibleObject()));
        }
    }
View Full Code Here

        for (TypeConverterMetadata typeConverter : m_typeConverters) {
            m_project.addConverter(typeConverter);
        }
       
        // Check for an TypeConverter annotation.
        MetadataAnnotation typeConverter = getAnnotation(TypeConverter.class);
        if (typeConverter != null) {
            m_project.addConverter(new TypeConverterMetadata(typeConverter, getAccessibleObject()));
        }
    }
View Full Code Here

            // Set the fetch type.
            setFetch((String) annotation.getAttribute("fetch"));
        }
       
        // Set the join fetch if one is present.
        MetadataAnnotation joinFetch = getAnnotation(JoinFetch.class);           
        if (joinFetch != null) {
            m_joinFetch = (String) joinFetch.getAttribute("value");
        }
        // Since BasicCollection and ElementCollection look for different
        // collection tables, we will not initialize/look for one here. Those
        // accessors will be responsible for loading their collection table.
    }
View Full Code Here

        m_fetch = (annotation == null) ? getDefaultFetchType() : (String) annotation.getAttribute("fetch");
        m_targetEntity = getMetadataClass((annotation == null) ? "void" : (String) annotation.getAttributeString("targetEntity"));        
        m_cascadeTypes = (annotation == null) ? null : new CascadeTypes((Object[]) annotation.getAttributeArray("cascade"), accessibleObject);
       
        // Set the join fetch if one is present.          
        MetadataAnnotation joinFetch = getAnnotation(JoinFetch.class);           
        if (joinFetch != null) {
            m_joinFetch = (String) joinFetch.getAttribute("value");
            // If the value is null a value still must be set, otherwise it will not be known to be there.
            if (m_joinFetch == null) {
                m_joinFetch = "";
            }
        }
       
        // Set the private owned if one is present.
        m_privateOwned = isAnnotationPresent(PrivateOwned.class);
       
        // Set the join columns if some are present.
        // Process all the join columns first.
        MetadataAnnotation joinColumns = getAnnotation(JoinColumns.class);
        if (joinColumns != null) {
            for (Object jColumn : (Object[]) joinColumns.getAttributeArray("value")) {
                m_joinColumns.add(new JoinColumnMetadata((MetadataAnnotation)jColumn, accessibleObject));
            }
        }
       
        // Process the single key join column second.
        MetadataAnnotation joinColumn = getAnnotation(JoinColumn.class);
        if (joinColumn != null) {
            m_joinColumns.add(new JoinColumnMetadata(joinColumn, accessibleObject));
        }
       
        // Set the join table if one is present.
View Full Code Here

        if (transformation != null) {
            setFetch((String) transformation.getAttribute("fetch"));
            setOptional((Boolean) transformation.getAttribute("optional"));
        }
       
        MetadataAnnotation readTransformer = getAnnotation(ReadTransformer.class);
        if (readTransformer != null) {
            m_readTransformer = new ReadTransformerMetadata(readTransformer, accessibleObject);
        }
       
        // Set the write transformers if specified.
        m_writeTransformers = new ArrayList<WriteTransformerMetadata>();
        // Process all the write transformers first.
        MetadataAnnotation writeTransformers = getAnnotation(WriteTransformers.class);
        if (writeTransformers != null) {
            for (Object transformer : (Object[]) writeTransformers.getAttributeArray("value")) {
                m_writeTransformers.add(new WriteTransformerMetadata((MetadataAnnotation)transformer, accessibleObject));
            }
        }
       
        // Process the single write transformer second.
        MetadataAnnotation writeTransformer = getAnnotation(WriteTransformer.class);
        if (writeTransformer != null) {
            m_writeTransformers.add(new WriteTransformerMetadata(writeTransformer, accessibleObject));
        }
       
        //TODO: ReturningPolicy
View Full Code Here

     */
    public BasicAccessor(MetadataAnnotation annotation, MetadataAccessibleObject accessibleObject, ClassAccessor classAccessor) {
        super(annotation, accessibleObject, classAccessor);
       
        // Set the basic metadata if one is present.
        MetadataAnnotation basic = getAnnotation(Basic.class);
        if (basic != null) {
            setFetch((String) basic.getAttribute("fetch"));
            setOptional((Boolean) basic.getAttribute("optional"));
        }
       
        // Set the column metadata if one if present.
        m_column = new ColumnMetadata(getAnnotation(Column.class), accessibleObject, getAttributeName());
       
        // Set the mutable value if one is present.
        MetadataAnnotation mutable = getAnnotation(Mutable.class);
        if (mutable != null) {
            m_mutable = (Boolean) mutable.getAttribute("value");
            if (m_mutable == null) {
                m_mutable = true;
            }
        }
       
View Full Code Here

     * supported using annotations.
     * TODO: Add to the eclipselink-orm.xsd
     */
    @Override
    protected void processReturnInsert() {
        MetadataAnnotation returnInsert = getAnnotation(ReturnInsert.class);

        if (returnInsert != null) {
            boolean returnOnly = (Boolean) returnInsert.getAttribute("returnOnly");
           
            if (returnOnly) {
                getDescriptor().addFieldForInsertReturnOnly(m_field);
            } else {
                getDescriptor().addFieldForInsert(m_field);
View Full Code Here

        // specified then go look for access methods on a mapped superclass
        // or inheritance parent.
        if (hasAccessMethods()) {
            getDescriptor().setDefaultAccessMethods(getAccessMethods());
        } else {
            MetadataAnnotation virtualAccessMethods = getAnnotation(VirtualAccessMethods.class);
            if (virtualAccessMethods != null){
                getDescriptor().setDefaultAccessMethods(new AccessMethodsMetadata(virtualAccessMethods, this));
                return;
            }
            // Go through the mapped superclasses.
View Full Code Here

TOP

Related Classes of org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotation

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.