This method creates the {@link #getPhaseMap() phase map} used as default.

@return the {@link Map}.
19742
protected Map<String, DevelopmentPhase> createDefaultPhaseMap() {

    Map<String, DevelopmentPhase> map = new HashMap<>();
    for (DevelopmentPhase phase : DevelopmentPhase.values()) {
      putPhase(map, phase.toString(), phase);
      putPhase(map, phase.getValue(), phase);
      for (String key : phase.getAlternatives()) {
        putPhase(map, key, phase);
      }
    }
    return map;
  }
405933
public synchronized Progress addPhase() {
    Progress phase = new Progress();
    phases.add(phase);
    phase.parent = this;
    progressPerPhase = 1.0f / (float)phases.size();
    return phase;
  }
115247
public Map<String, Map<String, Object>> getBooleanMapping() {
        if (null == this.booleanMapping) {
            this.booleanMapping = new HashMap<String, Map<String, Object>>(16);
        }
        return booleanMapping;
    }
1258515
@JSFProperty(returnSignature = "void", methodSignature = "javax.faces.event.PhaseEvent",
                 jspName = "beforePhase", stateHolder=true)
    public MethodExpression getBeforePhaseListener()
    {
        return (MethodExpression) getStateHelper().eval(PropertyKeys.beforePhaseListener);
    }
205652
public static <K,V> MapFactory<K,V> noCompTree() {
	return new MapFactory<K,V>() {
    	    
            private static final long serialVersionUID = 5687187370812696757L;

	    public Map<K,V> create() { return new NoCompTreeMap<K,V>(); }
	    
	    public Map<K,V> create(Map<K,V> m) {
		if(m instanceof NoCompTreeMap/*<K,V>*/) {
		    return ((NoCompTreeMap<K,V>) m).clone();
		}
		return super.create(m);
	    }
	};
    }
1198141
public Map<K, V> getMap() {
        if (mode == StorageMode.LIST) {
            synchronized (this) {
                if (mode == StorageMode.LIST) {
                    mapData = convertListToMap(listData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableMap(mapData);
    }
472296
public FaunusPipeline map() {
        this.state.assertNotLocked();
        this.state.assertNoProperty();

        this.compiler.addMap(PropertyMapMap.Map.class,
                LongWritable.class,
                Text.class,
                PropertyMapMap.createConfiguration(this.state.getElementType()));
        makeMapReduceString(PropertyMap.class);
        this.state.lock();
        return this;
    }
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();
    }
1316087
public Map<String, String> getImageDnd() {

        if (m_imageDnd == null) {
            m_imageDnd = CmsCollectionsGenericWrapper.createLazyMap(new CmsImageDndTransformer());
        }
        return m_imageDnd;
    }
363074
public Map<T, Integer> getMap() {
    return Maps.transformEntries(this.map,
      new EntryTransformer<T, AtomicInteger, Integer>() {
        @Override
        public Integer transformEntry(final T key, final AtomicInteger value) {
          return value.get();
        }
      });
  }
1184900
public List<Class<? extends RulePhase>> getAvailablePhases() {
        ArrayList<Class<? extends RulePhase>> phases = new ArrayList<>(this.cachedPhases.values());
        // It could be sorted by the real order.
        phases.sort(new Comparator()
        {
            @Override
            public int compare(Object phaseClass1, Object phaseClass2)
            {
                if (phaseClass1 == null || !(phaseClass1 instanceof Class))
                    return -1;
                if (phaseClass2 == null || !(phaseClass2 instanceof Class))
                    return 1;

                String name1 = ((Class<? extends RulePhase>)phaseClass1).getSimpleName();
                String name2 = ((Class<? extends RulePhase>)phaseClass2).getSimpleName();
                return name1.compareToIgnoreCase(name2);
            }
        });
        return phases;
    }
693455
public Map<String, String> toMap() {
    Map<String, String> map = new HashMap<>(size());

    for (String propertyName : this) {
      map.put(propertyName, get(propertyName));
    }

    return map;
  }
472450
public static <K,V> Map<K,V> asSynchronized(Map<K,V> self) {
        return Collections.synchronizedMap(self);
    }
1289289
public static CsvMapper defaultMapper() {
		final CsvMapper mapper = new CsvMapper();
		mapper.enable(CsvParser.Feature.TRIM_SPACES);
		mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY);
		mapper.configure(JsonParser.Feature.ALLOW_YAML_COMMENTS, true);
		return mapper;
	}
374639
public Map<String, JSType> getPropertyTypeMap() {
    ImmutableMap.Builder<String, JSType> propTypeMap = ImmutableMap.builder();
    for (String name : this.getPropertyNames()) {
      propTypeMap.put(name, this.getPropertyType(name));
    }
    return propTypeMap.build();
  }
1249327
protected void putPhase(Map<String, DevelopmentPhase> map, String key, DevelopmentPhase phase) {

    String newKey = key.toLowerCase(Locale.US);
    while (newKey != null) {
      DevelopmentPhase existingPhase = map.get(newKey);
      if ((existingPhase != null) && (existingPhase != phase)) {
        throw new IllegalStateException("Development phase '" + phase + "' has key '" + newKey + "' that is already mapped to '" + existingPhase + "'.");
      }
      map.put(newKey, phase);
      if (newKey.contains("-")) {
        newKey = newKey.replace("-", "");
      } else {
        newKey = null;
      }
    }
  }
93406
@SuppressWarnings("unchecked")
    public <M extends T> Map<?, M> findMap() {
        return (Map<?, M>) query().findMap();
    }