Map of program name to meta of included programs

@return Optional of the <code>includes</code> field value.
6179
@javax.annotation.Nonnull
    public java.util.Optional<java.util.Map<String,net.morimekta.providence.model.ProgramMeta>> optionalIncludes() {
        return java.util.Optional.ofNullable(mIncludes);
    }
669130
public Map<String, String> getMetadata() {
    return metadata == null || Data.isNull(metadata) ? null : Collections.unmodifiableMap(metadata);
  }
1051296
@JsonProperty
    private Map<String, Object> getMetadata() {
        if (metadata == null) {
            metadata = new HashMap<>();
        }
        
        return metadata;
    }
1035358
@SuppressWarnings("unchecked")
	public OptionsBuilder includes(/* @Nullable */ Collection<String> includes) {

		if (includes != null && !includes.isEmpty()) {
			if (!options.containsKey(Options.INCLUDES)) {
				options.put(Options.INCLUDES, new ArrayList<Object>());
			}

			List<Object> allIncludes = (List<Object>) options.get(Options.INCLUDES);
			allIncludes.addAll(includes);
		}
		return this;
	}
974810
private Map<MethodSymbol, Attribute> getAllValues() {
        Map<MethodSymbol, Attribute> res =
            new LinkedHashMap<MethodSymbol, Attribute>();

        // First find the default values.
        ClassSymbol sym = (ClassSymbol) anno.type.tsym;
        for (Scope.Entry e = sym.members().elems; e != null; e = e.sibling) {
            if (e.sym.kind == Kinds.MTH) {
                MethodSymbol m = (MethodSymbol) e.sym;
                Attribute def = m.getDefaultValue();
                if (def != null)
                    res.put(m, def);
            }
        }
        // Next find the explicit values, possibly overriding defaults.
        for (Pair<MethodSymbol, Attribute> p : anno.values)
            res.put(p.fst, p.snd);
        return res;
    }
78290
public Map<String, String> parseProperties() throws IOException
   {
      Map<String, String> replaceProperties = new HashMap<String, String>();
      ZipInputStream zip = null;
      try
      {
         zip = new ZipInputStream(archetypeIn);
         boolean ok = true;
         while (ok)
         {
            ZipEntry entry = zip.getNextEntry();
            if (entry == null)
            {
               ok = false;
            }
            else
            {
               if (!entry.isDirectory())
               {
                  String fullName = entry.getName();
                  if (fullName != null && fullName.equals("META-INF/maven/archetype-metadata.xml"))
                  {
                     parseReplaceProperties(zip, replaceProperties);
                  }
               }
               zip.closeEntry();
            }
         }
      }
      catch (Exception e)
      {
         throw new IOException(e.getMessage(), e);
      }
      finally
      {
         if (zip != null)
         {
            zip.close();
         }
      }
      return replaceProperties;
   }
1371685
protected Set<String> getSortedAppNames()
    {
        if (applList == null)
        {
            return Collections.emptySet();
        }

        Set<String> appNames = applList.keySet();

        // Per Collections.synchronizedMap javadoc, must synchronize on map when
        // iterating over any of the collection views.
        synchronized (applList)
        {
            return new TreeSet<String>(appNames);
        }
    }
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;
    }
1015199
private final Set<String> getNonSmokeAndMirrorsPropertyNameSet() {

        /* Get the names of all the properties in the JMS Property Maps */
        /* We need a copy so that we can add extra items, and so can the caller */
        Set<String> names = new HashSet<String>();

        // Add the names for the two flavours of properties, without creating lists
        // and maps unnecessarily.
        if (mayHaveJmsUserProperties()) {
            names.addAll(getJmsUserPropertyMap().keySet());
        }
        if (mayHaveMappedJmsSystemProperties()) {
            names.addAll(getJmsSystemPropertyMap().keySet());
        }

        // The MQMD properties may be in the JmsSystemPropertyMap AND the MQMSetPropertiesMap
        // however, the Set will cater for this as it doesn't allow duplicates.
        if (hasMQMDPropertiesSet()) {
            names.addAll(getMQMDSetPropertiesMap().keySet());
        }
        return names;
    }
727938
public Map<String, Integer> toMap(){
		Map<String, Integer> ret = new HashMap<>();
		ret.put("major", this.major);
		ret.put("minor", this.minor);
		ret.put("patch", this.patch);
		return ret;
	}
264209
public static <K, V, M extends Map<K, V>> Optional<M> getOptional(M map) {
        return Optional.ofNullable(map).filter(m -> m.size() > 0);
    }
518413
public static Map<String, Class<? extends ParaObject>> getCoreClassesMap() {
		if (CORE_CLASSES.isEmpty()) {
			try {
				CORE_PARA_CLASSES.putAll(SCANNER.getComponentClasses(ParaObject.class.getPackage().getName()));
				CORE_CLASSES.putAll(CORE_PARA_CLASSES);
				if (!Config.CORE_PACKAGE_NAME.isEmpty()) {
					CORE_CLASSES.putAll(SCANNER.getComponentClasses(Config.CORE_PACKAGE_NAME));
				}
				logger.debug("Found {} ParaObject classes: {}", CORE_CLASSES.size(), CORE_CLASSES);
			} catch (Exception ex) {
				logger.error(null, ex);
			}
		}
		return Collections.unmodifiableMap(CORE_CLASSES);
	}
