Gets map of fields and values.

@return Collection of field name-field value pairs.
330478
@Override
    public Map<String, String> getValues() {
        HashMap<String, String> result = new HashMap<>();

        if (beforeDate != null) result.put("BeforeDate", Long.toString(beforeDate));
        if (afterDate != null) result.put("AfterDate", Long.toString(afterDate));

        return result;
    }
816441
public Map<String, String> getMacroMap() {

        Map<String, String> map = new HashMap<String, String>();
        if (m_bundleComponentKeyMap != null) {
            Set<TextField> fields = m_bundleComponentKeyMap.keySet();

            for (TextField field : fields) {
                map.put(m_bundleComponentKeyMap.get(field), field.getValue());
            }
        }
        return map;
    }
496314
public Set<String> getFieldNamesCollection() {
        final Set<String> set = new HashSet<>(_size);
        for (HttpField f : this) {
            if (f != null)
                set.add(f.getName());
        }
        return set;
    }
948547
@Override
    public Map<FieldDescriptor, Object> getAllFields() {
        TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
        for (final FieldDescriptor field : metadata.descriptor.getFields()) {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
        return Collections.unmodifiableMap(result);
    }
1241133
private Map<String, Object> toFieldsMap(Map<String, DocumentField> fields) {
		Map<String, Object> result = new HashMap<>();
		for (Entry<String, DocumentField> entry : fields.entrySet()) {
			if (entry.getValue().getValues().size() > 1) {
				result.put(entry.getKey(), entry.getValue().getValues());
			} else {
				result.put(entry.getKey(), entry.getValue().getValue());
			}

		}
		return result;
	}
1260374
public function getFieldsMap() {

		$formFields = $this->fields;
		$fieldsMap	= [];

		foreach( $formFields as $formField ) {

			$fieldsMap[ $formField->name ] = $formField;
		}

		return $fieldsMap;
	}
334192
public SortedSet<String> fields() {
		// Optimization: Materialize the fields set
		if (myFieldSet == null)
			myFieldSet = new TreeSet<String>(fields.keySet());
		return myFieldSet;
	}
280398
public List<FieldValue> getFieldValues() {
        long offset = fileOffset + getInstanceFieldValuesOffset();
        List<Field> fields = dumpClass.getAllInstanceFields();
        List<FieldValue> values = new ArrayList<FieldValue>(fields.size());
        Iterator<Field> fit = fields.iterator();

        while (fit.hasNext()) {
            HprofField field = (HprofField) fit.next();

            if (field.getValueType() == HprofHeap.OBJECT) {
                values.add(new HprofInstanceObjectValue(this, field, offset));
            } else {
                values.add(new HprofInstanceValue(this, field, offset));
            }

            offset += field.getValueSize();
        }

        return values;
    }
531993
private Multimap<String, I_CmsFormField> getFieldsByGroup(Collection<I_CmsFormField> fields) {

        Multimap<String, I_CmsFormField> result = ArrayListMultimap.create();
        for (I_CmsFormField field : fields) {
            String group = field.getLayoutData().get(LD_GROUP);
            result.put(group, field);
        }
        return result;
    }
749998
public function getMappedFields()
    {
        $mapped = array();

        foreach ($this->fields as $key => $value) {
            if (array_key_exists($key, $this->mappings)) {
                $map = $this->mappings[$key];
                $mapped[$map] = $value;
            }
        }

        return $mapped;
    }
360441
public Map<String, String> getSortedMap()
    {
        ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
        for ( FieldValue fv : fieldValues )
        {
            builder.put(fv.getField(), fv.getValue());
        }

        return builder.build();
    }
1005375
public function getFields()
	{
		$list	= array();
		foreach( $this->fields as $name => $fields )
				if( count( $fields ) )
					foreach( $fields as $field )
						$list[]	= $field;
		return $list;
	}
395055
public Map<String, String> getMetatags() {
        Map<String, String> result = new HashMap<>();

        for (Map.Entry<String, String> entry : _metatags.entrySet()) {
            String key = entry.getKey();

            if (!ReservedField.isReservedField(key)) {
                result.put(key, entry.getValue());
            }
        }
        return Collections.unmodifiableMap(result);
    }
433092
public List<FieldRef> getFields() {
        Map<String,FieldRef> fields = new LinkedHashMap<String,FieldRef>();
        for (Klass<?> k = this; k!=null; k=k.getSuperClass()) {
            for (FieldRef f : k.getDeclaredFields()) {
                String name = f.getName();
                if (!fields.containsKey(name) && f.isRoutable()) {
                    fields.put(name,f);
                }
            }
        }

        return new ArrayList<FieldRef>(fields.values());
    }
306630
@Nullable
  public Map<String, Object> getData() {
    if (fields == null) {
      return null;
    }

    Map<String, Object> decodedFields = new HashMap<>();
    for (Map.Entry<String, Value> entry : fields.entrySet()) {
      Object decodedValue = decodeValue(entry.getValue());
      decodedValue = convertToDateIfNecessary(decodedValue);
      decodedFields.put(entry.getKey(), decodedValue);
    }
    return decodedFields;
  }
379619
public String getFields() {
        StateHelper helper = this.getStateHelper(true);
        return (String) helper.get(FIELDS_KEY);
    }
743816
public Collection values() {
        if (values == null) {
            values = new AbstractCollectionView() {
                public long size() throws ObjectManagerException {
                    return AbstractTreeMap.this.size();
                }

                public Iterator iterator() throws ObjectManagerException {
                    return makeTreeMapIterator(new AbstractMapEntry.Type() {
                        public Object get(AbstractMapEntry entry) {
                            return entry.getValue();
                        }
                    });
                }
            };
        }
        return values;
    }