Gets a map of unsafe result elements, ie. elements that cannot be saved
because serialization fails.

@return
12563
public Map<ComponentJob, AnalyzerResult> getUnsafeResultElements() {
        if (_unsafeResultElements == null) {
            _unsafeResultElements = new LinkedHashMap<>();
            final Map<ComponentJob, AnalyzerResult> resultMap = _analysisResult.getResultMap();
            for (final Entry<ComponentJob, AnalyzerResult> entry : resultMap.entrySet()) {
                final AnalyzerResult analyzerResult = entry.getValue();
                try {
                    SerializationUtils.serialize(analyzerResult, new NullOutputStream());
                } catch (final SerializationException e) {
                    _unsafeResultElements.put(entry.getKey(), analyzerResult);
                }
            }
        }
        return _unsafeResultElements;
    }
318567
public Map<String, String> getValueMap() {
        if (tokensMap == null) {
            return null;
        }
        if (tokensMap.isEmpty()) {
            return new LinkedHashMap<>();
        } else {
            Map<String, String> map = new LinkedHashMap<>(tokensMap.size());
            for (Map.Entry<String, Token[]> entry : tokensMap.entrySet()) {
                map.put(entry.getKey(), TokenParser.toString(entry.getValue()));
            }
            return map;
        }
    }
76125
public Map<String, Object> getData() {
        TypeToken<Map<String, Object>> typeToken = new TypeToken<Map<String, Object>>() {};
        return getData(typeToken);
    }
671575
public Iterator<JrsValue> elements() {
        if (_values.isEmpty()) { // fine, nothing that could be removed anyway
            return _values.iterator();
        }
        // ensure caller can not modify values this way
        return Collections.unmodifiableList(_values).iterator();            
    }
944812
public Map<String,String> getMappings(){
		
		HashMap<String, String> mappings      = new HashMap<String, String> ();
		HashMap<String, Boolean> destInstance = new HashMap<String, Boolean>();
		
		String s = "V";
		
		destInstance.put("null", true  );
		destInstance.put("v"   , false );
		
		HashMap<String, NullPointerControl> nullPointer = new HashMap<String, NullPointerControl>();
		
		nullPointer.put("Not", NOT_ANY     );
		nullPointer.put("All", ALL         );
		nullPointer.put("Des", DESTINATION );
		nullPointer.put("Sou", SOURCE      );
		
		HashMap<String, MappingType> mapping = new HashMap<String, MappingType>();		
		
		mapping.put("All"   , ALL_FIELDS         );
		mapping.put("Valued", ONLY_VALUED_FIELDS );
		mapping.put("Null"  , ONLY_NULL_FIELDS   );
		
		java.lang.reflect.Method[] methods = IMapper.class.getDeclaredMethods();
		
		for (Entry<String, Boolean> d : destInstance.entrySet()) 
			for (Entry<String, NullPointerControl> npc : nullPointer.entrySet()) 
				for (Entry<String, MappingType> mtd : mapping.entrySet()) 
					for (Entry<String, MappingType> mts : mapping.entrySet()) {
						String methodName = d.getKey()+s+npc.getKey()+mtd.getKey()+mts.getKey();
						for (java.lang.reflect.Method method : methods) 
							if(method.getName().equals(methodName))
								mappings.put(methodName, wrappedMapping(d.getValue(),npc.getValue(),mtd.getValue(),mts.getValue()));}
		
		mappings.put("get", "return null;"+newLine);
		return mappings;
	}
404314
public java.util.List<ResultAttribute> getResultAttributes() {
        if (resultAttributes == null) {
            resultAttributes = new com.amazonaws.internal.SdkInternalList<ResultAttribute>();
        }
        return resultAttributes;
    }
535034
@Override
  @NullSafe
  public Map<KEY, VALUE> toMap() {
    return Collections.unmodifiableMap(nullSafeMap(getMap()));
  }
1365769
public Map getAsMap() {
        if (mMap != null) {
            return mMap;
        } else {
            Map m = convertToMap();
            if (!isMutable()) {
                mMap = m;
            }
            return m;
        }
    }
