Refine search
/** * Constructor. */ public PCDataImpl(Object oid, ClassMetaData meta) { _oid = oid; _type = meta.getDescribedType(); int len = meta.getFields().length; _data = new Object[len]; _loaded = new BitSet(len); }
/** * Return the metadata for the persistent or transactional field with * the given relative index. * * @return the field's metadata, or null if not found */ public FieldMetaData getDeclaredField(int index) { FieldMetaData[] fields = getDeclaredFields(); if (index < 0 || index >= fields.length) return null; return fields[index]; }
public synchronized boolean isImplDataCacheable(int field) { if (_fieldImpl == null || !_loaded.get(field)) return false; if (_meta.getField(field).usesImplData() != null) return false; int idx = _meta.getExtraFieldDataIndex(field); return idx != -1 && _fieldImpl[idx] != null; }
/** * Cache field arrays. */ private void cacheFields() { getFields(); getPrimaryKeyFields(); }
/** * Return the MetaDataTag for the given class meta data. */ private static MetaDataTag getEntityTag(ClassMetaData meta) { // @Embeddable classes can't declare Id fields if (meta.isEmbeddedOnly() && meta.getPrimaryKeyFields().length == 0) return MetaDataTag.EMBEDDABLE; if (meta.isMapped()) return MetaDataTag.ENTITY; return MetaDataTag.MAPPED_SUPERCLASS; }
/** * Return the least-derived metadata in the inheritance chain * above <code>meta</code>, or <code>meta</code> if it is a * least-derived metadata. */ private static ClassMetaData getLeastDerived(ClassMetaData meta) { while (meta.getPCSuperclass() != null) meta = meta.getPCSuperclassMetaData(); return meta; }
public void store(OpenJPAStateManager sm, BitSet fields) { storeVersion(sm); storeImplData(sm); FieldMetaData[] fmds = sm.getMetaData().getFields(); for (int i = 0; i < fmds.length; i++) { if (fields != null && fields.get(i)) { storeField(sm, fmds[i]); storeImplData(sm, fmds[i], isLoaded(i)); } else if (!isLoaded(i)) storeIntermediate(sm, fmds[i]); } }
public Object newDataStoreId(Object val, ClassMetaData meta) { // we use base types for all oids while (meta.getPCSuperclass() != null) meta = meta.getPCSuperclassMetaData(); return Id.newInstance(meta.getDescribedType(), val); }
private boolean recursiveEmbed(ValueMetaData owner) { ClassMetaData cm = owner.getFieldMetaData().getDefiningMetaData(); if (cm.getDescribedType().isAssignableFrom(_type)) return true; ValueMetaData owner1 = cm.getEmbeddingMetaData(); if (owner1 == null) return false; else return recursiveEmbed(owner1); }
private Log getLog(ClassMetaData meta) { return meta.getRepository().getConfiguration() .getLog(OpenJPAConfiguration.LOG_METADATA); }
private Object getValue(int i, Object o) { FieldMetaData fmd = meta.getField(i); if (AccessCode.isProperty(fmd.getAccessType())) { Field field = Reflection.findField(meta.getDescribedType(), toFieldName(i), true); return Reflection.get(o, field); } else { Field field = (Field) meta.getField(i).getBackingMember(); return Reflection.get(o, field); } }
/** * Returns the attributes corresponding to the id class of the identifiable type. * * @throws IllegalArgumentException if the this type is not using an id class */ public final java.util.Set<SingularAttribute<? super X, ?>> getIdClassAttributes() { if (meta.isOpenJPAIdentity()) throw new IllegalArgumentException(meta + " does not use IdClass. Object Id type = " + meta.getObjectIdType() + " Identity Type = " + meta.getIdentityType()); return filter(attrs, new HashSet<SingularAttribute<? super X, ?>>(), new IdAttributeFilter<X>()); }
private void logNoSetter(ClassMetaData meta, String name, Exception e) { Log log = meta.getRepository().getConfiguration() .getLog(OpenJPAConfiguration.LOG_METADATA); if (log.isWarnEnabled()) log.warn(_loc.get("no-setter-for-getter", name, meta.getDescribedType().getName())); else if (log.isTraceEnabled()) // log the exception, if any, if we're in trace-level debugging log.warn(_loc.get("no-setter-for-getter", name, meta.getDescribedType().getName()), e); } }
private Object getValue(int i, Object o) { if (meta.getAccessType() == ClassMetaData.ACCESS_PROPERTY) { Field field = Reflection.findField(meta.getDescribedType(), toFieldName(i), true); return Reflection.get(o, field); } else { Field field = (Field) meta.getField(i).getBackingMember(); return Reflection.get(o, field); } }
/** * Whether the class being enhanced should externalize to a detached * instance rather than serialize. */ private boolean externalizeDetached() { return ClassMetaData.SYNTHETIC.equals(_meta.getDetachedState()) && Serializable.class.isAssignableFrom(_meta.getDescribedType()) && !_repos.getConfiguration().getDetachStateInstance(). isDetachedStateTransient(); }
private void add(Class cls) { // assume all user-defined types are PCs ClassMetaData meta = getRepository().addMetaData(cls); FieldMetaData[] fmds = meta.getDeclaredFields(); for (int i = 0; i < fmds.length; i++) { if (fmds[i].getDeclaredTypeCode() == JavaTypes.OBJECT && fmds[i].getDeclaredType() != Object.class) fmds[i].setDeclaredTypeCode(JavaTypes.PC); } meta.setSource(_file, meta.getSourceType(), _file == null ? "" : _file.getPath()); _flush = true; }
/** * Constructor. Supply configuration and type to enhance. This will look * up the metadata for <code>meta</code> by converting back to a class * and then loading from <code>conf</code>'s repository. */ public PCEnhancer(OpenJPAConfiguration conf, ClassMetaData meta) { this(conf, AccessController.doPrivileged(J2DoPrivHelper .loadProjectClassAction(new Project(), meta.getDescribedType())), meta.getRepository()); }