Returns the ordered Map value of the field.

@return the ordered Map value of the field. It returns a reference of the value.
@throws IllegalArgumentException if the value cannot be converted to ordered Map.
438499
@SuppressWarnings("unchecked")
  public LinkedHashMap<String, Field> getValueAsListMap() {
    return (LinkedHashMap<String, Field>) type.convert(getValue(), Type.LIST_MAP);
  }
646518
public static String getMapFieldValueType(Field field) {
        FieldType type = field.getType();
        if (!(type instanceof Message)) {
            throw new IllegalArgumentException(field.toString());
        }
        Message entryType = (Message) type;
        Type valueType = entryType.getField(MAP_ENTRY_VALUE).getType();
        String v;
        if (valueType instanceof ScalarFieldType) {
            ScalarFieldType scalarValueType = (ScalarFieldType) valueType;
            v = ScalarFieldTypeUtil.getWrapperType(scalarValueType);
        } else {
            UserType userType = (UserType) valueType;
            v = UserTypeUtil.getCanonicalName(userType);
        }
        return v;
    }
141359
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Long> getValues() {
    return getValuesMap();
  }
131825
private LinkedHashMap<PrefixedName,DTDElement> getElementMap() {
        LinkedHashMap<PrefixedName,DTDElement> m = mElements;
        if (m == null) {
            /* Let's try to get insert-ordered Map, to be able to
             * report redefinition problems in proper order when validating
             * subset compatibility
             */
            mElements = m = new LinkedHashMap<PrefixedName,DTDElement>();
        }
        return m;
    }
1058939
private static Map<String, Object> getMap(Object obj) {
    // Using a LinkedHashMap to maintain the original order of insertions. This is done to help
    // with handling unused parameters and makes testing easier as well.
    Map<String, Object> map = new LinkedHashMap<String, Object>();
    for (Map.Entry<String, Object> entry : Data.mapOf(obj).entrySet()) {
      Object value = entry.getValue();
      if (value != null && !Data.isNull(value)) {
        map.put(entry.getKey(), value);
      }
    }
    return map;
  }
1365769
public Map getAsMap() {
        if (mMap != null) {
            return mMap;
        } else {
            Map m = convertToMap();
            if (!isMutable()) {
                mMap = m;
            }
            return m;
        }
    }
192603
public Map<String, String> getSortParameter() {

        return new HashMap<String, String>() {{
            put(sortUrlParameterName, getFields());
        }};
    }
939364
public java.util.Map<String, java.util.List<String>> getFields() {
        if (fields == null) {
            fields = new com.amazonaws.internal.SdkInternalMap<String, java.util.List<String>>();
        }
        return fields;
    }
199330
public static String mapGetByKeyMethodName(Field field) {
        if (field.isMap()) {
            return GETTER_PREFIX + Formatter.toPascalCase(field.getName());
        }
        throw new IllegalArgumentException(field.toString());
    }
849045
public HashMap<String,Object> getValueMap()
  {
    try {
      if (_values == null) {
        _values = new HashMap<String,Object>();

        Method []methods = _ann.annotationType().getMethods();

        for (int i = 0; i < methods.length; i++) {
          Method method = methods[i];

          if (method.getDeclaringClass().equals(Class.class))
            continue;
          if (method.getDeclaringClass().equals(Object.class))
            continue;
          if (method.getParameterTypes().length != 0)
            continue;

          _values.put(method.getName(), method.invoke(_ann));
        }
      }

      return _values;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
1294368
@Deprecated
  public static <K, V> ImmutableMap<K, V> copyWithKeysSortedBy(final Map<K, V> map,
      final Ordering<? super K> ordering) {
    return ImmutableSortedMap.copyOf(map, ordering);
  }
279412
public Map<String, Object> asMap() {
        Map<String, Object> map = new HashMap<>();
        Set<String> keys = columnNameToIdxMap.keySet();
        Iterator<String> iterator = keys.iterator();
        while (iterator.hasNext()) {
            String colum = iterator.next().toString();
            int index = columnNameToIdxMap.get(colum);
            map.put(colum, values[index]);
        }
        return map;
    }
434731
@SuppressWarnings("unchecked")
  public static <K, V> ImmutableSortedMap<K, V> of() {
    return EmptyImmutableSortedMap.forComparator(NATURAL_ORDER);
  }
1085366
public Position.LineMap getLineMap() {
        return Position.makeLineMap(reader.getRawCharacters(), reader.buflen, false);
    }
341294
@SuppressWarnings("unchecked")
    public Map<String, V> getData() {
        final TreeMap<String, V> result = new TreeMap<>(); // returned map must be sorted
        for (int i = 0; i < data.size(); i++) {
            // The Eclipse compiler does not need the typecast to V, but the Oracle compiler sure does.
            result.put(data.getKeyAt(i), (V) data.getValueAt(i));
        }
        return Collections.unmodifiableMap(result);
    }
1191864
public T next() {
		if(MapUtil.isEmpty(this.weightMap)) {
			return null;
		}
		final double randomWeight = this.weightMap.lastKey() * random.nextDouble();
		final SortedMap<Double, T> tailMap = this.weightMap.tailMap(randomWeight, false);
		return this.weightMap.get(tailMap.firstKey());
	}
987440
public java.util.Map<java.lang.String, java.lang.String> getRetMap() {
    return internalGetRet().getMap();
  }