1183537
public Map<Object, Map<Object, String>> getElementCollectionCache()
    {
        if (this.elementCollectionCache == null)
        {
            this.elementCollectionCache = new HashMap<Object, Map<Object, String>>();
        }
        return this.elementCollectionCache;
    }
958904
public Map<String,Object> getProperty() {
		// TODO: If we have properties volatile, could do the null and frozen cases outside the synchronized block
		// TODO: Would this be faster?
		synchronized(lock) {
			if(properties == null) return Collections.emptyMap();
			if(frozen) return properties;
			return AoCollections.unmodifiableCopyMap(properties);
		}
	}
344506
public Map<String, Object> getProperties() {
        Map<String, Object> result = null;
        if (body != null) {
            Map<String, Object> prop;
            try {
                prop = body.getProperties();
            } catch (IllegalStateException e) {
                // handle when both object and json are null for this body
                return null;
            }
            if (result == null) {
                result = new HashMap<String, Object>();
            }
            result.putAll(prop);
        }
        return result;
    }
141359
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Long> getValues() {
    return getValuesMap();
  }
899656
public List<JcError> store(Map<Long, Integer> elementVersionsMap) {
		Map<GrNode, JcNumber> createdNodeToIdMap = new HashMap<GrNode, JcNumber>();
		Map<GrRelation, JcNumber> createdRelationToIdMap = new HashMap<GrRelation, JcNumber>();
		List<ElemId2Query> elemIds2Query = createUpdateQueries(createdNodeToIdMap, createdRelationToIdMap, elementVersionsMap);
		Map<Long, Integer> elemId2ResultIndex = new HashMap<Long, Integer>();
		List<JcQuery> queries = collectQueries(elemIds2Query, elemId2ResultIndex);
		Util.printQueries(queries, QueryToObserve.UPDATE_QUERY, Format.PRETTY_1);
		List<JcError> errors = new ArrayList<JcError>();
		if (queries.size() > 0) {
			List<JcQueryResult> results = dbAccess.execute(queries);
			errors.addAll(Util.collectErrors(results));
			if (errors.isEmpty()) { // success
				JcError error;
				if ((error = checkLockingError(results, !createdNodeToIdMap.isEmpty() || !createdRelationToIdMap.isEmpty(),
						elemIds2Query)) != null) {
					errors.add(error);
					ITransaction tx = this.dbAccess.getTX();
					if (tx != null)
						tx.failure();
				}
				this.handleSyncState(results, createdNodeToIdMap,
						createdRelationToIdMap, error != null, elemId2ResultIndex);
			}
		}
		return errors;
	}
1281368
public Map<String, List<Item>> getTableItems() {
        Map<String, List<Map<String, AttributeValue>>> res = 
            result.getResponses();
        Map<String, List<Item>> map = new LinkedHashMap<String, List<Item>>(res.size());
        for (Map.Entry<String, List<Map<String, AttributeValue>>> e 
                : res.entrySet()) {
            String tableName = e.getKey();
            List<Map<String, AttributeValue>> items = e.getValue();
            map.put(tableName, InternalUtils.toItemList(items));
        }
        return map;
    }
493101
public List<J4pRemoteException> getRemoteExceptions() {
        List<J4pRemoteException> ret = new ArrayList<J4pRemoteException>();
        for (Object entry : results) {
            if (entry instanceof J4pRemoteException) {
                ret.add((J4pRemoteException) entry);
            }
        }
        return ret;
    }
845745
public Map<String, String> getLinks() {
        if (links == null) {
            return ImmutableMap.of();
        }
        return ImmutableMap.copyOf(links);
    }
664053
public Map<String, Object> toMap() {
        Lock lock = lockForWrite();
        try {
            Map<String, Object> data = new HashMap<>();
            data.put(SER_FIELD_DIRTY, dirty);
            data.put(SER_FIELD_ATTRS, attributes != null ? cloneData(attributes) : new HashMap<>());
            return data;
        } finally {
            lock.unlock();
        }
    }