Remove and copy the MultiFormatter.

@param formatters
195625
public MultiFormatter remove(Formatter<?>... formatters) {
        if (formatter != null) {
            MultiFormatter copy = new MultiFormatter();
            copy.formatters.putAll(this.formatters);
            if (formatters != null && formatters.length > 0) {
                for (Formatter<?> formatter : formatters) {
                    if (formatter != null) {
                        Class<?> type = ClassUtils.getGenericClass(formatter.getClass());
                        if (type != null) {
                            this.formatters.remove(type);
                        }
                    }
                }
            }
            return copy;
        }
        return this;
    }
710904
private Multimap<String, I_CmsFormatterBean> getFormattersByType() {

        if (m_formattersByType == null) {
            ArrayListMultimap<String, I_CmsFormatterBean> formattersByType = ArrayListMultimap.create();
            for (I_CmsFormatterBean formatter : m_formatters.values()) {
                for (String typeName : formatter.getResourceTypeNames()) {
                    formattersByType.put(typeName, formatter);
                }
            }
            m_formattersByType = formattersByType;
        }
        Multimap<String, I_CmsFormatterBean> result = Multimaps.unmodifiableMultimap(m_formattersByType);
        return result;
    }
1148072
public static FormatterBuilder createFormatterBuilder(Properties formatterProperties) throws Exception {

        FormatterBuilder builder;
        AbstractFormatterFactory factory;

        if (formatterProperties.size() > 0) {
            String formatterClass = formatterProperties.getProperty("formatter");
            String format = formatterProperties.getProperty("format", "csv");
            Class<?> classz = Class.forName(formatterClass);
            Class<?>[] ctorParmTypes = new Class[]{ String.class, Properties.class };
            Constructor<?> ctor = classz.getDeclaredConstructor(ctorParmTypes);
            Object[] ctorParms = new Object[]{ format, formatterProperties };

            factory = new AbstractFormatterFactory() {
                @Override
                public Formatter create(String formatName, Properties props) {
                    try {
                        return (Formatter) ctor.newInstance(ctorParms);
                    }
                    catch (Exception e) {
                        VoltDB.crashLocalVoltDB("Failed to create formatter " + formatName);
                        return null;
                    }

                }
            };
            builder = new FormatterBuilder(format, formatterProperties);
        } else {
            factory = new VoltCSVFormatterFactory();
            Properties props = new Properties();
            factory.create("csv", props);
            builder = new FormatterBuilder("csv", props);
        }

        builder.setFormatterFactory(factory);
        return builder;
    }
587244
public synchronized CellFormatter registerFormatter(final String formatPattern, final CellFormatter cellFormatter) {
        return patternFormatterMap.put(formatPattern, cellFormatter);
    }
852356
public function setFormatter(Formatter $formatter)
    {
        $this->output->setFormatter($formatter);
        $this->errorOutput->setFormatter($formatter);
    }
1082779
def _set_axis_formatter(self, axis, dim, formatter):
        
        if isinstance(dim, list): dim = dim[0]
        if formatter is not None:
            pass
        elif dim.value_format:
            formatter = dim.value_format
        elif dim.type in dim.type_formatters:
            formatter = dim.type_formatters[dim.type]
        if formatter:
            axis.set_major_formatter(wrap_formatter(formatter))
