Returns a map with key property as key and item as value.<p>

@return HashMap
487042
private Map<String, Item> getKeyItemMap() {

        Map<String, Item> ret = new HashMap<String, Item>();
        for (Object itemId : m_container.getItemIds()) {
            ret.put(
                m_container.getItem(itemId).getItemProperty(TableProperty.KEY).getValue().toString(),
                m_container.getItem(itemId));
        }
        return ret;

    }
332801
public Map<String, MethodInfoList> asMap() {
        // Note that MethodInfoList extends InfoList rather than MappableInfoList, because one
        // name can be shared by multiple MethodInfo objects (so asMap() needs to be of type
        // Map<String, MethodInfoList> rather than Map<String, MethodInfo>)
        final Map<String, MethodInfoList> methodNameToMethodInfoList = new HashMap<>();
        for (final MethodInfo methodInfo : this) {
            final String name = methodInfo.getName();
            MethodInfoList methodInfoList = methodNameToMethodInfoList.get(name);
            if (methodInfoList == null) {
                methodInfoList = new MethodInfoList(1);
                methodNameToMethodInfoList.put(name, methodInfoList);
            }
            methodInfoList.add(methodInfo);
        }
        return methodNameToMethodInfoList;
    }
1222013
public Map<String, Object> toMap() {
        Map<String, Object> result = new HashMap<>();
        for (Entry<Key, Value> keyValueEntry : fields.entrySet()) {
            Key key = keyValueEntry.getKey();
            Value value = keyValueEntry.getValue();
            if (!key.isExtension()) {
                result.put(key.getName(), transformValueToObject(value));
            } else {
                result.put("(" + key.getName() + ")", transformValueToObject(value));
            }
        }
        return result;
    }
1324932
public function set($key, $value) : HashMap
    {
        $values = $this->_set($key, $value, false);
        $this->setValues($values);
        return $this;
    }
304221
public Map<String, Set<String>> getReverseMap() {
    Set<Map.Entry<String,Set<String>>> entries = map.entrySet();
    Map<String, Set<String>> rMap = new HashMap<String, Set<String>>(entries.size());
    for (Map.Entry<String,Set<String>> me : entries) {
      String k = me.getKey();
      Set<String> transList = me.getValue();
      for (String trans : transList) {
        Set<String> entry = rMap.get(trans);
        if (entry == null) {
          // reduce default size as most will be small
          Set<String> toAdd = new LinkedHashSet<String>(6);
          toAdd.add(k);
          rMap.put(trans, toAdd);
        } else {
          entry.add(k);
        }
      }
    }
    return rMap;
  }
1229806
public Map<String, String> getPropertySearch() {

        if (m_propertiesSearch == null) {
            try {
                List<CmsProperty> properties = m_cms.readPropertyObjects(this, true);
                m_propertiesSearch = CmsProperty.toMap(properties);
            } catch (CmsException e) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(e.getMessage(), e);
                }
            }
        }
        return m_propertiesSearch;
    }
535034
@Override
  @NullSafe
  public Map<KEY, VALUE> toMap() {
    return Collections.unmodifiableMap(nullSafeMap(getMap()));
  }
270029
private Map<String, String> simpleColumnToPropertyMappings(Map<String, ColumnMetaData> cm){
		Map<String, String> result = new HashMap<String, String>(cm.size());
		for (Entry<String, ColumnMetaData> entry: cm.entrySet()){
			result.put(entry.getKey(), entry.getValue().getPropertyName());
		}
		return result;
	}
1061290
@Pure
	public static <K, V> HashMap<K, V> newHashMap() {
		return new HashMap<K, V>();
	}
1249193
private static function getInstance(): HashMap {
        if (null === self::$map) {
            self::$map = new HashMap();
        }
        return self::$map;
    }
853553
public function map()
    {
        $column = array();
        foreach ($this as $record) {
            $key = reset($record);
            $val = next($record);
            $column[$key] = $val;
        }
        return $column;
    }
68475
public HashMap<Integer, byte[]> getPreKeys() {
        if (preKeys == null) {
            preKeys = new HashMap<>();
            for (int id : preKeysB64.keySet()) {
                preKeys.put(id, Base64.decode(preKeysB64.get(id)));
            }
        }
        return this.preKeys;
    }
1134863
protected function buildPropertyMap()
    {
        $map = [];
        $properties = (new ReflectionObject($this))->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $property) {
            $map[$property->getName()] = $property;
        }

        return $map;
    }
968312
public Map<String, String> getFieldMap() {
		if (headerMap == null) {
			throw new IllegalStateException("No header available");
		}

		final Map<String, String> fieldMap = new LinkedHashMap<>(headerMap.size());
		String key;
		Integer col;
		String val;
		for (final Map.Entry<String, Integer> header : headerMap.entrySet()) {
			key = header.getKey();
			col = headerMap.get(key);
			val = null == col ? null : get(col);
			fieldMap.put(key, val);
		}

		return fieldMap;
	}
1198141
public Map<K, V> getMap() {
        if (mode == StorageMode.LIST) {
            synchronized (this) {
                if (mode == StorageMode.LIST) {
                    mapData = convertListToMap(listData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableMap(mapData);
    }
186747
public Map<K, V> toMap() {
        Map<K, V> result = new HashMap<K, V>();
        result.put(key, value);
        return result;
    }
209996
@Override
    public Map<String, Object> toMap() {
        Map<String, Object> map = C.newMap();
        for (Map.Entry<String, ValueObject> entry : entrySet()) {
            map.put(entry.getKey(), entry.getValue().value());
        }
        return map;
    }