1258402
private Map<String, TField> computeFieldNameMap(Class<?> clazz) {
        final Map<String, TField> map = new HashMap<>();

        if (isTBase(clazz)) {
            // Get the metaDataMap for this Thrift class
            @SuppressWarnings("unchecked")
            final Map<? extends TFieldIdEnum, FieldMetaData> metaDataMap =
                    FieldMetaData.getStructMetaDataMap((Class<? extends TBase<?, ?>>) clazz);

            for (Entry<? extends TFieldIdEnum, FieldMetaData> e : metaDataMap.entrySet()) {
                final String fieldName = e.getKey().getFieldName();
                final FieldMetaData metaData = e.getValue();

                final FieldValueMetaData elementMetaData;
                if (metaData.valueMetaData.isContainer()) {
                    if (metaData.valueMetaData instanceof SetMetaData) {
                        elementMetaData = ((SetMetaData) metaData.valueMetaData).elemMetaData;
                    } else if (metaData.valueMetaData instanceof ListMetaData) {
                        elementMetaData = ((ListMetaData) metaData.valueMetaData).elemMetaData;
                    } else if (metaData.valueMetaData instanceof MapMetaData) {
                        elementMetaData = ((MapMetaData) metaData.valueMetaData).valueMetaData;
                    } else {
                        // Unrecognized container type, but let's still continue processing without
                        // special enum support.
                        elementMetaData = metaData.valueMetaData;
                    }
                } else {
                    elementMetaData = metaData.valueMetaData;
                }

                if (elementMetaData instanceof EnumMetaData) {
                    classMap.put(fieldName, ((EnumMetaData) elementMetaData).enumClass);
                } else if (elementMetaData instanceof StructMetaData) {
                    classMap.put(fieldName, ((StructMetaData) elementMetaData).structClass);
                }

                // Workaround a bug in the generated thrift message read()
                // method by mapping the ENUM type to the INT32 type
                // The thrift generated parsing code requires that, when expecting
                // a value of enum, we actually parse a value of type int32. The
                // generated read() method then looks up the enum value in a map.
                final byte type = TType.ENUM == metaData.valueMetaData.type ? TType.I32
                                                                            : metaData.valueMetaData.type;

                map.put(fieldName,
                        new TField(fieldName,
                                   type,
                                   e.getKey().getThriftFieldId()));
            }
        } else { // TApplicationException
            map.put("message", new TField("message", (byte)11, (short)1));
            map.put("type", new TField("type", (byte)8, (short)2));
        }

        return map;
    }
1318187
public Map<String, String> collectValues() {

        Map<String, String> result = new HashMap<String, String>();
        for (Map.Entry<String, I_CmsFormField> entry : m_fields.entrySet()) {
            String key = entry.getKey();
            String value = null;
            I_CmsFormField field = entry.getValue();
            value = field.getModelValue();
            result.put(key, value);
        }
        return result;
    }
998199
private Map<String, String> getBundleMap() {

        Map<String, String> bundles = new HashMap<String, String>();

        if (m_bundleComponentKeyMap != null) {
            Set<TextField> fields = m_bundleComponentKeyMap.keySet();

            for (TextField field : fields) {
                bundles.put(m_bundleComponentKeyMap.get(field), field.getValue());
            }
        }
        return bundles;
    }
639064
public Map<String, Node> getTemplateNodeToMatchMap() {
    Map<String, Node> map = new HashMap<>(stringLiteralMatches);

    for (int i = 0; i < templateParams.size(); i++) {
      String name = templateParams.get(i);
      map.put(name, paramNodeMatches.get(i));
    }

    for (int i = 0; i < templateLocals.size(); i++) {
      String name = templateLocals.get(i);
      map.put(name, IR.name(localVarMatches.get(i)));
    }

    return map;
  }
970172
public Map<String, String> getFieldValues() {
		Map<String, String> values = new HashMap<>(requiredFields.length + optionalFields.length);
		for (Entry<String, ZapTextField> f : textFields.entrySet())
			values.put(f.getKey(), f.getValue().getText());
		return values;
	}

	/**
	 * Bind a mapping of field names/values to the fields in this panel. All the fields whose names
	 * have a value provided in the map get set to that value, the others get cleared.
	 * 
	 * @param fieldValues the field values
	 */
	public void bindFieldValues(Map<String, String> fieldValues) {
		for (Entry<String, ZapTextField> f : textFields.entrySet()) {
			ZapTextField field = f.getValue();
			field.setText(fieldValues.get(f.getKey()));
			field.discardAllEdits();
		}
	}