Returns values aggregated from all the delegates, without overriding
values that already exist.

@return The Map of aggregated values
186666
@Override
    public Map<String, String> values() {
        Map<String, String> values = new LinkedHashMap<>();
        for (Row each : delegates) {
            for (Entry<String, String> entry : each.values().entrySet()) {
                String name = entry.getKey();
                if (!values.containsKey(name)) {
                    values.put(name, entry.getValue());
                }
            }
        }
        return values;
    }
778734
@Pure
	public List<Object> getRemovedValues() {
		if (this.oldValues == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.oldValues);
	}
891429
@Override
    public Collection<V> values() {
        final Collection<V> localValues = this.localMap.values();

        if (isReadyOnly())
            return Collections.unmodifiableCollection(localValues);

        return localValues;
    }
1274975
@Override
  public ImmutableCollection<V> values() {
    ImmutableCollection<V> result = values;
    return (result == null) ? values = new ImmutableMapValues<K, V>(this) : result;
  }
834476
private final MultimapSubject delegate() {
    MultimapSubject delegate = check().that(actual());
    if (internalCustomName() != null) {
      delegate = delegate.named(internalCustomName());
    }
    return delegate;
  }
1247834
public Map<String, Object> getVariables() {
    final HashMap<String, Object> map = new HashMap<String, Object>();
    if (inherited != null)
      map.putAll(inherited.getVariables());
    if (variables != null)
      map.putAll(variables);
    return map;
  }
207239
@Override
    public Collection<Object> values() {
        ArrayList<Object> answer = new ArrayList<>(types.size());
        for (Iterator<Object> iter = valueIterator(); iter.hasNext(); ) {
            answer.add(iter.next());
        }
        return Collections.unmodifiableList(answer);
    }
289691
public Map<String, SetAndCount> getAggregateResultFullSummary() {

        Map<String, SetAndCount> summaryMap = new ConcurrentHashMap<String, SetAndCount>();

        for (Entry<String, LinkedHashSet<String>> entry : aggregateResultMap
                .entrySet()) {
            summaryMap.put(entry.getKey(), new SetAndCount(entry.getValue()));
        }

        return summaryMap;
    }
398942
@Override
    public Collection<V> values() {
        try {
            lockAllSegments();
            Collection<V> collection = new ArrayList<>();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                collection.addAll(seg.values());
            }
            return collection;
        } finally {
            unlockAllSegments();
        }
    }
83076
public List<Map> getValues() {
        if (values == null) {
            values = Reflection.toTypedList(getMap().get(BATCH_INSERTION_VALUES_KEY), Map.class);
        }
        return values;
    }
153580
public List<AggregationSelectItem> getAggregationSelectItems() {
        List<AggregationSelectItem> result = new LinkedList<>();
        for (SelectItem each : items) {
            if (each instanceof AggregationSelectItem) {
                AggregationSelectItem aggregationSelectItem = (AggregationSelectItem) each;
                result.add(aggregationSelectItem);
                result.addAll(aggregationSelectItem.getDerivedAggregationSelectItems());
            }
        }
        return result;
    }
720045
public Map<K, V> getMutableMap() {
        if (mode != StorageMode.MAP) {
            if (mode == StorageMode.LIST) {
                mapData = convertListToMap(listData);
            }
            listData = null;
            mode = StorageMode.MAP;
        }
        return mapData;
    }
1174515
public java.util.Map<java.lang.String, alluxio.grpc.InconsistentPropertyValues> getValuesMap() {
    return internalGetValues().getMap();
  }
953071
public java.util.List<AggregateComplianceCount> getAggregateComplianceCounts() {
        if (aggregateComplianceCounts == null) {
            aggregateComplianceCounts = new com.amazonaws.internal.SdkInternalList<AggregateComplianceCount>();
        }
        return aggregateComplianceCounts;
    }
417297
@NullSafe
  @Override
  public Iterator<VALUE> iterator() {
    return Collections.unmodifiableMap(this.map).values().iterator();
  }
748103
public final Set<T> values()
    {
        Set<T> convertedValues = new HashSet<>();
        for (BinaryValue baw : values)
        {
            convertedValues.add(convert(baw));
        }
        return Collections.unmodifiableSet(convertedValues);
    }
134338
public Map<String, String> getProperties() {
        final Map<String, String> res = new HashMap<>();
        for (final Map.Entry<String, Object> e: prop.entrySet()) {
            if (e.getValue() instanceof String) {
                res.put(e.getKey(), (String) e.getValue());
            }
        }
        return Collections.unmodifiableMap(res);
    }