Package org.jpox.metadata

Examples of org.jpox.metadata.AbstractMemberMetaData


                // field accessor will ignore all methods not annotated
                return null;
            }

            // Create the Field/Property MetaData so we have something to add to
            AbstractMemberMetaData mmd = newMetaDataForMember(cmd, member, annotations);

            // Process other annotations
            ColumnMetaData[] columnMetaData = null;
            JoinMetaData joinmd = null;
            boolean oneToMany = false;
            boolean manyToMany = false;
            for (int i=0;annotations != null && i<annotations.length;i++)
            {
                if (isSupportedAnnotation(annotations[i].getName()))
                {
                    String annName = annotations[i].getName();
                    HashMap<String, Object> annotationValues = annotations[i].getNameValueMap();
                    if (annName.equals(JPAAnnotationUtils.JOIN_COLUMNS))
                    {
                        // 1-1 FK columns, or 1-N FK columns, or N-1 FK columns
                        JoinColumn[] cols = (JoinColumn[])annotationValues.get("value");
                        if (cols != null)
                        {
                            columnMetaData = new ColumnMetaData[cols.length];
                            for (int j=0;j<cols.length;j++)
                            {
                                columnMetaData[j] = new ColumnMetaData(mmd, cols[j].name(), null,
                                    cols[j].referencedColumnName(), null, null, null, null, "" + cols[j].nullable(),
                                    null, null, "" + cols[j].insertable(), "" + cols[j].updatable(), "" + cols[j].unique());
                            }
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.JOIN_COLUMN))
                    {
                        // 1-1 FK column, or 1-N FK column, or N-1 FK column
                        columnMetaData = new ColumnMetaData[1];
                        String colNullable = null;
                        String colInsertable = null;
                        String colUpdateable = null;
                        String colUnique = null;
                        if (annotationValues.get("nullable") != null)
                        {
                            colNullable = annotationValues.get("nullable").toString();
                        }
                        if (annotationValues.get("insertable") != null)
                        {
                            colInsertable = annotationValues.get("insertable").toString();
                        }
                        if (annotationValues.get("updatable") != null)
                        {
                            // Note : "updatable" is spelt incorrectly in the JPA spec.
                            colUpdateable = annotationValues.get("updatable").toString();
                        }
                        if (annotationValues.get("unique") != null)
                        {
                            colUnique = annotationValues.get("unique").toString();
                        }
                        columnMetaData[0] = new ColumnMetaData(mmd, (String)annotationValues.get("name"), null,
                            (String)annotationValues.get("referencedColumnName"), null, null,
                            null, null, colNullable, null, null, colInsertable, colUpdateable, colUnique);
                    }
                    else if (annName.equals(JPAAnnotationUtils.ATTRIBUTE_OVERRIDES) && mmd.isEmbedded())
                    {
                        // Embedded field overrides
                        EmbeddedMetaData emd = new EmbeddedMetaData(mmd,mmd.getName(),"","");
                        mmd.setEmbeddedMetaData(emd);                           
                        AttributeOverride[] attributeOverride = (AttributeOverride[])annotationValues.get("value");
                        for (int j=0; j<attributeOverride.length; j++)
                        {
                            AbstractMemberMetaData apmd = mgr.getMetaDataFactory().newFieldObject(emd,
                                                                    attributeOverride[j].name(),
                                                                    null,null,null,
                                                                    null,null,null,
                                                                    null,null,null,
                                                                    null,null,null,
                                                                    null,null,null,
                                                                    null,null,null,
                                                                    null,null);
                            emd.addMember(apmd);
                            try
                            {
                                //needs to do the same for methods
                                Field overrideField = member.getType().getDeclaredField(attributeOverride[j].name());
                                apmd.addColumn(JPAAnnotationUtils.getColumnMetaDataForColumnAnnotation(apmd,
                                    new Member(overrideField), attributeOverride[j].column()));
                            }
                            catch (SecurityException e)
                            {
                                throw new JPOXException("Cannot obtain override field "+
View Full Code Here


        {
            modifier = FieldPersistenceModifier.PERSISTENT.toString();
        }

        // Create the field
        AbstractMemberMetaData fmd;
        if (field.isProperty())
        {
            fmd = mgr.getMetaDataFactory().newPropertyObject(cmd, field.getName(), pk, modifier, dfg, nullValue,
                embedded, null, null, mappedBy, null, null, null, null, null, null, null, null, null,
                null, null, null, null);
        }
        else
        {
            fmd = mgr.getMetaDataFactory().newFieldObject(cmd, field.getName(), pk, modifier, dfg, nullValue,
                embedded, null, null, mappedBy, null, null, null, null, null, null, null, null, null,
                null, null, null);
        }

        if (version != null)
        {
            // Tag this field as the version field
            VersionMetaData vermd = new VersionMetaData(VersionStrategy.VERSION_NUMBER.toString(), fmd.getName());
            cmd.setVersionMetaData(vermd);
        }

        cmd.addMember(fmd);

        if (cascades != null)
        {
            for (int i = 0; i < cascades.length; i++)
            {
                if (cascades[i] == CascadeType.ALL)
                {
                    fmd.setCascadePersist(true);
                    fmd.setCascadeUpdate(true);
                    fmd.setCascadeDelete(true);
                    fmd.setCascadeRefresh(true);
                }
                else if (cascades[i] == CascadeType.PERSIST)
                {
                    fmd.setCascadePersist(true);
                }
                else if (cascades[i] == CascadeType.MERGE)
                {
                    fmd.setCascadeUpdate(true);
                }
                else if (cascades[i] == CascadeType.REMOVE)
                {
                    fmd.setCascadeDelete(true);
                }
                else if (cascades[i] == CascadeType.REFRESH)
                {
                    fmd.setCascadeRefresh(true);
                }
            }
        }

        // Value generation
        if (valueStrategy != null && valueGenerator != null)
        {
            fmd.setValueGeneratorName(valueGenerator);
        }
        if (valueStrategy != null)
        {
            fmd.setValueStrategy(IdentityStrategy.getIdentityStrategy(valueStrategy));
        }

        // Type storage
        if (storeInLob)
        {
            fmd.setStoreInLob();
        }

        // Container fields : If the field is a container then add its container element
        ContainerMetaData contmd = null;
        if (Collection.class.isAssignableFrom(field.getType()))
        {
            String elementType = null;
            if (targetEntity != null && targetEntity != void.class)
            {
                elementType = targetEntity.getName();
            }
            if (elementType == null)
            {
                elementType = ClassUtils.getCollectionElementType(field.getType(),field.getGenericType());
            }
            // No annotation for collections so cant specify the element type, dependent, embedded, serialized

            contmd = new CollectionMetaData(fmd, elementType, null, null, null);
        }
        else if (field.getType().isArray())
        {
            contmd = new ArrayMetaData(fmd, null, null, null, null);
        }
        else if (Map.class.isAssignableFrom(field.getType()))
        {
            String keyType = ClassUtils.getMapKeyType(field.getType(),field.getGenericType());
            String valueType = null;
            if (targetEntity != null && targetEntity != void.class)
            {
                valueType = targetEntity.getName();
            }
            if (valueType == null)
            {
                valueType = ClassUtils.getMapValueType(field.getType(),field.getGenericType());
            }
            // No annotation for maps so cant specify the key/value type, dependent, embedded, serialized
            contmd = new MapMetaData(fmd, keyType, null, null, null, valueType, null, null, null);
        }
        if (contmd != null)
        {
            fmd.setContainer(contmd);           
        }

        // JPOX extensions
        if (extensions != null)
        {
            Iterator<ExtensionMetaData> iter = extensions.iterator();
            while (iter.hasNext())
            {
                ExtensionMetaData extmd = iter.next();
                fmd.addExtension(extmd.getVendorName(), extmd.getKey(), extmd.getValue());
            }
        }

        return fmd;
    }
View Full Code Here

        ColumnMetaData colmd = new ColumnMetaData(parent, columnName, target, targetField, jdbcType, sqlType, length,
            scale, allowsNull, defaultValue, insertValue, insertable, updateable, unique);
        if (parent instanceof AbstractMemberMetaData)
        {
            AbstractMemberMetaData apmd = (AbstractMemberMetaData) parent;
            apmd.setTable(table);
            // apmd.addColumn(colmd);
            // update column settings if primary key, cannot be null
            colmd.setAllowsNull(new Boolean(apmd.isPrimaryKey() ? false : colmd.isAllowsNull()));
        }
        return colmd;
        // TODO Support columnDefinition
    }
View Full Code Here

        // Add all fields of the embedded class (that are persistent)
        int[] pcFieldNumbers = pcCmd.getAllMemberPositions();
        for (int i=0;i<pcFieldNumbers.length;i++)
        {
            AbstractMemberMetaData pcFmd = pcCmd.getMetaDataForManagedMemberAtAbsolutePosition(pcFieldNumbers[i]);
            if (pcFmd.getPersistenceModifier() == FieldPersistenceModifier.PERSISTENT)
            {
                if (emd != null && emd.getOwnerMember() != null && emd.getOwnerMember().equals(pcFmd.getName()))
                {
                    // Do nothing since we dont map owner fields (since the owner is the containing object)
                }
                else
                {
                    AbstractMemberMetaData embeddedFmd = null;
                    for (int j=0;j<embFmds.length;j++)
                    {
                        // Why are these even possible ? Why are they here ? Why dont they use localised messages ?
                        if (embFmds[j] == null)
                        {
View Full Code Here

                    embSM.replaceField(embAbsFieldNum, fieldValue, true);
                }
                else
                {
                    // If the value is null, but the field is not a primitive update it
                    AbstractMemberMetaData embFmd = embCmd.getMetaDataForManagedMemberAtAbsolutePosition(embAbsFieldNum);
                    if (!embFmd.getType().isPrimitive())
                    {
                        embSM.replaceField(embAbsFieldNum, fieldValue, true);
                    }
                }
View Full Code Here

                    table = qs.getStoreManager().getDatastoreClass(mapping.getType(), clr);
                    ApiAdapter api = qs.getStoreManager().getApiAdapter();

                    if (fieldName != null && subfieldName != null)
                    {
                        AbstractMemberMetaData subfieldMetaData = otherCmd.getMetaDataForMember(subfieldName);
                        if (subfieldMetaData != null && subfieldMetaData.isPrimaryKey() &&
                            !api.isPersistable(subfieldMetaData.getType()))
                        {
                            // Selecting a non-PC field in the other class that is part of its PK mapping (so we have a column here for it)
                            // Avoids the extra join to the other table
                            JavaTypeMapping[] subMappings = ((PersistenceCapableMapping)mapping).getJavaTypeMapping();
                            if (subMappings.length == 1)
View Full Code Here

    {
        AbstractClassMetaData acmd = getMetaDataManager().getMetaDataForClass(cls,
            getClassLoaderResolver());
        if( acmd != null )
        {
            AbstractMemberMetaData fmd =acmd.getMetaDataForMember(fieldName);
            if( fmd == null )
            {
                throw new JPOXUserException("Cannot access field "+fieldName+" on type "+cls.getName());
            }
            return fmd.getType();
        }
        else
        {
            Field field = ClassUtils.getFieldForClass(cls, fieldName);
            if( field == null )
View Full Code Here

            //load key fields from Application Id instance to PC instance

            //if a primary key field is of type PersistenceCapable, it must first be persistent
            for (int fieldNumber = 0; fieldNumber < getAllFieldNumbers().length; fieldNumber++)
            {
                AbstractMemberMetaData fmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
                if (fmd.isPrimaryKey())
                {
                    if (myOM.getMetaDataManager().getMetaDataForClass(fmd.getType(), getObjectManager().getClassLoaderResolver()) != null)
                    {
                        synchronized (currFMmonitor)
                        {
                            FieldManager prevFM = currFM;
                            try
                            {
                                currFM = new SingleValueFieldManager();
                                myPC.jdoProvideField(fieldNumber);
                                PersistenceCapable pkFieldPC =
                                    (PersistenceCapable) ((SingleValueFieldManager) currFM).fetchObjectField(fieldNumber);
                                if (pkFieldPC == null)
                                {
                                    throw new JPOXUserException(
                                        LOCALISER.msg("026016", fmd.getFullFieldName()));
                                }
                                if (!myOM.getApiAdapter().isPersistent(pkFieldPC))
                                {
                                    // Can cause the insert of our object being managed by this SM via flush() when bidir relation
                                    myOM.persistObjectInternal(pkFieldPC, null, null, -1, org.jpox.StateManager.PC);
                                }
                            }
                            finally
                            {
                                currFM = prevFM;
                            }
                        }
                    }
                }
            }
        }

        /* Set the identity
         * This must come after the above block, because in identifying relationships
         * the PK FK associations must be persisted before, otherwise we
         * don't have an id assigned to the PK FK associations
         */       
        setIdentity();

        if (this.getObjectManager().getTransaction().isActive())
        {
            myOM.enlistInTransaction(this);
        }

        // Now in PERSISTENT_NEW so call any callbacks/listeners
        getCallbackHandler().postCreate(myPC);

        if (myOM.getOMFContext().getPersistenceConfiguration().getBooleanProperty("org.jpox.manageRelationships"))
        {
            // Managed Relations : register non-null bidir fields for later processing
            ClassLoaderResolver clr = myOM.getClassLoaderResolver();
            int[] relationPositions = cmd.getRelationMemberPositions(myOM.getClassLoaderResolver());
            if (relationPositions != null)
            {
                for (int i=0;i<relationPositions.length;i++)
                {
                    AbstractMemberMetaData mmd =
                        cmd.getMetaDataForManagedMemberAtAbsolutePosition(relationPositions[i]);
                    int relationType = mmd.getRelationType(clr);
                    if (relationType == Relation.ONE_TO_ONE_BI ||
                        relationType == Relation.MANY_TO_ONE_BI ||
                        relationType == Relation.ONE_TO_MANY_BI ||
                        relationType == Relation.MANY_TO_MANY_BI)
                    {
View Full Code Here

    {
        int totalFieldCount = cmd.getNoOfInheritedManagedMembers() + cmd.getNoOfManagedMembers();

        for (int fieldNumber =0; fieldNumber < totalFieldCount; fieldNumber++)
        {
            AbstractMemberMetaData fmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            IdentityStrategy strategy = fmd.getValueStrategy();

            // Check for the strategy, and if it is a datastore attributed strategy
            if (strategy != null && !getStoreManager().isStrategyDatastoreAttributed(strategy, false))
            {
                // Assign the strategy value where required.
                // Default JDO2 behaviour is to always provide a strategy value when it is marked as using a strategy
                boolean applyStrategy = true;
                if (!fmd.getType().isPrimitive() && strategy != null &&
                    fmd.hasExtension("strategy-when-notnull") &&
                    fmd.getValueForExtension("strategy-when-notnull").equalsIgnoreCase("false") &&
                    this.provideField(fieldNumber) != null)
                {
                    // JPOX allows an extension to only provide a value-strategy value where the field is null at persistence.
                    applyStrategy = false;
                }
View Full Code Here

        {
            boolean isObjectIDDatastoreAttributed = false;
            int totalFieldCount = cmd.getNoOfInheritedManagedMembers() + cmd.getNoOfManagedMembers();
            for (int fieldNumber =0; fieldNumber < totalFieldCount; fieldNumber++)
            {
                AbstractMemberMetaData fmd=cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
                if (fmd.isPrimaryKey())
                {
                    if (getStoreManager().isStrategyDatastoreAttributed(fmd.getValueStrategy(), false))
                    {
                        isObjectIDDatastoreAttributed = true;
                        break;
                    }
                    else if (cmd.usesSingleFieldIdentityClass())
                    {
                        if (this.provideField(fieldNumber) == null)
                        {
                            // SingleFieldIdentity field has not had its value set (by user, or by value-strategy)
                            throw new JPOXUserException(LOCALISER.msg("026017",
                                cmd.getFullClassName(), fmd.getName())).setFatal();
                        }
                    }
                }
            }
View Full Code Here

TOP

Related Classes of org.jpox.metadata.AbstractMemberMetaData

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.