/**
* Method to remove an element from the List
*
* @param element The Element to remove
* @return Whether it was removed successfully.
*/
public boolean remove(Object element, boolean allowCascadeDelete) {
boolean success = delegate.remove(element);
if (ownerOP != null && ownerOP.getExecutionContext().getManageRelations()) {
ownerOP
.getExecutionContext()
.getRelationshipManager(ownerOP)
.relationRemove(ownerMmd.getAbsoluteFieldNumber(), element);
}
if (ownerOP != null && allowCascadeDelete) {
// Cascade delete
if (SCOUtils.useQueuedUpdate(ownerOP)) {
// Queue the cascade delete
ownerOP
.getExecutionContext()
.addOperationToQueue(
new CollectionRemoveOperation(
ownerOP, ownerMmd.getAbsoluteFieldNumber(), element, allowCascadeDelete));
} else if (SCOUtils.hasDependentElement(ownerMmd)) {
// Perform the cascade delete
ownerOP.getExecutionContext().deleteObjectInternal(element);
}
}
if (success) {
makeDirty();
if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
return success;
}
/**
* Method to add a collection to the LinkedHashSet.
*
* @param elements The collection
* @return Whether it was added ok.
*/
public boolean addAll(Collection elements) {
boolean success = delegate.addAll(elements);
if (ownerOP != null && ownerOP.getExecutionContext().getManageRelations()) {
// Relationship management
Iterator iter = elements.iterator();
while (iter.hasNext()) {
ownerOP
.getExecutionContext()
.getRelationshipManager(ownerOP)
.relationAdd(ownerMmd.getAbsoluteFieldNumber(), iter.next());
}
}
if (success) {
if (SCOUtils.useQueuedUpdate(ownerOP)) {
for (Object element : elements) {
ownerOP
.getExecutionContext()
.addOperationToQueue(
new CollectionAddOperation(ownerOP, ownerMmd.getAbsoluteFieldNumber(), element));
}
}
makeDirty();
if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
return success;
}
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() == 0 || args.size() > 1) {
throw new NucleusException(Localiser.msg("060016", "containsValue", "MapExpression", 1));
}
MapExpression mapExpr = (MapExpression) expr;
SQLExpression valExpr = args.get(0);
if (valExpr.isParameter()) {
// Value is a parameter so make sure its type is set
AbstractMemberMetaData mmd = mapExpr.getJavaTypeMapping().getMemberMetaData();
if (mmd != null && mmd.getMap() != null) {
Class valCls =
stmt.getQueryGenerator()
.getClassLoaderResolver()
.classForName(mmd.getMap().getValueType());
stmt.getQueryGenerator().bindParameter(valExpr.getParameterName(), valCls);
}
}
if (mapExpr instanceof MapLiteral) {
MapLiteral lit = (MapLiteral) mapExpr;
Map map = (Map) lit.getValue();
if (map == null || map.size() == 0) {
return new BooleanLiteral(stmt, expr.getJavaTypeMapping(), Boolean.FALSE);
}
// TODO If valExpr is a parameter and mapExpr is derived from a parameter ?
MapValueLiteral mapValueLiteral = lit.getValueLiteral();
BooleanExpression bExpr = null;
List<SQLExpression> elementExprs = mapValueLiteral.getValueExpressions();
for (int i = 0; i < elementExprs.size(); i++) {
if (bExpr == null) {
bExpr = (elementExprs.get(i)).eq(valExpr);
} else {
bExpr = bExpr.ior((elementExprs.get(i)).eq(valExpr));
}
}
if (bExpr != null) {
bExpr.encloseInParentheses();
}
return bExpr;
}
if (stmt.getQueryGenerator().getCompilationComponent() == CompilationComponent.FILTER) {
boolean needsSubquery = getNeedsSubquery();
// TODO Check if *this* "containsValue" is negated, not any of them (and remove above check)
if (needsSubquery) {
NucleusLogger.QUERY.debug(
"map.containsValue on " + mapExpr + "(" + valExpr + ") using SUBQUERY");
return containsAsSubquery(mapExpr, valExpr);
}
NucleusLogger.QUERY.debug(
"map.containsValue on " + mapExpr + "(" + valExpr + ") using INNERJOIN");
return containsAsInnerJoin(mapExpr, valExpr);
}
return containsAsSubquery(mapExpr, valExpr);
}
/**
* Convenience method to unload a field/property.
*
* @param fieldName Name of the field/property
* @throws NucleusUserException if the object managed by this StateManager is embedded
*/
public void unloadField(String fieldName) {
if (objectType == ObjectProvider.PC) {
// Mark as not loaded
AbstractMemberMetaData mmd = getClassMetaData().getMetaDataForMember(fieldName);
loadedFields[mmd.getAbsoluteFieldNumber()] = false;
} else {
throw new NucleusUserException("Cannot unload field/property of embedded object");
}
}
/**
* Convenience method for whether a PK is required for the join table. Makes use of the extension
* "primary-key" (within <join>) to allow turning off PK generation.
*
* @return Whether a PK is required
*/
protected boolean requiresPrimaryKey() {
boolean pkRequired = true;
if (mmd.getJoinMetaData() != null
&& mmd.getJoinMetaData().hasExtension("primary-key")
&& mmd.getJoinMetaData().getValueForExtension("primary-key").equalsIgnoreCase("false")) {
pkRequired = false;
}
return pkRequired;
}
/**
* Method called when a method of the class is visited.
*
* @param access Access for the method
* @param name Name of the method
* @param desc Descriptor
* @param signature Signature
* @param exceptions Exceptions that this method is declared to throw
* @return Visitor to visit this (or null if not wanting to visit it)
*/
public MethodVisitor visitMethod(
int access, String name, String desc, String signature, String[] exceptions) {
if (name.equals("<init>") && desc != null && desc.equals("()V")) {
// Check for default constructor
hasDefaultConstructor = true;
}
if (name.equals("writeObject")
&& desc != null
&& desc.equals("(Ljava/io/ObjectOutputStream;)V")) {
// Has writeObject() for use in serialisation
hasWriteObject = true;
}
if (name.equals("<clinit>") && desc != null && desc.equals("()V")) {
hasStaticInitialisation = true;
}
MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
if (mv == null) {
return null;
}
if (name.equals("jdoPreClear") || name.equals("jdoPostLoad")) {
// jdoPreClear/jdoPostLoad should not be enhanced (JDO2 spec [10.1, 10.3]
return mv;
} else if (name.equals("readObject")
&& (desc.equals("(Ljava/io/ObjectOutputStream;)V")
|| desc.equals("(Ljava/io/ObjectInputStream;)V"))) {
// readObject(ObjectInputStream), readObject(ObjectOutputStream) should not be enhanced (JDO2
// spec [21.6])
return mv;
}
String propGetterName = ClassUtils.getFieldNameForJavaBeanGetter(name);
String propSetterName = ClassUtils.getFieldNameForJavaBeanSetter(name);
if (propGetterName != null) {
AbstractMemberMetaData mmd = enhancer.getClassMetaData().getMetaDataForMember(propGetterName);
if (mmd != null
&& mmd instanceof PropertyMetaData
&& mmd.getPersistenceModifier() != FieldPersistenceModifier.NONE) {
// Property getter method "getXXX" - generated dnGetXXX
return new EnhancerPropertyGetterAdapter(mv, enhancer, name, desc, mmd, cv);
}
} else if (propSetterName != null) {
AbstractMemberMetaData mmd = enhancer.getClassMetaData().getMetaDataForMember(propSetterName);
if (mmd != null
&& mmd instanceof PropertyMetaData
&& mmd.getPersistenceModifier() != FieldPersistenceModifier.NONE) {
// Property setter method "setXXX" - generates dnSetXXX
return new EnhancerPropertySetterAdapter(mv, enhancer, name, desc, mmd, cv);
}
}
// normal method, so just enhance it
return new EnhancerMethodAdapter(mv, enhancer, name, desc);
}
/**
* Accessor for the primary key for this table. Overrides the method in TableImpl to add on any
* specification of PK name in the <join> metadata.
*
* @return The primary key.
*/
public PrimaryKey getPrimaryKey() {
PrimaryKey pk = super.getPrimaryKey();
if (mmd.getJoinMetaData() != null) {
PrimaryKeyMetaData pkmd = mmd.getJoinMetaData().getPrimaryKeyMetaData();
if (pkmd != null && pkmd.getName() != null) {
pk.setName(pkmd.getName());
}
}
return pk;
}
/**
* Constructor.
*
* @param tableName The Table SQL identifier
* @param mmd Member meta data for the owner field/property
* @param storeMgr Manager for the datastore.
*/
protected JoinTable(
DatastoreIdentifier tableName, AbstractMemberMetaData mmd, RDBMSStoreManager storeMgr) {
super(tableName, storeMgr);
this.mmd = mmd;
this.ownerType = mmd.getClassName(true);
if (mmd.getPersistenceModifier() == FieldPersistenceModifier.NONE) {
throw new NucleusException(Localiser.msg("057006", mmd.getName())).setFatal();
}
}
/**
* Utility to add the mapping for a field/property to the managed list.
*
* @param fieldMapping The mapping for the field/property
*/
protected void addMemberMapping(JavaTypeMapping fieldMapping) {
AbstractMemberMetaData mmd = fieldMapping.getMemberMetaData();
logMapping(mmd.getFullFieldName(), fieldMapping);
memberMappingsMap.put(mmd, fieldMapping);
// Update highest field number if this is higher
int absoluteFieldNumber = mmd.getAbsoluteFieldNumber();
if (absoluteFieldNumber > highestMemberNumber) {
highestMemberNumber = absoluteFieldNumber;
}
}
/**
* Accessor for the JavaTypeMapping that is handling the member of the specified name. Returns the
* first one that matches.
*
* @param memberName Name of the field/property
* @return The java type mapping
*/
protected JavaTypeMapping getMappingForMemberName(String memberName) {
Iterator<Map.Entry<AbstractMemberMetaData, JavaTypeMapping>> memberMapEntryIter =
memberMappingsMap.entrySet().iterator();
while (memberMapEntryIter.hasNext()) {
Map.Entry<AbstractMemberMetaData, JavaTypeMapping> memberMapEntry = memberMapEntryIter.next();
AbstractMemberMetaData mmd = memberMapEntry.getKey();
if (mmd.getFullFieldName().equals(memberName)) {
return memberMapEntry.getValue();
}
}
return null;
}
/**
* Constructor, using the ObjectProvider of the "owner" and the field name.
*
* @param op The owner ObjectProvider
* @param mmd Metadata for the member
*/
public Map(ObjectProvider op, AbstractMemberMetaData mmd) {
super(op, mmd);
// Set up our "delegate"
this.delegate = new java.util.HashMap();
ExecutionContext ec = ownerOP.getExecutionContext();
allowNulls = SCOUtils.allowNullsInContainer(allowNulls, mmd);
useCache = SCOUtils.useContainerCache(ownerOP, mmd);
if (!SCOUtils.mapHasSerialisedKeysAndValues(mmd)
&& mmd.getPersistenceModifier() == FieldPersistenceModifier.PERSISTENT) {
ClassLoaderResolver clr = ec.getClassLoaderResolver();
this.backingStore =
(MapStore)
((BackedSCOStoreManager) ownerOP.getStoreManager())
.getBackingStoreForField(clr, mmd, java.util.Map.class);
}
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
SCOUtils.getContainerInfoMessage(
ownerOP,
ownerMmd.getName(),
this,
useCache,
allowNulls,
SCOUtils.useCachedLazyLoading(ownerOP, ownerMmd)));
}
}
/**
* Constructor, using the ObjectProvider of the "owner" and the field name.
*
* @param op The owner ObjectProvider
* @param mmd Metadata for the member
*/
public ArrayList(ObjectProvider op, AbstractMemberMetaData mmd) {
super(op, mmd);
// Set up our delegate
this.delegate = new java.util.ArrayList();
ExecutionContext ec = op.getExecutionContext();
allowNulls = SCOUtils.allowNullsInContainer(allowNulls, mmd);
queued = ec.isDelayDatastoreOperationsEnabled();
useCache = SCOUtils.useContainerCache(op, mmd);
if (!SCOUtils.collectionHasSerialisedElements(mmd)
&& mmd.getPersistenceModifier() == FieldPersistenceModifier.PERSISTENT) {
ClassLoaderResolver clr = ec.getClassLoaderResolver();
this.backingStore =
(ListStore)
((BackedSCOStoreManager) op.getStoreManager())
.getBackingStoreForField(clr, mmd, java.util.ArrayList.class);
}
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
SCOUtils.getContainerInfoMessage(
op,
ownerMmd.getName(),
this,
useCache,
queued,
allowNulls,
SCOUtils.useCachedLazyLoading(op, ownerMmd)));
}
}
/**
* Provide the mappings to the consumer for all non primary-key fields mapped to this table.
*
* @param consumer Consumer for the mappings
*/
public final void provideNonPrimaryKeyMappings(MappingConsumer consumer) {
consumer.preConsumeMapping(highestMemberNumber + 1);
Iterator<Map.Entry<AbstractMemberMetaData, JavaTypeMapping>> memberMapEntryIter =
memberMappingsMap.entrySet().iterator();
while (memberMapEntryIter.hasNext()) {
Map.Entry<AbstractMemberMetaData, JavaTypeMapping> memberMapEntry = memberMapEntryIter.next();
AbstractMemberMetaData mmd = memberMapEntry.getKey();
JavaTypeMapping memberMapping = memberMapEntry.getValue();
if (memberMapping != null) {
if (!mmd.isPrimaryKey()) {
consumer.consumeMapping(memberMapping, mmd);
}
}
}
}
/**
* Convenience logging method to output the mapping information for an element, key, value field
*
* @param mapping The mapping
*/
protected void debugMapping(JavaTypeMapping mapping) {
if (NucleusLogger.DATASTORE.isDebugEnabled()) {
// Provide field->column mapping debug message
StringBuffer columnsStr = new StringBuffer();
for (int i = 0; i < mapping.getNumberOfDatastoreMappings(); i++) {
if (i > 0) {
columnsStr.append(",");
}
columnsStr.append(mapping.getDatastoreMapping(i).getDatastoreField());
}
if (mapping.getNumberOfDatastoreMappings() == 0) {
columnsStr.append("[none]");
}
StringBuffer datastoreMappingTypes = new StringBuffer();
for (int i = 0; i < mapping.getNumberOfDatastoreMappings(); i++) {
if (i > 0) {
datastoreMappingTypes.append(',');
}
datastoreMappingTypes.append(mapping.getDatastoreMapping(i).getClass().getName());
}
NucleusLogger.DATASTORE.debug(
LOCALISER.msg(
"057010",
mmd.getFullFieldName(),
columnsStr.toString(),
mapping.getClass().getName(),
datastoreMappingTypes.toString()));
}
}
/** Utility to mark the object as dirty */
public void makeDirty() {
if (ownerOP != null) {
ownerOP.makeDirty(ownerMmd.getAbsoluteFieldNumber());
if (!ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
}
/**
* Constructor.
*
* @param enhancer ClassEnhancer
* @param fmd MetaData for the field we are generating for
*/
public JdoSetViaCheck(ClassEnhancer enhancer, AbstractMemberMetaData fmd) {
super(
enhancer,
enhancer.getNamer().getSetMethodPrefixMethodName() + fmd.getName(),
(fmd.isPublic() ? Opcodes.ACC_PUBLIC : 0)
| (fmd.isProtected() ? Opcodes.ACC_PROTECTED : 0)
| (fmd.isPrivate() ? Opcodes.ACC_PRIVATE : 0)
| Opcodes.ACC_STATIC,
null,
null,
null);
// Set the arg types/names
argTypes = new Class[] {getClassEnhancer().getClassBeingEnhanced(), fmd.getType()};
argNames = new String[] {"objPC", "val"};
this.fmd = fmd;
}
/**
* Constructor, taking the meta data for the field, and the table it is mapped to.
*
* @param mmd MetaData for the field.
* @param table Table definition
*/
public RDBMSStoreData(AbstractMemberMetaData mmd, Table table) {
super(mmd.getFullFieldName(), mmd, SCO_TYPE, null);
if (table == null) {
throw new NullPointerException("table should not be null");
}
this.table = table;
this.tableName = table.toString();
this.tableOwner = true;
this.tableIdentifier = table.getIdentifier();
String interfaceName =
(table.getStoreManager().getMetaDataManager().isPersistentInterface(mmd.getType().getName())
? mmd.getType().getName()
: null);
if (interfaceName != null) {
this.interfaceName = interfaceName;
}
}
/**
* Method to remove all elements from the collection from the LinkedHashSet.
*
* @param elements The collection of elements to remove
* @return Whether it was removed ok.
*/
public boolean removeAll(java.util.Collection elements) {
boolean success = delegate.removeAll(elements);
if (ownerOP != null && ownerOP.getExecutionContext().getManageRelations()) {
// Relationship management
Iterator iter = elements.iterator();
RelationshipManager relMgr = ownerOP.getExecutionContext().getRelationshipManager(ownerOP);
while (iter.hasNext()) {
relMgr.relationRemove(ownerMmd.getAbsoluteFieldNumber(), iter.next());
}
}
if (ownerOP != null && elements != null && !elements.isEmpty()) {
// Cascade delete
if (SCOUtils.useQueuedUpdate(ownerOP)) {
// Queue the cascade delete
Iterator iter = elements.iterator();
while (iter.hasNext()) {
ownerOP
.getExecutionContext()
.addOperationToQueue(
new CollectionRemoveOperation(
ownerOP, ownerMmd.getAbsoluteFieldNumber(), iter.next(), true));
}
} else if (SCOUtils.hasDependentElement(ownerMmd)) {
// Perform the cascade delete
Iterator iter = elements.iterator();
while (iter.hasNext()) {
ownerOP.getExecutionContext().deleteObjectInternal(iter.next());
}
}
}
if (success) {
makeDirty();
if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
return success;
}
/** Method to initialise the SCO for use. */
public void initialise() {
initialiseDelegate();
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
LOCALISER.msg(
"023003",
ownerOP.getObjectAsPrintable(),
ownerMmd.getName(),
"" + size(),
SCOUtils.getSCOWrapperOptionsMessage(true, false, false, false)));
}
}
/* (non-Javadoc)
* @see org.datanucleus.store.fieldmanager.AbstractFieldManager#fetchObjectField(int)
*/
@Override
public Object fetchObjectField(int fieldNumber) {
ClassLoaderResolver clr = ec.getClassLoaderResolver();
AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
RelationType relationType = mmd.getRelationType(clr);
EmbeddedMetaData embmd = mmds.get(0).getEmbeddedMetaData();
if (mmds.size() == 1
&& embmd != null
&& embmd.getOwnerMember() != null
&& embmd.getOwnerMember().equals(mmd.getName())) {
// Special case of this being a link back to the owner. TODO Repeat this for nested and their
// owners
ObjectProvider[] ownerOps = ec.getOwnersForEmbeddedObjectProvider(op);
return (ownerOps != null && ownerOps.length > 0 ? ownerOps[0].getObject() : null);
}
if (relationType != RelationType.NONE
&& MetaDataUtils.getInstance()
.isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, null)) {
// Embedded field
if (RelationType.isRelationSingleValued(relationType)) {
// TODO Cater for null value detection
List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>(mmds);
embMmds.add(mmd);
AbstractClassMetaData embCmd =
ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), clr);
ObjectProvider embOP =
ec.getNucleusContext()
.getObjectProviderFactory()
.newForEmbedded(ec, embCmd, op, fieldNumber);
FieldManager ffm = new FetchEmbeddedFieldManager(embOP, result, embMmds, table);
embOP.replaceFields(embCmd.getAllMemberPositions(), ffm);
return embOP.getObject();
}
}
return fetchNonEmbeddedObjectField(mmd, relationType, clr);
}
private static void addColumnsToScanForEmbeddedMember(
Scan scan, List<AbstractMemberMetaData> embMmds, Table table, ExecutionContext ec) {
AbstractMemberMetaData lastMmd = embMmds.get(embMmds.size() - 1);
ClassLoaderResolver clr = ec.getClassLoaderResolver();
AbstractClassMetaData embCmd =
ec.getMetaDataManager().getMetaDataForClass(lastMmd.getTypeName(), clr);
int[] embMmdPosns = embCmd.getAllMemberPositions();
for (int i = 0; i < embMmdPosns.length; i++) {
AbstractMemberMetaData embMmd = embCmd.getMetaDataForManagedMemberAtAbsolutePosition(i);
List<AbstractMemberMetaData> subEmbMmds = new ArrayList<AbstractMemberMetaData>(embMmds);
subEmbMmds.add(embMmd);
RelationType relationType = embMmd.getRelationType(clr);
MemberColumnMapping mapping = table.getMemberColumnMappingForEmbeddedMember(subEmbMmds);
if (RelationType.isRelationSingleValued(relationType)) {
addColumnsToScanForEmbeddedMember(scan, subEmbMmds, table, ec);
} else {
String familyName = HBaseUtils.getFamilyNameForColumn(mapping.getColumn(0));
String qualifName = HBaseUtils.getQualifierNameForColumn(mapping.getColumn(0));
scan.addColumn(familyName.getBytes(), qualifName.getBytes());
}
}
}
/**
* Method to add an element to the LinkedHashSet.
*
* @param element The new element
* @return Whether it was added ok.
*/
public boolean add(E element) {
boolean success = delegate.add(element);
if (ownerOP != null && ownerOP.getExecutionContext().getManageRelations()) {
// Relationship management
ownerOP
.getExecutionContext()
.getRelationshipManager(ownerOP)
.relationAdd(ownerMmd.getAbsoluteFieldNumber(), element);
}
if (success) {
if (SCOUtils.useQueuedUpdate(ownerOP)) {
ownerOP
.getExecutionContext()
.addOperationToQueue(
new CollectionAddOperation(ownerOP, ownerMmd.getAbsoluteFieldNumber(), element));
}
makeDirty();
if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
return success;
}
/**
* Method to initialise the SCO from an existing value.
*
* @param o Object to set value using.
* @param forInsert Whether the object needs inserting in the datastore with this value
* @param forUpdate Whether to update the datastore with this value
*/
public void initialise(Object o, boolean forInsert, boolean forUpdate) {
java.util.Map m = (java.util.Map) o;
if (m != null) {
delegate = (java.util.HashMap) m;
} else {
delegate = new java.util.HashMap();
}
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
LOCALISER.msg(
"023003",
ownerOP.getObjectAsPrintable(),
ownerMmd.getName(),
"" + size(),
SCOUtils.getSCOWrapperOptionsMessage(true, false, true, false)));
}
}
public void initialise(java.util.LinkedHashSet c) {
if (c != null) {
delegate = c;
} else {
delegate = new java.util.LinkedHashSet();
}
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
Localiser.msg(
"023003",
this.getClass().getName(),
ownerOP.getObjectAsPrintable(),
ownerMmd.getName(),
"" + size(),
SCOUtils.getSCOWrapperOptionsMessage(true, false, true, false)));
}
}
/**
* Method to initialise the SCO from an existing value.
*
* @param c The object to set from
* @param forInsert Whether the object needs inserting in the datastore with this value
* @param forUpdate Whether to update the datastore with this value
*/
public void initialise(java.util.PriorityQueue c, boolean forInsert, boolean forUpdate) {
if (c != null) {
initialiseDelegate();
delegate.addAll(c);
} else {
initialiseDelegate();
}
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(
Localiser.msg(
"023003",
ownerOP.getObjectAsPrintable(),
ownerMmd.getName(),
"" + size(),
SCOUtils.getSCOWrapperOptionsMessage(true, false, false, false)));
}
}
/**
* Method to retain a Collection of elements (and remove all others).
*
* @param c The collection to retain
* @return Whether they were retained successfully.
*/
public boolean retainAll(java.util.Collection c) {
if (c == null) {
throw new NullPointerException("Input collection was null");
}
Collection collToRemove = new java.util.LinkedHashSet();
for (Object o : delegate) {
if (!c.contains(o)) {
collToRemove.add(o);
}
}
boolean success = delegate.retainAll(c);
if (success) {
makeDirty();
if (SCOUtils.useQueuedUpdate(ownerOP)) {
// Queue any cascade delete
Iterator iter = collToRemove.iterator();
while (iter.hasNext()) {
ownerOP
.getExecutionContext()
.addOperationToQueue(
new CollectionRemoveOperation(
ownerOP, ownerMmd.getAbsoluteFieldNumber(), iter.next(), true));
}
} else if (SCOUtils.hasDependentElement(ownerMmd)) {
// Perform the cascade delete
Iterator iter = collToRemove.iterator();
while (iter.hasNext()) {
ownerOP.getExecutionContext().deleteObjectInternal(iter.next());
}
}
if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) {
ownerOP.getExecutionContext().processNontransactionalUpdate();
}
}
return success;
}
/** Method to add the contents of the class method. */
public void execute() {
visitor.visitCode();
String fieldTypeDesc = Type.getDescriptor(fmd.getType());
Label startLabel = new Label();
visitor.visitLabel(startLabel);
// "if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)"
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitFieldInsn(
Opcodes.GETFIELD,
getClassEnhancer().getASMClassName(),
getNamer().getFlagsFieldName(),
"B");
Label l1 = new Label();
visitor.visitJumpInsn(Opcodes.IFEQ, l1);
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitFieldInsn(
Opcodes.GETFIELD,
getClassEnhancer().getASMClassName(),
getNamer().getStateManagerFieldName(),
"L" + getNamer().getStateManagerAsmClassName() + ";");
visitor.visitJumpInsn(Opcodes.IFNULL, l1);
// "objPC.jdoStateManager.setYYYField(objPC, 8, objPC.ZZZ, val);"
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitFieldInsn(
Opcodes.GETFIELD,
getClassEnhancer().getASMClassName(),
getNamer().getStateManagerFieldName(),
"L" + getNamer().getStateManagerAsmClassName() + ";");
visitor.visitVarInsn(Opcodes.ALOAD, 0);
EnhanceUtils.addBIPUSHToMethod(visitor, fmd.getFieldId());
if (enhancer.getClassMetaData().getPersistenceCapableSuperclass() != null) {
visitor.visitFieldInsn(
Opcodes.GETSTATIC,
getClassEnhancer().getASMClassName(),
getNamer().getInheritedFieldCountFieldName(),
"I");
visitor.visitInsn(Opcodes.IADD);
}
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitFieldInsn(
Opcodes.GETFIELD, getClassEnhancer().getASMClassName(), fmd.getName(), fieldTypeDesc);
EnhanceUtils.addLoadForType(visitor, fmd.getType(), 1);
String jdoMethodName = "set" + EnhanceUtils.getTypeNameForJDOMethod(fmd.getType()) + "Field";
String argTypeDesc = fieldTypeDesc;
if (jdoMethodName.equals("setObjectField")) {
argTypeDesc = EnhanceUtils.CD_Object;
}
visitor.visitMethodInsn(
Opcodes.INVOKEINTERFACE,
getNamer().getStateManagerAsmClassName(),
jdoMethodName,
"(L" + getNamer().getPersistableAsmClassName() + ";I" + argTypeDesc + argTypeDesc + ")V");
Label l3 = new Label();
visitor.visitJumpInsn(Opcodes.GOTO, l3);
// "objPC.text = val;"
visitor.visitLabel(l1);
if (JavaUtils.useStackMapFrames()) {
visitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
}
visitor.visitVarInsn(Opcodes.ALOAD, 0);
EnhanceUtils.addLoadForType(visitor, fmd.getType(), 1);
visitor.visitFieldInsn(
Opcodes.PUTFIELD, getClassEnhancer().getASMClassName(), fmd.getName(), fieldTypeDesc);
if (enhancer.getClassMetaData().isDetachable()) {
// "if (objPC.jdoIsDetached() == true) ((BitSet) objPC.jdoDetachedState[3]).set(8);"
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitMethodInsn(
Opcodes.INVOKEVIRTUAL,
getClassEnhancer().getASMClassName(),
getNamer().getIsDetachedMethodName(),
"()Z");
visitor.visitJumpInsn(Opcodes.IFEQ, l3);
visitor.visitVarInsn(Opcodes.ALOAD, 0);
visitor.visitFieldInsn(
Opcodes.GETFIELD,
getClassEnhancer().getASMClassName(),
getNamer().getDetachedStateFieldName(),
"[Ljava/lang/Object;");
visitor.visitInsn(Opcodes.ICONST_3);
visitor.visitInsn(Opcodes.AALOAD);
visitor.visitTypeInsn(Opcodes.CHECKCAST, "java/util/BitSet");
EnhanceUtils.addBIPUSHToMethod(visitor, fmd.getFieldId());
if (enhancer.getClassMetaData().getPersistenceCapableSuperclass() != null) {
visitor.visitFieldInsn(
Opcodes.GETSTATIC,
getClassEnhancer().getASMClassName(),
getNamer().getInheritedFieldCountFieldName(),
"I");
visitor.visitInsn(Opcodes.IADD);
}
visitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/BitSet", "set", "(I)V");
}
visitor.visitLabel(l3);
if (JavaUtils.useStackMapFrames()) {
visitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
}
visitor.visitInsn(Opcodes.RETURN);
Label endLabel = new Label();
visitor.visitLabel(endLabel);
visitor.visitLocalVariable(
argNames[0], getClassEnhancer().getClassDescriptor(), null, startLabel, endLabel, 0);
visitor.visitLocalVariable(argNames[1], fieldTypeDesc, null, startLabel, endLabel, 1);
visitor.visitMaxs(5, 2);
visitor.visitEnd();
}
/**
* Accessor for the field name
*
* @return The field name
*/
public String getFieldName() {
return ownerMmd.getName();
}
/** Utility to mark the object as dirty */
public void makeDirty() {
if (ownerOP != null) {
ownerOP.makeDirty(ownerMmd.getAbsoluteFieldNumber());
}
}
public boolean useBackedSCOWrapperForMember(AbstractMemberMetaData mmd, ExecutionContext ec) {
// Use backed SCO wrapper on relation field (to support legacy), and use simple SCO wrapper on
// others
return (mmd.getRelationType(ec.getClassLoaderResolver()) == RelationType.NONE ? false : true);
}