/*******************************************************************************
* Copyright (c) 1998, 2010 Oracle, Frank Schwarz. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 11/23/2010-2.2 Frank Schwarz
* - 328774: TABLE_PER_CLASS-mapped key of a java.util.Map does not work for querying
******************************************************************************/
package org.eclipse.persistence.internal.queries;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import java.util.Map.Entry;
import java.lang.reflect.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.queries.DatabaseQuery;
import org.eclipse.persistence.queries.ReadAllQuery;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.security.PrivilegedMethodInvoker;
import org.eclipse.persistence.internal.security.PrivilegedGetValueFromField;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.internal.sessions.CollectionChangeRecord;
import org.eclipse.persistence.internal.sessions.MergeManager;
import org.eclipse.persistence.internal.sessions.ObjectChangeSet;
import org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet;
import org.eclipse.persistence.internal.sessions.UnitOfWorkImpl;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.changetracking.MapChangeEvent;
import org.eclipse.persistence.descriptors.changetracking.CollectionChangeEvent;
import org.eclipse.persistence.mappings.Association;
import org.eclipse.persistence.mappings.CollectionMapping;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.mappings.ForeignReferenceMapping;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.mappings.querykeys.QueryKey;
/**
* <p><b>Purpose</b>: A MapContainerPolicy is ContainerPolicy whose container class
* implements the Map interface.
* <p>
* <p><b>Responsibilities</b>:
* Provide the functionality to operate on an instance of a Map.
*
* @see ContainerPolicy
* @see CollectionContainerPolicy
*/
public class MapContainerPolicy extends InterfaceContainerPolicy {
/** The Method which is called on each value added to the Map and whose result is used as key to the value. */
protected String keyName;
protected String elementClassName;
protected Class elementClass;
protected transient Field keyField;
protected transient Method keyMethod;
/**
* INTERNAL:
* Construct a new policy.
*/
public MapContainerPolicy() {
super();
}
/**
* INTERNAL:
* Construct a new policy for the specified class.
*/
public MapContainerPolicy(Class containerClass) {
super(containerClass);
}
/**
* INTERNAL:
* Construct a new policy for the specified class name.
*/
public MapContainerPolicy(String containerClassName) {
super(containerClassName);
}
/**
* Prepare and validate.
* Set the element class.
*/
@Override
public void prepare(DatabaseQuery query, AbstractSession session) throws QueryException {
if ((getElementClass() == null) && (query.getDescriptor() != null)) {
setElementClass(query.getDescriptor().getJavaClass());
}
super.prepare(query, session);
}
/**
* INTERNAL:
* Add element to container.
* This is used to add to a collection independent of the collection type.
* The session may be required to wrap for the wrapper policy.
* Return whether the container changed.
*/
@Override
public boolean addInto(Object element, Object container, AbstractSession session){
if (element instanceof Map.Entry){
return addInto(((Map.Entry)element).getKey(), ((Map.Entry)element).getValue(), container, session);
} else {
return addInto(keyFrom(element, session), element, container, session);
}
}
/**
* INTERNAL:
* Add element into container which implements the Map interface.
*/
@Override
public boolean addInto(Object key, Object element, Object container, AbstractSession session) {
Object wrapped = element;
if (hasElementDescriptor()) {
wrapped = getElementDescriptor().getObjectBuilder().wrapObject(element, session);
}
try {
if (key != null) {
return ((Map)container).put(key, wrapped) != null;
} else if (isKeyAvailableFromElement()){
Object keyFromElement = keyFrom(element, session);
try {
Object result = ((Map)container).put(keyFromElement, wrapped);
return null != result;
} catch (NullPointerException e) {
// If the container Map is a concrete type that does not
// allow null keys then throw a QueryException. Note, a
// HashMap permits null keys.
if (keyFromElement == null) {
// TreeMap, HashTable, SortedMap do not permit null keys
throw QueryException.mapKeyIsNull(element, container);
} else {
// We got a null pointer exception for some other reason
// so re-throw the exception.
throw e;
}
}
} else {
throw QueryException.cannotAddElementWithoutKeyToMap(element);
}
} catch (ClassCastException ex1) {
throw QueryException.mapKeyNotComparable(key, container);
}
}
/**
* INTERNAL:
* This method is used to add the next value from an iterator built using ContainerPolicy's iteratorFor() method
* into the toCollection. Since this ContainerPolicy represents a Map, the key and the value are extracted and added.
*/
@Override
public void addNextValueFromIteratorInto(Object valuesIterator, Object parent, CacheKey parentCacheKey, Object toCollection, CollectionMapping mapping, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache) {
Map.Entry entry = ((MapContainerPolicyIterator)valuesIterator).next();
Object clonedKey = buildCloneForKey(entry.getKey(), parent, parentCacheKey, refreshCascade, cloningSession, isExisting, isFromSharedCache);
Object clonedValue = buildCloneForValue(entry.getValue(), parent, parentCacheKey, mapping, refreshCascade, cloningSession, isExisting, isFromSharedCache);
// add the object to the uow list of private owned objects if it is a candidate and the
// uow should discover new objects
if (cloningSession.isUnitOfWork() && mapping.isCandidateForPrivateOwnedRemoval() && ((UnitOfWorkImpl) cloningSession).shouldDiscoverNewObjects()) {
if (clonedValue != null && ((UnitOfWorkImpl) cloningSession).isCloneNewObject(clonedValue)) {
((UnitOfWorkImpl) cloningSession).addPrivateOwnedObject(mapping, clonedValue);
}
}
addInto(clonedKey, clonedValue, toCollection, cloningSession);
}
/**
* INTERNAL:
* Return an object representing an entry in the collection represented by this container policy
* This method will returns an Association containing the key and the value for a Map
*/
@Override
public Object buildCollectionEntry(Object objectAdded, ObjectChangeSet changeSet){
return new Association(changeSet.getNewKey(), objectAdded);
}
/**
* INTERNAL:
* This method will access the target relationship and create a list of information to rebuild the collection.
* For the MapContainerPolicy this return will consist of an array with serial Map entry key and value elements.
* @see ObjectReferenceMapping.buildReferencesPKList
* @see ContainerPolicy.buildReferencesPKList
*/
@Override
public Object[] buildReferencesPKList(Object container, AbstractSession session){
Object[] result = new Object[this.sizeFor(container)*2];
Iterator iterator = (Iterator)this.iteratorFor(container);
int index = 0;
while(iterator.hasNext()){
Map.Entry entry = (Entry) iterator.next();
result[index] = entry.getKey(); // record key for cases where it will be needed
++index;
result[index] = elementDescriptor.getObjectBuilder().extractPrimaryKeyFromObject(entry.getValue(), session);
++index;
}
return result;
}
/**
* INTERNAL:
* Ensure the new key is set for the change set for a new map object
*/
@Override
public void buildChangeSetForNewObjectInCollection(Object object, ClassDescriptor referenceDescriptor, UnitOfWorkChangeSet uowChangeSet, AbstractSession session){
Object value = ((Map.Entry)object).getValue();
ClassDescriptor valueDescriptor = referenceDescriptor;
if (value != null){
ClassDescriptor tempValueDescriptor = session.getDescriptor(value.getClass());
if (tempValueDescriptor != null){
valueDescriptor = tempValueDescriptor;
}
}
ObjectChangeSet changeSet = valueDescriptor.getObjectBuilder().createObjectChangeSet(value, uowChangeSet, session);
Object key = ((Map.Entry)object).getKey();
changeSet.setNewKey(key);
}
/**
* Build a clone for the value in a mapping.
*/
protected Object buildCloneForValue(Object value, Object parent, CacheKey parentCacheKey, CollectionMapping mapping, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache){
return mapping.buildElementClone(value, parent, parentCacheKey, refreshCascade, cloningSession, isExisting, isFromSharedCache);
}
/**
* INTERNAL:
* Remove all the elements from container.
*/
@Override
public void clear(Object container) {
try {
((Map)container).clear();
} catch (UnsupportedOperationException ex) {
throw QueryException.methodNotValid(container, "clear()");
}
}
/**
* INTERNAL:
* Return true if keys are the same in the source as the backup. False otherwise
* in the case of read-only compare against the original
*/
@Override
public boolean compareKeys(Object sourceValue, AbstractSession session) {
if (((UnitOfWorkImpl)session).isClassReadOnly(sourceValue.getClass())) {
return true;
}
Object backUpVersion = ((UnitOfWorkImpl)session).getBackupClone(sourceValue, getElementDescriptor());
Object backUpVersionKey = keyFrom(backUpVersion, session);
Object sourceValueKey = keyFrom(sourceValue, session);
if (backUpVersionKey == sourceValueKey) {
// this conditional captures the same instances, as well as both being nulls
// not sure if this semantics is correct
return true;
}
if (backUpVersionKey == null && sourceValueKey != null) {
return false;
}
return backUpVersionKey.equals(sourceValueKey);
}
/**
* INTERNAL:
* Build a new container, add the contents of each of the specified containers
* to it, and return it.
* Both of the containers must use the same container policy (namely, this one).
*/
@Override
public Object concatenateContainers(Object firstContainer, Object secondContainer, AbstractSession session) {
Object container = containerInstance(sizeFor(firstContainer) + sizeFor(secondContainer));
for (Object firstIter = iteratorFor(firstContainer); hasNext(firstIter);) {
Map.Entry<?, ?> entry = (Entry<?, ?>) nextEntry(firstIter);
addInto(entry.getKey(), entry.getValue(), container, session);
}
for (Object secondIter = iteratorFor(secondContainer); hasNext(secondIter);) {
Map.Entry<?, ?> entry = (Entry<?, ?>) nextEntry(secondIter);
addInto(entry.getKey(), entry.getValue(), container, session);
}
return container;
}
/**
* INTERNAL:
* Return the true if element exists in container.
* @return boolean true if container 'contains' element
*/
@Override
protected boolean contains(Object element, Object container) {
return ((Map)container).containsValue(element);
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this ContainerPolicy to
* actual class-based settings. This method is used when converting a
* project that has been built with class names to a project with classes.
* @param classLoader
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader){
super.convertClassNamesToClasses(classLoader);
if (elementClassName == null){
return;
}
try {
Class elementClass = null;
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
elementClass = (Class)AccessController.doPrivileged(new PrivilegedClassForName(elementClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(containerClassName, exception.getException());
}
} else {
elementClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(elementClassName, true, classLoader);
}
setElementClass(elementClass);
} catch (ClassNotFoundException exc){
throw ValidationException.classNotFoundWhileConvertingClassNames(containerClassName, exc);
}
}
/**
* INTERNAL:
* Creates a CollectionChangeEvent for the container
*/
@Override
public CollectionChangeEvent createChangeEvent(Object collectionOwner, String propertyName, Object collectionChanged, Object elementChanged, int changeType, Integer index, boolean isChangeApplied) {
if (elementChanged instanceof Map.Entry) {
return new MapChangeEvent(collectionOwner,propertyName, collectionChanged,
((Map.Entry)elementChanged).getKey(), ((Map.Entry)elementChanged).getValue(), changeType, isChangeApplied);
}
return super.createChangeEvent(collectionOwner, propertyName, collectionChanged, elementChanged, changeType, index, isChangeApplied);
}
/**
* INTERNAL:
* Create a query key that links to the map key. MapContainerPolicy does not have a specific mapping for the
* key, so return null.
*/
@Override
public QueryKey createQueryKeyForMapKey(){
return null;
}
/**
* INTERNAL:
* This method will actually potentially wrap an object in two ways. It will first wrap the object
* based on the referenceDescriptor's wrapper policy. It will also potentially do some wrapping based
* on what is required by the container policy.
*/
@Override
public Object createWrappedObjectFromExistingWrappedObject(Object wrappedObject, Object parent, ClassDescriptor referenceDescriptor, MergeManager mergeManager, AbstractSession targetSession){
Object key = ((Map.Entry)wrappedObject).getKey();
Object value = referenceDescriptor.getObjectBuilder().wrapObject(mergeManager.getTargetVersionOfSourceObject(unwrapIteratorResult(wrappedObject), referenceDescriptor, targetSession), mergeManager.getSession());
return new Association(key, value);
}
/**
* INTERNAL:
* Return the DatabaseField that represents the key in a DirectMapMapping. MapContainerPolicy gets it fields from the reference descriptor
* of the provided mappings. It uses its keyName to lookup the appropriate mapping and returns the field from
* that mapping.
*/
@Override
public DatabaseField getDirectKeyField(CollectionMapping baseMapping){
if (baseMapping == null){
return null;
}
ClassDescriptor descriptor = baseMapping.getReferenceDescriptor();
DatabaseMapping mapping = descriptor.getMappingForAttributeName(Helper.getAttributeNameFromMethodName(keyName));
if (mapping.isAbstractDirectMapping()){
return ((AbstractDirectMapping)mapping).getField();
}
return null;
}
/**
* INTERNAL:
* Returns the element class which defines the map key.
*/
public Class getElementClass() {
return elementClass;
}
/**
* INTERNAL:
* Returns the element class name which defines the map key.
*/
public String getElementClassName() {
return elementClassName;
}
/**
* INTERNAL:
*/
@Override
public Class getInterfaceType() {
return ClassConstants.Map_Class;
}
/**
* INTERNAL:
* Returns the key name which will return the value of the key to be used
* in the container.
*/
public String getKeyName() {
return keyName;
}
/**
* INTERNAL:
* Return the type of the map key, this will be overridden by container policies that allow maps.
*/
@Override
public Object getKeyType(){
initializeKey();
if (keyField != null){
return keyField.getType();
} else if (keyMethod != null){
return keyMethod.getReturnType();
}else if (elementDescriptor != null){
return elementDescriptor.getCMPPolicy().getPKClass();
}
return null;
}
/**
* INTERNAL
* Yes this is a MapPolicy
*/
@Override
public boolean isMapPolicy() {
return true;
}
/**
* MapContainerPolicy is for mappings where the key is stored in actual element.
*/
protected boolean isKeyAvailableFromElement() {
return true;
}
/**
* INTERNAL:
* Return whether a map key this container policy represents is an attribute.
*/
@Override
public boolean isMapKeyAttribute() {
if (elementDescriptor != null && keyName != null){
DatabaseMapping mapping = elementDescriptor.getMappingForAttributeName(Helper.getAttributeNameFromMethodName(keyName));
if (mapping != null) {
return mapping.isDirectToFieldMapping();
}
}
initializeKey();
if (keyField != null){
if (keyField.getClass().isPrimitive()){
return true;
}
} else if (keyMethod != null) {
if (keyMethod.getClass().isPrimitive()) {
return true;
}
}
return false;
}
/**
* INTERNAL:
* Return whether the iterator has more objects.
* The iterator is the one returned from #iteratorFor().
*
* @see ContainerPolicy#iteratorFor(java.lang.Object)
*/
@Override
public boolean hasNext(Object iterator) {
return ((MapContainerPolicyIterator)iterator).hasNext();
}
/**
* INTERNAL:
* Set the keyMethod or keyField based on the keyName.
*/
protected void initializeKey() {
// Should only run through this once ...
if (keyName != null && keyMethod == null && keyField == null) {
try {
keyMethod = Helper.getDeclaredMethod(elementClass, keyName, (Class[]) null);
} catch (NoSuchMethodException ex) {
try {
keyField = Helper.getField(elementClass, keyName);
} catch (NoSuchFieldException e) {
throw ValidationException.mapKeyNotDeclaredInItemClass(keyName, elementClass);
}
}
}
}
/**
* INTERNAL:
* Return an Iterator for the given container.
*/
@Override
public Object iteratorFor(Object container) {
return new MapContainerPolicyIterator((Map)container);
}
/**
* INTERNAL:
* Return the key for the specified element.
*/
@Override
public Object keyFrom(Object element, AbstractSession session) {
initializeKey();
Object keyElement = element;
if (hasElementDescriptor()) {
keyElement = getElementDescriptor().getObjectBuilder().unwrapObject(element, session);
}
if (keyMethod != null) {
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
return AccessController.doPrivileged(new PrivilegedMethodInvoker(keyMethod, keyElement, (Object[])null));
} catch (PrivilegedActionException exception) {
Exception throwableException = exception.getException();
if (throwableException instanceof IllegalAccessException) {
throw QueryException.cannotAccessMethodOnObject(keyMethod, keyElement);
} else {
throw QueryException.calledMethodThrewException(keyMethod, keyElement, throwableException);
}
}
} else {
return PrivilegedAccessHelper.invokeMethod(keyMethod, keyElement, (Object[])null);
}
} catch (IllegalAccessException e) {
throw QueryException.cannotAccessMethodOnObject(keyMethod, keyElement);
} catch (InvocationTargetException exception) {
throw QueryException.calledMethodThrewException(keyMethod, keyElement, exception);
}
} else if (keyField != null) {
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
return AccessController.doPrivileged(new PrivilegedGetValueFromField(keyField, keyElement));
} catch (PrivilegedActionException exception) {
throw QueryException.cannotAccessFieldOnObject(keyField, keyElement);
}
} else {
return org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getValueFromField(keyField, keyElement);
}
} catch (IllegalAccessException e) {
throw QueryException.cannotAccessFieldOnObject(keyField, keyElement);
}
} else {
// If we get this far I think it is safe to assume we have
// an element descriptor.
return getElementDescriptor().getCMPPolicy().createPrimaryKeyInstance(keyElement, session);
}
}
/**
* Get the key from the passed in Map.Entry.
*/
@Override
public Object keyFromEntry(Object entry){
if (entry instanceof Map.Entry){
return ((Map.Entry)entry).getKey();
}
return null;
}
@Override
public Object keyFromIterator(Object iterator){
return ((MapContainerPolicyIterator)iterator).getCurrentKey();
}
/**
* INTERNAL:
* Return the next object on the queue. The iterator is the one
* returned from #iteratorFor().
*
* @see ContainerPolicy#iteratorFor(java.lang.Object)
*/
@Override
protected Object next(Object iterator){
return ((MapContainerPolicyIterator)iterator).next().getValue();
}
/**
* INTERNAL:
* Return the next object on the queue. The iterator is the one
* returned from #iteratorFor().
*
* This will return a MapEntry to allow use of the key
*
* @see ContainerPolicy#iteratorFor(java.lang.Object)
* @see MapContainerPolicy.unwrapIteratorResult(Object object)
*/
@Override
public Object nextEntry(Object iterator){
return ((MapContainerPolicyIterator)iterator).next();
}
/**
* INTERNAL:
* Return the next object on the queue. The iterator is the one
* returned from #iteratorFor().
*
* This will return a MapEntry to allow use of the key
*
* @see ContainerPolicy#iteratorFor(Object iterator, AbstractSession session)
* @see MapContainerPolicy.unwrapIteratorResult(Object object)
*/
@Override
public Object nextEntry(Object iterator, AbstractSession session) {
Map.Entry next = (Map.Entry)nextEntry(iterator);
Object object = next.getValue();
if (hasElementDescriptor()) {
object = getElementDescriptor().getObjectBuilder().unwrapObject(object, session);
}
Object key = next.getKey();
key = unwrapKey(key, session);
next = new Association(key, object);
return next;
}
/**
* INTERNAL:
* MapContainerPolicy's iterator iterates on the Entries of a Map.
* This method returns the object from the iterator
*
* @see MapContainerPolicy.nextWrapped(Object iterator)
*/
@Override
public Object unwrapElement(Object object) {
if (object instanceof Association) {
return ((Association)object).getValue();
} else {
return object;
}
}
/**
* INTERNAL:
* MapContainerPolicy's iterator iterates on the Entries of a Map.
* This method returns the object from the iterator
*
* @see MapContainerPolicy.nextWrapped(Object iterator)
*/
@Override
public Object unwrapIteratorResult(Object object) {
if (object instanceof Map.Entry) {
return ((Map.Entry)object).getValue();
} else {
return object;
}
}
/**
* INTERNAL:
* Allow the key to be unwrapped. This will be overridden by container policies that
* allow keys that are entities.
*/
public Object unwrapKey(Object key, AbstractSession session) {
return key;
}
/**
* This method is used to bridge the behavior between Attribute Change Tracking and
* deferred change tracking with respect to adding the same instance multiple times.
* Each ContainerPolicy type will implement specific behavior for the collection
* type it is wrapping. These methods are only valid for collections containing object references
*/
@Override
public void recordUpdateToCollectionInChangeRecord(CollectionChangeEvent event, ObjectChangeSet changeSet, CollectionChangeRecord collectionChangeRecord){
Object key = null;
//This is to allow non-MapChangeEvent. Not sure how one could get here, but wasn't willing to remove the chance that it could
if (event.getClass().equals(ClassConstants.MapChangeEvent_Class)){
key = ((MapChangeEvent)event).getKey();
}
if (event.getChangeType() == CollectionChangeEvent.ADD) {
recordAddToCollectionInChangeRecord(changeSet, collectionChangeRecord);
changeSet.setNewKey(key);
} else if (event.getChangeType() == CollectionChangeEvent.REMOVE) {
recordRemoveFromCollectionInChangeRecord(changeSet, collectionChangeRecord);
changeSet.setOldKey(key);
} else {
throw ValidationException.wrongCollectionChangeEventType(event.getChangeType());
}
}
/**
* INTERNAL:
* Remove element from container which implements the Map interface.
*/
@Override
public boolean removeFrom(Object key, Object element, Object container, AbstractSession session) {
try {
Object returnValue = null;
if (key != null) {
returnValue = ((Map)container).remove(key);
} else if (element != null) {
returnValue = ((Map)container).remove(keyFrom(element, session));
}
if (returnValue == null) {
return false;
} else {
return true;
}
} catch (UnsupportedOperationException ex) {
throw QueryException.methodNotValid(container, "remove(Object element)");
}
}
/**
* INTERNAL:
* Sets the element class which defines the method.
*/
public void setElementClass(Class elementClass) {
if (elementClass != null) {
elementClassName = elementClass.getName();
}
this.elementClass = elementClass;
}
/**
* INTERNAL:
* Validate the container type.
*/
@Override
public boolean isValidContainer(Object container) {
// PERF: Use instanceof which is inlined, not isAssignable which is very inefficient.
return container instanceof Map;
}
/**
* INTERNAL:
* Sets the key name to be used to generate the key in a Map type container
* class. The key name, may be the name of a field or method.
*/
public void setKeyName(String keyName, String elementClassName) {
// The key name and class name must be held as the policy is used
// directly from the mapping.
this.keyName = keyName;
this.elementClassName = elementClassName;
}
/**
* INTERNAL:
* Sets the key name to be used to generate the key in a Map type container
* class. The key name, may be the name of a field or method.
* An instance of the class is provided in the case when the descriptor is being
* built in code.
*/
public void setKeyName(String keyName, Class elementClass) {
// The key name and class name must be held as the policy is used
// directly from the mapping.
this.keyName = keyName;
this.elementClass = elementClass;
}
/**
* INTERNAL:
* Sets the key name to be used to generate the key in a Map type container
* class. The key name, maybe the name of a field or method.
*/
public void setKeyName(String keyName) {
this.keyName = keyName;
}
/**
* INTERNAL:
* Sets the Method to be used to generate the key in a Map type container class.
*/
public void setKeyMethod(String keyMethodName, Class elementClass) {
this.setKeyName(keyMethodName, elementClass);
}
/**
* INTERNAL:
* Sets the Method to be used to generate the key in a Map type container class.
*/
public void setKeyMethod(String keyMethodName, String elementClassName) {
this.setKeyName(keyMethodName, elementClassName);
}
/**
* INTERNAL:
* Sets the Method to be used to generate the key in a Map type container class.
*/
public void setKeyMethodName(String keyMethodName) {
this.setKeyName(keyMethodName);
}
/**
* INTERNAL:
* Return the size of container.
*/
@Override
public int sizeFor(Object container) {
return ((Map)container).size();
}
/**
* INTERNAL:
* This method is used to load a relationship from a list of PKs. This list
* may be available if the relationship has been cached.
*/
public Object valueFromPKList(Object[] pks, AbstractRecord foreignKeys, ForeignReferenceMapping mapping, AbstractSession session){
// pks contains both keys and values, but only values are required because keys could be obtained from corresponding values.
Object[] pksOnly = new Object[pks.length / 2];
for (int i=0; i<pks.length/2; i++) {
pksOnly[i] = pks[2*i + 1];
}
return super.valueFromPKList(pksOnly, foreignKeys, mapping, session);
}
/**
* INTERNAL:
* This inner class is used to iterate through the Map.Entry s of a Map.
* It maintains a pointer to the current entry to allow access to the key and the value.
* @author tware
*/
public static class MapContainerPolicyIterator implements Iterator {
private Iterator iterator;
private Map.Entry currentEntry;
public MapContainerPolicyIterator(Map container) {
this.iterator = container.entrySet().iterator();
}
public boolean hasNext() {
return iterator.hasNext();
}
public Map.Entry next() {
currentEntry = (Map.Entry)iterator.next();
return currentEntry;
}
public Object getCurrentKey() {
if (currentEntry != null) {
return currentEntry.getKey();
}
return null;
}
public Object getCurrentValue() {
if (currentEntry != null) {
return currentEntry.getValue();
}
return null;
}
public void remove() {
this.iterator.remove();
}
}
}