1164653
protected void applyHiddenRegionFormatting(List<ITextReplacer> replacers) {
		IHiddenRegionFormatting separator = findWhitespaceThatSeparatesSemanticRegions(replacers).getFormatting();

		// 1. apply indentation 
		Integer inc = formatting.getIndentationIncrease();
		Integer dec = formatting.getIndentationDecrease();
		if (inc != null && dec != null) {
			((WhitespaceReplacer) replacers.get(0)).getFormatting().setIndentationIncrease(inc);
			((WhitespaceReplacer) replacers.get(replacers.size() - 1)).getFormatting().setIndentationDecrease(dec);
		} else if (inc != null) {
			separator.setIndentationIncrease(inc);
		} else if (dec != null) {
			separator.setIndentationDecrease(dec);
		}

		// 2. apply NewLine and space configuration to the first whitespace region that follows or contains a linewrap.  
		separator.setNewLinesDefault(formatting.getNewLineDefault());
		separator.setNewLinesMax(formatting.getNewLineMax());
		separator.setNewLinesMin(formatting.getNewLineMin());
		separator.setSpace(formatting.getSpace());

		// 3. apply the 'priority' configuration for all and set a default formatting
		for (ITextReplacer replacer : replacers)
			if (replacer instanceof WhitespaceReplacer) {
				IHiddenRegionFormatting formatting2 = ((WhitespaceReplacer) replacer).getFormatting();
				formatting2.setPriority(formatting.getPriority());
				if (formatting2 != separator) {
					formatting2.setSpace(replacer.getRegion().getOffset() > 0 ? " " : "");
					formatting2.setNewLinesMin(0);
					formatting2.setNewLinesMax(1);
				}
			}

		// 4. make sure whitespace before and after multiline comments introduce a NewLine 
		for (int i = 0; i < replacers.size(); i++) {
			ITextReplacer replacer = replacers.get(i);
			if (replacer instanceof CommentReplacer) {
				CommentReplacer commentReplacer = ((CommentReplacer) replacer);
				WhitespaceReplacer leading = (WhitespaceReplacer) replacers.get(i - 1);
				WhitespaceReplacer trailing = (WhitespaceReplacer) replacers.get(i + 1);
				commentReplacer.configureWhitespace(leading, trailing);
			}
		}
	}
1075091
public <T> void registerFormatter(final String fieldPath, final Class<T> requiredType, FieldFormatter<T> formatter) {
        ArgUtils.notEmpty(fieldPath, "fieldPath");
        ArgUtils.notNull(requiredType, "requiredType");
        ArgUtils.notNull(formatter, "formatter");
        
        this.pathMap.put(fieldPath, new FormatterHolder(requiredType, formatter));
        
    }
94046
public void format(PrintStream out, String[] headers, String[]... rows) {
        int[] columnWidth = computeEachColumnWidth(this.defaultColumnWidth, headers, rows);

        printRow(out, columnWidth, headers);
        printTableSeperatir(out, headers, columnWidth);

        for (String[] row : rows) {
            printRow(out, columnWidth, row);
        }
    }
665131
def clear(self):
        
        if self._customFormat:
            self._customFormat.clear()
        else:
            super(XSettings, self).clear()
107465
private void configureFormatter(NumberFormat formatter) {

        formatter.setGroupingUsed(groupingUsed);
        if (isMaxIntegerDigitsSet()) {
            formatter.setMaximumIntegerDigits(maxIntegerDigits);
        }
        if (isMinIntegerDigitsSet()) {
            formatter.setMinimumIntegerDigits(minIntegerDigits);
        }
        if (isMaxFractionDigitsSet()) {
            formatter.setMaximumFractionDigits(maxFractionDigits);
        }
        if (isMinFractionDigitsSet()) {
            formatter.setMinimumFractionDigits(minFractionDigits);
        }

    }
310478
@Override
    public CompareAssert withComparisonFormatter(ComparisonFormatter formatter) {
        this.formatter = formatter;
        diffBuilder.withComparisonFormatter(formatter);
        return this;
    }
856239
public void formatTo(Formatter formatter, int flags, int width,
			int precision)
	{
		formatTo(this.toString(), formatter, flags, width, precision);
	}
1319651
public function formatters($formatters = null)
    {
        if (!func_num_args()) {
            return $this->_formatters;
        }
        $this->_formatters = $formatters;
        return $this;
    }
80579
public void setFormatter(final FormatterCallback<T> formatterCallback) {
        this.formatterCallback = formatterCallback;
        if (isAttached()) {
            setFormatter(getElement());
            refresh();
        }
    }
107292
public void setDayFormatter(DayFormatter formatter) {
    adapter.setDayFormatter(formatter == null ? DayFormatter.DEFAULT : formatter);
  }
78555
protected void removeDuplicates ()
    {
        if (_size > 1) {
            int last = _values[0];
            for (int ii = 1; ii < _size; ) {
                if (_values[ii] == last) { // shift everything down 1
                    _size--;
                    System.arraycopy(_values, ii + 1, _values, ii, _size - ii);
                } else {
                    last = _values[ii++];
                }
            }
        }
    }