001    /*
002     * Cumulus4j - Securing your data in the cloud - http://cumulus4j.org
003     * Copyright (C) 2011 NightLabs Consulting GmbH
004     *
005     * This program is free software: you can redistribute it and/or modify
006     * it under the terms of the GNU Affero General Public License as
007     * published by the Free Software Foundation, either version 3 of the
008     * License, or (at your option) any later version.
009     *
010     * This program is distributed in the hope that it will be useful,
011     * but WITHOUT ANY WARRANTY; without even the implied warranty of
012     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013     * GNU Affero General Public License for more details.
014     *
015     * You should have received a copy of the GNU Affero General Public License
016     * along with this program.  If not, see <http://www.gnu.org/licenses/>.
017     */
018    package org.cumulus4j.store.fieldmanager;
019    
020    import java.lang.reflect.Array;
021    import java.util.ArrayList;
022    import java.util.Collection;
023    import java.util.Collections;
024    import java.util.HashSet;
025    import java.util.Iterator;
026    import java.util.List;
027    import java.util.Map;
028    import java.util.Set;
029    
030    import javax.jdo.PersistenceManager;
031    import javax.jdo.spi.JDOImplHelper;
032    import javax.jdo.spi.PersistenceCapable;
033    
034    import org.cumulus4j.store.Cumulus4jStoreManager;
035    import org.cumulus4j.store.EncryptionHandler;
036    import org.cumulus4j.store.ObjectContainerHelper;
037    import org.cumulus4j.store.crypto.CryptoContext;
038    import org.cumulus4j.store.model.ClassMeta;
039    import org.cumulus4j.store.model.DataEntryDAO;
040    import org.cumulus4j.store.model.EmbeddedObjectContainer;
041    import org.cumulus4j.store.model.FieldMeta;
042    import org.cumulus4j.store.model.FieldMetaRole;
043    import org.cumulus4j.store.model.IndexEntry;
044    import org.cumulus4j.store.model.IndexEntryObjectRelationHelper;
045    import org.cumulus4j.store.model.IndexValue;
046    import org.cumulus4j.store.model.ObjectContainer;
047    import org.datanucleus.exceptions.NucleusDataStoreException;
048    import org.datanucleus.identity.IdentityUtils;
049    import org.datanucleus.metadata.AbstractClassMetaData;
050    import org.datanucleus.metadata.AbstractMemberMetaData;
051    import org.datanucleus.metadata.Relation;
052    import org.datanucleus.state.ObjectProviderFactory;
053    import org.datanucleus.store.ExecutionContext;
054    import org.datanucleus.store.ObjectProvider;
055    import org.datanucleus.store.fieldmanager.AbstractFieldManager;
056    import org.datanucleus.store.types.sco.SCOUtils;
057    
058    /**
059     * Manager for the process of fetching a user object from the datastore, handling the translation from the
060     * DataEntry object into the users own object.
061     * @author Marco หงุ่ยตระกูล-Schulze - marco at nightlabs dot de
062     */
063    public class FetchFieldManager extends AbstractFieldManager
064    {
065            private ObjectProvider op;
066            private CryptoContext cryptoContext;
067            private PersistenceManager pmData;
068            private PersistenceManager pmIndex;
069            private ExecutionContext ec;
070            private ClassMeta classMeta;
071            private AbstractClassMetaData dnClassMetaData;
072            private ObjectContainer objectContainer;
073    
074            public FetchFieldManager(
075                            ObjectProvider op,
076                            CryptoContext cryptoContext,
077                            ClassMeta classMeta,
078                            AbstractClassMetaData dnClassMetaData,
079                            ObjectContainer objectContainer
080            )
081            {
082                    if (op == null)
083                            throw new IllegalArgumentException("op == null");
084                    if (cryptoContext == null)
085                            throw new IllegalArgumentException("cryptoContext == null");
086                    if (classMeta == null)
087                            throw new IllegalArgumentException("classMeta == null");
088                    if (dnClassMetaData == null)
089                            throw new IllegalArgumentException("dnClassMetaData == null");
090                    if (objectContainer == null)
091                            throw new IllegalArgumentException("objectContainer == null");
092    
093                    this.op = op;
094                    this.cryptoContext = cryptoContext;
095                    this.pmData = cryptoContext.getPersistenceManagerForData();
096                    this.pmIndex = cryptoContext.getPersistenceManagerForIndex();
097                    this.ec = op.getExecutionContext();
098                    this.classMeta = classMeta;
099                    this.dnClassMetaData = dnClassMetaData;
100                    this.objectContainer = objectContainer;
101            }
102    
103            protected EncryptionHandler getEncryptionHandler()
104            {
105                    return ((Cumulus4jStoreManager) ec.getStoreManager()).getEncryptionHandler();
106            }
107    
108            private long getFieldID(int fieldNumber)
109            {
110                    AbstractMemberMetaData mmd = dnClassMetaData.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
111    
112                    FieldMeta fieldMeta = classMeta.getFieldMeta(mmd.getClassName(), mmd.getName());
113                    if (fieldMeta == null)
114                            throw new IllegalStateException("Unknown field! class=" + dnClassMetaData.getFullClassName() + " fieldNumber=" + fieldNumber + " fieldName=" + mmd.getName());
115    
116                    return fieldMeta.getFieldID();
117            }
118    
119            @Override
120            public boolean fetchBooleanField(int fieldNumber) {
121                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
122                    return value == null ? false : (Boolean)value;
123            }
124    
125            @Override
126            public byte fetchByteField(int fieldNumber) {
127                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
128                    return value == null ? 0 : (Byte)value;
129            }
130    
131            @Override
132            public char fetchCharField(int fieldNumber) {
133                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
134                    return value == null ? 0 : (Character)value;
135            }
136    
137            @Override
138            public double fetchDoubleField(int fieldNumber) {
139                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
140                    return value == null ? 0 : (Double)value;
141            }
142    
143            @Override
144            public float fetchFloatField(int fieldNumber) {
145                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
146                    return value == null ? 0 : (Float)value;
147            }
148    
149            @Override
150            public int fetchIntField(int fieldNumber) {
151                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
152                    return value == null ? 0 : (Integer)value;
153            }
154    
155            @Override
156            public long fetchLongField(int fieldNumber) {
157                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
158                    return value == null ? 0 : (Long)value;
159            }
160    
161            @Override
162            public short fetchShortField(int fieldNumber) {
163                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
164                    return value == null ? 0 : (Short)value;
165            }
166    
167            @Override
168            public String fetchStringField(int fieldNumber) {
169                    Object value = objectContainer.getValue(getFieldID(fieldNumber));
170                    return (String)value;
171            }
172    
173            private long thisDataEntryID = -1;
174    
175            protected long getThisDataEntryID()
176            {
177                    if (thisDataEntryID < 0)
178                            thisDataEntryID = new DataEntryDAO(pmData, cryptoContext.getKeyStoreRefID()).getDataEntryID(classMeta, op.getObjectId().toString());
179    
180                    return thisDataEntryID;
181            }
182    
183            @Override
184            public Object fetchObjectField(int fieldNumber)
185            {
186                    AbstractMemberMetaData mmd = dnClassMetaData.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
187                    FieldMeta fieldMeta = classMeta.getFieldMeta(mmd.getClassName(), mmd.getName());
188                    if (fieldMeta == null)
189                            throw new IllegalStateException("Unknown field! class=" + dnClassMetaData.getFullClassName() + " fieldNumber=" + fieldNumber + " fieldName=" + mmd.getName());
190    
191                    Set<Long> mappedByDataEntryIDs = null;
192                    if (mmd.getMappedBy() != null) {
193                            ClassMeta fieldOrElementTypeClassMeta = fieldMeta.getFieldOrElementTypeClassMeta(ec);
194    
195    //                      IndexEntry indexEntry = IndexEntryObjectRelationHelper.getIndexEntry(cryptoContext, pmIndex, fieldMeta.getMappedByFieldMeta(ec), classMeta, getThisDataEntryID());
196                            List<IndexEntry> indexEntries = IndexEntryObjectRelationHelper.getIndexEntriesIncludingSubClasses(cryptoContext, pmIndex, fieldMeta.getMappedByFieldMeta(ec), fieldOrElementTypeClassMeta, getThisDataEntryID());
197                            if (indexEntries.isEmpty())
198                                    mappedByDataEntryIDs = Collections.emptySet();
199                            else {
200                                    for (IndexEntry indexEntry : indexEntries) {
201                                            IndexValue indexValue = getEncryptionHandler().decryptIndexEntry(cryptoContext, indexEntry);
202                                            if (mappedByDataEntryIDs == null)
203                                                    mappedByDataEntryIDs = new HashSet<Long>(indexValue.getDataEntryIDs());
204                                            else
205                                                    mappedByDataEntryIDs.addAll(indexValue.getDataEntryIDs());
206                                    }
207                            }
208                    }
209    
210                    int relationType = mmd.getRelationType(ec.getClassLoaderResolver());
211    
212                    if (relationType == Relation.NONE)
213                            return fetchObjectFieldWithRelationTypeNone(fieldNumber, mmd, fieldMeta);
214                    else if (Relation.isRelationSingleValued(relationType))
215                            return fetchObjectFieldWithRelationTypeSingleValue(fieldNumber, mmd, fieldMeta, mappedByDataEntryIDs);
216                    else if (Relation.isRelationMultiValued(relationType))
217                    {
218                            // Collection/Map/Array
219                            if (mmd.hasCollection())
220                                    return fetchObjectFieldWithRelationTypeCollection(fieldNumber, mmd, fieldMeta, mappedByDataEntryIDs);
221                            else if (mmd.hasMap())
222                                    return fetchObjectFieldWithRelationTypeMap(fieldNumber, mmd, fieldMeta, mappedByDataEntryIDs);
223                            else if (mmd.hasArray())
224                                    return fetchObjectFieldWithRelationTypeArray(fieldNumber, mmd, fieldMeta, mappedByDataEntryIDs);
225                            else
226                                    throw new IllegalStateException("Unexpected multi-valued relationType: " + relationType);
227                    }
228                    else
229                            throw new IllegalStateException("Unexpected relationType: " + relationType);
230            }
231    
232            /**
233             * Fetch related objects that are not persistence-capable.
234             * The related objects might be single-valued, arrays, collections or maps.
235             */
236            protected Object fetchObjectFieldWithRelationTypeNone(int fieldNumber, AbstractMemberMetaData mmd, FieldMeta fieldMeta)
237            {
238                    if (mmd.hasCollection())
239                    {
240                            Collection<Object> collection;
241                            @SuppressWarnings("unchecked")
242                            Class<? extends Collection<Object>> instanceType = SCOUtils.getContainerInstanceType(mmd.getType(), mmd.getOrderMetaData() != null);
243                            try {
244                                    collection = instanceType.newInstance();
245                            } catch (InstantiationException e) {
246                                    throw new NucleusDataStoreException(e.getMessage(), e);
247                            } catch (IllegalAccessException e) {
248                                    throw new NucleusDataStoreException(e.getMessage(), e);
249                            }
250    
251                            Object array = objectContainer.getValue(fieldMeta.getFieldID());
252                            if (array != null) {
253                                    for (int idx = 0; idx < Array.getLength(array); ++idx) {
254                                            Object element = Array.get(array, idx);
255                                            collection.add(element);
256                                    }
257                            }
258                            return op.wrapSCOField(fieldNumber, collection, false, false, true);
259                    }
260    
261                    if (mmd.hasMap())
262                    {
263                            Map<?,?> map = (Map<?,?>) objectContainer.getValue(fieldMeta.getFieldID());
264                            return op.wrapSCOField(fieldNumber, map, false, false, true);
265                    }
266    
267                    // Arrays are stored 'as is', thus no conversion necessary.
268                    return objectContainer.getValue(getFieldID(fieldNumber));
269            }
270    
271            /**
272             * Fetch a single related object (1-1-relationship).
273             * The related object is persistence-capable.
274             */
275            protected Object fetchObjectFieldWithRelationTypeSingleValue(int fieldNumber, AbstractMemberMetaData mmd, FieldMeta fieldMeta, Set<Long> mappedByDataEntryIDs)
276            {
277                    if (mmd.isEmbedded()) {
278                            Object value = objectContainer.getValue(fieldMeta.getFieldID());
279                            if (value == null)
280                                    return null;
281    
282                            if (!(value instanceof EmbeddedObjectContainer))
283                                    throw new IllegalStateException("field claims to be embedded, but persistent field value is not an EmbeddedObjectContainer! fieldID=" + fieldMeta.getFieldID() + " fieldName=" + fieldMeta.getFieldName() + " value=" + value);
284    
285                            EmbeddedObjectContainer embeddedObjectContainer = (EmbeddedObjectContainer) value;
286                            ClassMeta embeddedClassMeta = fieldMeta.getEmbeddedClassMeta();
287                            return createPCFromEmbeddedObjectContainer(fieldNumber, fieldMeta, embeddedClassMeta, embeddedObjectContainer);
288                    }
289                    else {
290                            if (mmd.getMappedBy() != null) {
291                                    if (mappedByDataEntryIDs.isEmpty())
292                                            return null;
293    
294                                    if (mappedByDataEntryIDs.size() != 1)
295                                            throw new IllegalStateException("There are multiple objects referencing a 1-1-mapped-by-relationship! Expected 0 or 1! fieldMeta=" + fieldMeta + " dataEntryIDsForMappedBy=" + mappedByDataEntryIDs);
296    
297                                    long dataEntryID = mappedByDataEntryIDs.iterator().next();
298                                    return getObjectFromDataEntryID(dataEntryID);
299                            }
300    
301                            Object valueID = objectContainer.getValue(fieldMeta.getFieldID());
302                            return ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, valueID);
303                    }
304            }
305    
306            protected Object createPCFromEmbeddedObjectContainer(int fieldNumber, FieldMeta fieldMeta, ClassMeta embeddedClassMeta, EmbeddedObjectContainer embeddedObjectContainer)
307            {
308                    if (fieldMeta == null)
309                            throw new IllegalArgumentException("fieldMeta == null");
310                    if (embeddedClassMeta == null)
311                            throw new IllegalArgumentException("embeddedClassMeta == null");
312    
313                    if (embeddedObjectContainer == null) // we allow null values in embedded lists - or shouldn't we?
314                            return null;
315    
316                    // TODO the newest DN version has a StateManagerFactory that makes the following more convenient (I think) - maybe switch later?!
317    //              ClassMeta embeddedClassMeta = ((Cumulus4jStoreManager)ec.getStoreManager()).getClassMeta(ec, embeddedObjectContainer.getClassID(), true);
318    //              ClassMeta embeddedClassMeta = fieldMeta.getEmbeddedClassMeta();
319                    Class<?> embeddedClass = ec.getClassLoaderResolver().classForName(embeddedClassMeta.getClassName());
320    
321                    AbstractClassMetaData embeddedDNClassMeta = embeddedClassMeta.getDataNucleusClassMetaData(ec);
322                    PersistenceCapable pc = JDOImplHelper.getInstance().newInstance(embeddedClass, null);
323    
324                    ObjectProvider embeddedOP = ObjectProviderFactory.newForEmbedded(ec, pc, false, op, fieldNumber);
325                    embeddedOP.replaceFields(
326                                    embeddedDNClassMeta.getAllMemberPositions(),
327                                    new FetchFieldManager(embeddedOP, cryptoContext, embeddedClassMeta, embeddedDNClassMeta, embeddedObjectContainer)
328                    );
329                    return embeddedOP.getObject();
330            }
331    
332            /**
333             * Fetch an array of related objects (1-n-relationship).
334             * The related objects are persistence-capable.
335             */
336            protected Object fetchObjectFieldWithRelationTypeArray(int fieldNumber, AbstractMemberMetaData mmd, FieldMeta fieldMeta, Set<Long> mappedByDataEntryIDs)
337            {
338                    Class<?> elementType = ec.getClassLoaderResolver().classForName(mmd.getArray().getElementType());
339    
340                    Object array;
341    
342                    if (mmd.getArray().isEmbeddedElement()) {
343                            Object value = objectContainer.getValue(fieldMeta.getFieldID());
344                            if (!(value instanceof EmbeddedObjectContainer[]))
345                                    throw new IllegalStateException("field claims to be embedded, but persistent field value is not an array of EmbeddedObjectContainer! fieldID=" + fieldMeta.getFieldID() + " fieldName=" + fieldMeta.getFieldName() + " value=" + value);
346    
347                            EmbeddedObjectContainer[] embeddedObjectContainers = (EmbeddedObjectContainer[]) value;
348                            int arrayLength = embeddedObjectContainers.length;
349                            array = Array.newInstance(elementType, arrayLength);
350                            ClassMeta embeddedClassMeta = fieldMeta.getSubFieldMeta(FieldMetaRole.arrayElement).getEmbeddedClassMeta();
351                            for (int i = 0; i < arrayLength; ++i) {
352                                    Object pc = createPCFromEmbeddedObjectContainer(fieldNumber, fieldMeta, embeddedClassMeta, embeddedObjectContainers[i]);
353                                    Array.set(array, i, pc);
354                            }
355                    }
356                    else {
357                            if (mmd.getMappedBy() != null) {
358                                    int arrayLength = mappedByDataEntryIDs.size();
359                                    array = Array.newInstance(elementType, arrayLength);
360                                    Iterator<Long> it = mappedByDataEntryIDs.iterator();
361                                    for (int i = 0; i < arrayLength; ++i) {
362                                            Long dataEntryID = it.next();
363                                            Object element = getObjectFromDataEntryID(dataEntryID);
364                                            Array.set(array, i, element);
365                                    }
366                            }
367                            else {
368                                    Object ids = objectContainer.getValue(fieldMeta.getFieldID());
369                                    if (ids == null)
370                                            array = null;
371                                    else {
372                                            if (ec.getStoreManager().getPersistenceHandler().useReferentialIntegrity()) {
373                                                    // Directly fill the array.
374                                                    int arrayLength = Array.getLength(ids);
375                                                    array = Array.newInstance(elementType, arrayLength);
376                                                    for (int i = 0; i < arrayLength; ++i) {
377                                                            Object id = Array.get(ids, i);
378                                                            Object element = ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, id);
379                                                            Array.set(array, i, element);
380                                                    }
381                                            }
382                                            else {
383                                                    // https://sourceforge.net/tracker/?func=detail&aid=3515529&group_id=517465&atid=2102914
384                                                    // First fill a list and then transfer everything into an array, because there might
385                                                    // be elements missing (orphaned references).
386                                                    int arrayLength = Array.getLength(ids);
387                                                    ArrayList<Object> tmpList = new ArrayList<Object>();
388                                                    for (int i = 0; i < arrayLength; ++i) {
389                                                            Object id = Array.get(ids, i);
390                                                            Object element = ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, id);
391                                                            if (element != null)
392                                                                    tmpList.add(element);
393                                                    }
394                                                    array = Array.newInstance(elementType, tmpList.size());
395                                                    array = tmpList.toArray((Object[]) array);
396                                            }
397                                    }
398                            }
399                    }
400    
401                    return array;
402            }
403    
404            /**
405             * Fetch a {@link Collection} (<code>List</code>, <code>Set</code>, etc.) of
406             * related objects (1-n-relationship).
407             * The related objects are persistence-capable.
408             */
409            protected Object fetchObjectFieldWithRelationTypeCollection(int fieldNumber, AbstractMemberMetaData mmd, FieldMeta fieldMeta, Set<Long> mappedByDataEntryIDs) {
410                    Collection<Object> collection;
411                    @SuppressWarnings("unchecked")
412                    Class<? extends Collection<Object>> instanceType = SCOUtils.getContainerInstanceType(mmd.getType(), mmd.getOrderMetaData() != null);
413                    try {
414                            collection = instanceType.newInstance();
415                    } catch (InstantiationException e) {
416                            throw new NucleusDataStoreException(e.getMessage(), e);
417                    } catch (IllegalAccessException e) {
418                            throw new NucleusDataStoreException(e.getMessage(), e);
419                    }
420    
421                    if (mmd.getCollection().isEmbeddedElement()) {
422                            Object value = objectContainer.getValue(fieldMeta.getFieldID());
423                            if (!(value instanceof EmbeddedObjectContainer[]))
424                                    throw new IllegalStateException("field claims to be embedded, but persistent field value is not an array of EmbeddedObjectContainer! fieldID=" + fieldMeta.getFieldID() + " fieldName=" + fieldMeta.getFieldName() + " value=" + value);
425    
426                            EmbeddedObjectContainer[] embeddedObjectContainers = (EmbeddedObjectContainer[]) value;
427                            ClassMeta embeddedClassMeta = fieldMeta.getSubFieldMeta(FieldMetaRole.collectionElement).getEmbeddedClassMeta();
428                            for (EmbeddedObjectContainer embeddedObjectContainer : embeddedObjectContainers) {
429                                    Object pc = createPCFromEmbeddedObjectContainer(fieldNumber, fieldMeta, embeddedClassMeta, embeddedObjectContainer);
430                                    collection.add(pc);
431                            }
432                    }
433                    else {
434                            if (mmd.getMappedBy() != null) {
435                                    for (Long mappedByDataEntryID : mappedByDataEntryIDs) {
436                                            Object element = getObjectFromDataEntryID(mappedByDataEntryID);
437                                            collection.add(element);
438                                    }
439                            }
440                            else {
441                                    Object ids = objectContainer.getValue(fieldMeta.getFieldID());
442                                    if (ids != null) {
443                                            for (int idx = 0; idx < Array.getLength(ids); ++idx) {
444                                                    Object id = Array.get(ids, idx);
445                                                    Object element = ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, id);
446                                                    if (element != null) // orphaned reference - https://sourceforge.net/tracker/?func=detail&aid=3515529&group_id=517465&atid=2102914
447                                                            collection.add(element);
448                                            }
449                                    }
450                            }
451                    }
452    
453                    return op.wrapSCOField(fieldNumber, collection, false, false, true);
454            }
455    
456            /**
457             * Fetch a {@link Map} of related objects (1-n-relationship).
458             * The related objects are persistence-capable.
459             */
460            protected Object fetchObjectFieldWithRelationTypeMap(int fieldNumber, AbstractMemberMetaData mmd, FieldMeta fieldMeta, Set<Long> mappedByDataEntryIDs)
461            {
462                    Map<Object, Object> map;
463                    @SuppressWarnings("unchecked")
464                    Class<? extends Map<Object, Object>> instanceType = SCOUtils.getContainerInstanceType(mmd.getType(), mmd.getOrderMetaData() != null);
465                    try {
466                            map = instanceType.newInstance();
467                    } catch (InstantiationException e) {
468                            throw new NucleusDataStoreException(e.getMessage(), e);
469                    } catch (IllegalAccessException e) {
470                            throw new NucleusDataStoreException(e.getMessage(), e);
471                    }
472    
473                    boolean keyIsPersistent = mmd.getMap().keyIsPersistent();
474                    boolean valueIsPersistent = mmd.getMap().valueIsPersistent();
475    
476                    if (mmd.getMappedBy() != null) {
477                            FieldMeta oppositeFieldMetaKey = fieldMeta.getSubFieldMeta(FieldMetaRole.mapKey).getMappedByFieldMeta(ec);
478                            FieldMeta oppositeFieldMetaValue = fieldMeta.getSubFieldMeta(FieldMetaRole.mapValue).getMappedByFieldMeta(ec);
479    
480                            for (Long mappedByDataEntryID : mappedByDataEntryIDs) {
481                                    Object element = getObjectFromDataEntryID(mappedByDataEntryID);
482                                    ObjectProvider elementOP = ec.findObjectProvider(element);
483                                    if (elementOP == null)
484                                            throw new IllegalStateException("executionContext.findObjectProvider(element) returned null for " + element);
485    
486                                    Object key;
487                                    if (keyIsPersistent)
488                                            key = element;
489                                    else
490                                            key = elementOP.provideField(oppositeFieldMetaKey.getDataNucleusAbsoluteFieldNumber(ec));
491    
492                                    Object value;
493                                    if (valueIsPersistent)
494                                            value = element;
495                                    else
496                                            value = elementOP.provideField(oppositeFieldMetaValue.getDataNucleusAbsoluteFieldNumber(ec));
497    
498                                    map.put(key, value);
499                            }
500                    }
501                    else {
502                            Map<?,?> idMap = (Map<?,?>) objectContainer.getValue(fieldMeta.getFieldID());
503                            if (idMap != null) {
504                                    for (Map.Entry<?, ?> me : idMap.entrySet()) {
505                                            Object k = me.getKey();
506                                            Object v = me.getValue();
507    
508                                            if (keyIsPersistent) {
509                                                    k = ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, k);
510                                                    if (k == null) // orphaned reference - https://sourceforge.net/tracker/?func=detail&aid=3515529&group_id=517465&atid=2102914
511                                                            continue;
512                                            }
513    
514                                            if (valueIsPersistent) {
515                                                    v = ObjectContainerHelper.referenceToEntity(cryptoContext, pmData, v);
516                                                    if (v == null) // orphaned reference - https://sourceforge.net/tracker/?func=detail&aid=3515529&group_id=517465&atid=2102914
517                                                            continue;
518                                            }
519    
520                                            map.put(k, v);
521                                    }
522                            }
523                    }
524    
525                    return op.wrapSCOField(fieldNumber, map, false, false, true);
526            }
527    
528            protected Object getObjectFromDataEntryID(long dataEntryID)
529            {
530                    String idStr = new DataEntryDAO(pmData, cryptoContext.getKeyStoreRefID()).getDataEntry(dataEntryID).getObjectID();
531                    return IdentityUtils.getObjectFromIdString(
532                                    idStr, classMeta.getDataNucleusClassMetaData(ec), ec, true
533                    );
534            }
535    }