<p>
toMap.
</p>

@param wordMappings an array of {@link java.lang.String} objects.
@return a {@link java.util.Map} object.
351669
public static Map<String, String> toMap(String[]... wordMappings) {
    Map<String, String> mappings = new HashMap<String, String>();
    for (int i = 0; i < wordMappings.length; i++) {
      String singular = wordMappings[i][0];
      String plural = wordMappings[i][1];
      mappings.put(singular, plural);
    }
    return mappings;
  }
536875
@java.lang.Deprecated
  public java.util.Map<
          java.lang.String, com.google.cloud.translate.v3beta1.TranslateTextGlossaryConfig>
      getGlossaries() {
    return getGlossariesMap();
  }
1121632
@Override
    public Map<String, Object> toMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("plz", getPLZ());
        map.put("ortsname", getOrtsname());
        if (nummer != null) {
            map.put("nummer", nummer);
        }
        return map;
    }
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;
    }
44332
public Map<String, String> toStringMap() {
    Map<String, String> map = new HashMap<>();
    for (Map.Entry<String, Object> entry : entrySet()) {
      map.put(entry.getKey(), String.valueOf(entry.getValue()));
    }
    return map;
  }
663384
public static Map<String, QueryParameter> toMap(List<QueryParameter> parameters) {
        Map<String, QueryParameter> map = new HashMap<String, QueryParameter>();
        for (QueryParameter qp : parameters) {
            map.put(qp.getName(), qp);
        }
        return map;
    }
739458
public Map<String, String> toMap() {

        HashMap<String,String> map = new HashMap<>();

        if( user != null ) {

            Map<String,String> userMap = user.toMap();

            for(String st : userMap.keySet() ){
                map.put("user."+st,userMap.get(st));
            }

        }

        map.put("message",message);
        map.put("token",token);
        map.put("success",String.valueOf(success));
        return map;
    }
901302
public Iterable<Map<String, String>> toMaps() {
    checkState(!isClosed, WORKBOOK_CLOSED);
    checkState(hasHeader, NO_HEADER);
    return Iterables.skip(Iterables.transform(sheet, item -> {
      Map<String, String> map = newLinkedHashMap();
      List<String> row = rowToList(item);
      for (int i = 0; i < getHeader().size(); i++) {
        map.put(getHeader().get(i), row.get(i));
      }
      return map;
    }), 1);
  }
839382
public java.util.Map<java.lang.String, java.lang.String> getTagsMap() {
    return internalGetTags().getMap();
  }
418240
Map<String,Long> getContext(String... tokens) throws IOException {
    Objects.requireNonNull(tokens);
    TermsEnum iterator = getIterator();
    Map<String,Long> result = new HashMap<>();
    BytesRef byteRef;
    int i = 0;
    while ((byteRef = iterator.next()) != null) {
      String term = new String(byteRef.bytes, byteRef.offset, byteRef.length);
      for (String token : tokens) {
        if (term.contains(" " + token + " ")) {
          String[] split = term.split(" ");
          if (split.length == 3) {
            long count = getCount(Arrays.asList(split[0], split[1], split[2]));
            result.put(term, count);
          }
        }
      }
      /*if (i++ > 1_000_000) { // comment in for faster testing with subsets of the data
        break;
      }*/
    }
    return result;
  }
1372528
public Map<String, String> getKeywordMap() {
        if (keywords == null) {
            TreeMap<String, String> m = null;
            if (setToKeywordStart()) {
                // trim spaces and convert to lower case, both keywords and values.
                do {
                    String key = getKeyword();
                    if (key.length() == 0) {
                        break;
                    }
                    char c = next();
                    if (c != KEYWORD_ASSIGN) {
                        // throw new IllegalArgumentException("key '" + key + "' missing a value.");
                        if (c == DONE) {
                            break;
                        } else {
                            continue;
                        }
                    }
                    String value = getValue();
                    if (value.length() == 0) {
                        // throw new IllegalArgumentException("key '" + key + "' missing a value.");
                        continue;
                    }
                    if (m == null) {
                        m = new TreeMap<String, String>(getKeyComparator());
                    } else if (m.containsKey(key)) {
                        // throw new IllegalArgumentException("key '" + key + "' already has a value.");
                        continue;
                    }
                    m.put(key, value);
                } while (next() == ITEM_SEPARATOR);
            }
            keywords = m != null ? m : Collections.<String, String>emptyMap();
        }

        return keywords;
    }
998984
public static Map<String, Object> toMap(XmlReaders readers){
        Node root = readers.getNode("xml");
        if (root == null){
            return Collections.emptyMap();
        }
        NodeList children = root.getChildNodes();
        if (children.getLength() == 0){
            return Collections.emptyMap();
        }
        Map<String, Object> data = new HashMap<>(children.getLength());
        Node n;
        for (int i = 0; i<children.getLength(); i++){
            n = children.item(i);
            data.put(n.getNodeName(), n.getTextContent());
        }
        return data;
    }
165600
public static Map<String, Long> buildCountMap(List<String> wordList) {
        return buildCountMap(wordList.stream());
    }
535034
@Override
  @NullSafe
  public Map<KEY, VALUE> toMap() {
    return Collections.unmodifiableMap(nullSafeMap(getMap()));
  }
1317067
protected Map<String, Object> toMap(final String xml) {
        XmlReaders readers = readResp(xml);
        return Maps.toMap(readers);
    }
664053
public Map<String, Object> toMap() {
        Lock lock = lockForWrite();
        try {
            Map<String, Object> data = new HashMap<>();
            data.put(SER_FIELD_DIRTY, dirty);
            data.put(SER_FIELD_ATTRS, attributes != null ? cloneData(attributes) : new HashMap<>());
            return data;
        } finally {
            lock.unlock();
        }
    }
1304588
private Map<String,Namespace> buildByPrefixMap()
    {
        int len = mNamespaces.size();
        if (len == 0) {
            return Collections.emptyMap();
        }

        LinkedHashMap<String,Namespace> m = new LinkedHashMap<String,Namespace>(1 + len + (len>>1));
        for (int i = 0; i < len; ++i) {
            Namespace ns = mNamespaces.get(i);
            String prefix = ns.getPrefix();
            if (prefix == null) { // shouldn't happen but...
                prefix = "";
            }
            m.put(prefix, ns);
        }
        return m;
    }