Gets a mapped presentation of the pair.

@return mapped presentation of the pair.

@since v1.1.0
186747
public Map<K, V> toMap() {
        Map<K, V> result = new HashMap<K, V>();
        result.put(key, value);
        return result;
    }
1217698
public static Map<String, String> getImmutableContext() {
        final Map<String, String> map = contextMap.getImmutableMapOrNull();
        return map == null ? EMPTY_MAP : map;
    }
562511
public static Map<String, String[]> getParameterMap()
	{
		final Request request = RequestCycle.get().getRequest();
		return getParameterMap(request);
	}
913176
public Map<String, Object> getProperties()
    {
        if (this.getRecord() != null)
            if (((this.getRecord().getDatabaseType() & DBConstants.MAPPED) != 0)
                || ((this.getRecord().getDatabaseType() & DBConstants.REMOTE_MEMORY) != 0))
        {
            if (m_properties == null)
                m_properties = new Hashtable<String,Object>();
            m_properties.put(RecordMessageConstants.TABLE_NAME, this.getRecord().getTableNames(false)); // Don't call setProperty since ClientTable does a remote call
        }
        return m_properties;
    }
183406
public Map<String, Object> asMap() {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("statusCode", statusCode);
        map.put("statusMessage", statusMessage);
        map.put("requestMethod", requestMethod);
        map.put("requestUri", requestUri);

        if (!StringUtils.isNullOrEmpty(message)) {
            map.put("message", message);
        }
        if (!StringUtils.isNullOrEmpty(stacktrace)) {
            map.put("stacktrace", stacktrace);
        }

        return map;
    }
75979
public Map<String,String> getMap () {                                                               //SIB0163.comms.1
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getMap");

     final short len = getShort();

     final Map<String,String> rc = new HashMap<String,String>();
     for (int i=0; i < len; i++) {
       rc.put(getString(),getString());
     }

     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getMap","rc="+rc);
     return rc;
   }
1181423
public Map<String, Object> getTarget() {
        TreeMap<String, Object> map = new TreeMap<String, Object>();
        synchronized (eventMap) {
            for (Entry<String, Object> entry : eventMap.entrySet()) {
                if (entry.getKey().startsWith(TARGET))
                    map.put(entry.getKey(), entry.getValue());
            }
        }
        return map;
    }
815722
public static Mapping getMapping(PersistentEntity domainClass) {
        return domainClass == null ? null : MAPPING_CACHE.get(domainClass.getJavaClass());
    }
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;
        }
    }
69059
public ValueMap getProperties() {
    if (this.properties == null) {
      this.properties = new ValueMapDecorator(new HashMap<String, Object>());
    }
    return this.properties;
  }
79822
public Map<String, String> getRoleMap() {
        if (mapAllMethods != null) {
            return getRoleMapFromAllMap();
        }
        Map<String, List<String>> outputRTMNormal = null;
        Map<String, List<String>> outputRTMOmission = null;

        if (mapMethod != null) {
            outputRTMNormal = getRoleToMethodMap(getMethod(mapMethod, ROLE, true));
            if (tc.isDebugEnabled())
                Tr.debug(tc, "outputRTMNormal: " + outputRTMNormal);
        }
        if (mapMethodOmission != null) {
            // it genereate output only following condition:
            // 1.role is assigned.
            // 2.neither unchecked or excluded.
            Map<String, MethodConstraint> omissionRole = getMethod(mapMethodOmission, ROLE_NO_CHECK, true);
            Map<String, MethodConstraint> validRole = getMethod(mapMethodOmission, EXCLUDED_OR_UNCHECKED_NO_ROLE, true);
            Map<String, MethodConstraint> uncheckedOrExcluded = getMethod(mapMethodOmission, EXCLUDED_OR_UNCHECKED, true);

            if (tc.isDebugEnabled())
                Tr.debug(tc, "omissionRole: " + omissionRole + " validRole : " + validRole + " uncheckedOrExcluded : " + uncheckedOrExcluded);
            if (omissionRole != null && ((uncheckedOrExcluded != null && validRole != null) || uncheckedOrExcluded == null)) {
                outputRTMOmission = getRoleToMethodMap(omissionRole);
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "outputRTMOmission: " + outputRTMOmission);
            }
        }

        // now merge both tables and generate method strings.
        Map<String, String> output = mergeRTM(outputRTMNormal, outputRTMOmission);
        if (tc.isDebugEnabled())
            Tr.debug(tc, "getRoleMap: output: " + output);
        return output;
    }
687358
public Map<String, Collection<String>> toMap() {
        Map<String, Collection<String>> params = new HashMap<String, Collection<String>>();
        if (name != null) {
            ArrayList<String> valueList = new ArrayList<String>();
            valueList.add(name);
            params.put("name", valueList);
        }
        if (resolution != null) {
            ArrayList<String> valueList = new ArrayList<String>();
            valueList.add(resolution);
            params.put("resolution", valueList);
        }
        ArrayList<String> valueList = new ArrayList<String>();
        valueList.add(Boolean.toString(hasAudio));
        params.put("hasAudio", valueList);
        
        valueList = new ArrayList<String>();
        valueList.add(Boolean.toString(hasVideo));
        params.put("hasVideo", valueList);
        
        valueList = new ArrayList<String>();
        valueList.add(outputMode.toString());
        params.put("outputMode", valueList);

        if (layout != null) {
            valueList = new ArrayList<String>();
            valueList.add(layout.toString());
            params.put("layout", valueList);
        }

        return params;
    }
373906
public Map<String, Metamodel> getMetamodelMap()
    {
        if (metamodelMap == null)
        {
            metamodelMap = new HashMap<String, Metamodel>();
        }
        return metamodelMap;
    }
817178
public synchronized Map<String, Object> getProperties() {
        if (properties == null) {
            return Collections.emptyMap();
        }
        return Collections.unmodifiableMap(new HashMap<>(properties));
    }
900453
public Map<String,Object> getProperties()
    {
        Map<String,Object> properties = new HashMap<String,Object>();
        if (m_mxProperties != null)
        {
            for (int i = 0; i < m_mxProperties.length; i++)
            {
                if (m_mxProperties[i][MessageConstants.NAME] != null)
                    if (m_mxProperties[i][MessageConstants.VALUE] != null)
                        properties.put((String)m_mxProperties[i][MessageConstants.NAME], m_mxProperties[i][MessageConstants.VALUE]);
            }
        }
        return properties;
    }
89976
protected Map<String, String> getInfoMap() {

        Map<String, String> infos = new LinkedHashMap<String, String>();
        List<CmsSessionInfo> sessions = OpenCms.getSessionManager().getSessionInfos();
        List<CmsUUID> user = new ArrayList<CmsUUID>();
        for (CmsSessionInfo info : sessions) {
            CmsUUID id = info.getUserId();
            if (!user.contains(id)) {
                user.add(id);
            }
        }
        infos.put(
            CmsVaadinUtils.getMessageText(Messages.GUI_MESSAGES_SESSION_COUNT_0),
            String.valueOf(sessions.size()));
        infos.put(CmsVaadinUtils.getMessageText(Messages.GUI_MESSAGES_USER_COUNT_0), String.valueOf(user.size()));
        return infos;
    }
430
public Map<String, String> getProperty() {

        if (m_properties == null) {
            try {
                List<CmsProperty> properties = m_cms.readPropertyObjects(this, false);
                m_properties = CmsProperty.toMap(properties);
            } catch (CmsException e) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(e.getMessage(), e);
                }
            }
        }
        return m_properties;
    }