Adds a FormatFinder to the chain.

@param \Nasumilu\Geometry\Builder\Serializer\FormatFinder $finder
165272
public function addFinder(FormatFinder ...$finder) {
        foreach ($finder as $f) {
            if (false === array_search($f, $this->finders, true)) {
                $this->finders[] = $f;
            }
        }
    }
1272504
protected function addFormatter(&$manager, $model, $formatter)
    {
        // Get the config
        $config = (include $this->configPath . '/' . $model . '.php');

        if(!isset($config[$formatter]))
            return;

        $formatterClass = 'kriskbx\mikado\Formatters\\' . $formatter;

        if (is_array($config[$formatter]) && count($config[$formatter]) > 0) {
            $manager->add(new $formatterClass($config[$formatter]));
        }
    }
409358
public function copyDir($from,$to,Finder $finder)
    {
        /* @var \Symfony\Component\Finder\SplFileInfo $path */

        $finder->in($from);
        foreach ($finder->files() as $path) {
            $targetDir = $to.DIRECTORY_SEPARATOR.$path->getRelativePath();
            if (!is_dir($targetDir)) {
                mkdir($targetDir,0755,true);
            }
            $target = $to.DIRECTORY_SEPARATOR.$path->getRelativePathname();
            copy($path->getRealPath(),$target);
        }
    }
742855
public function addExtension($extension)
    {
        /** @var ViewFinderInterface $viewFinder */
        foreach ($this->viewFinders as $viewFinder) {
            try {
                $viewFinder->addExtension($extension);
            } catch (\Exception $e) {
            }
        }
    }
1304882
public function withFormatter(string $formatters): object
    {
        $this->withParams['f'] = array_merge($this->withParams['f'], array_map('trim', explode(',', $formatters)));
        return $this;
    }
368851
protected function dynamicSegmenter($finder, $all)
    {
        $splitOn    =   true === $all
            ? 'And'
            : 'Or';
        $pattern    =   "/($splitOn)(?=[A-Z])/";
        $segments   =   preg_split(
            $pattern,
            $finder,
            -1,
            PREG_SPLIT_DELIM_CAPTURE
        );

        $segments   =   array_where(
            $segments, 
            function ($key, $segment) use ($splitOn) {
                return $segment !== $splitOn;
            }
        );

        $segments   =   array_map('str_slug', $segments, ['_']);

        // foreach ($segments as $segment) {
        //     if ($segment !== $splitOn) {
        //         $return[]   =   snake_case($segment);
        //     }
        // }

        return $segments;
    }
27714
public function setFormatter(\Symfony\Component\Console\Formatter\OutputFormatterInterface $formatter)
    {
        $this->decoratedOutput->setFormatter($formatter);
    }
921077
protected function add_format($format) {
        if (in_array($format, $this->supportedformats)) {
            return;
        }
        $this->supportedformats = portfolio_most_specific_formats(array($format), $this->supportedformats);
    }
107371
public function insertAfter( FormattingElement $a, FormattingElement $b ) {
		if ( $this->head !== $a && !$a->prevAFE ) {
			throw new TreeBuilderError(
				"Attempted to insert after an element which is not in the AFE list" );
		}
		if ( $this->tail === $a ) {
			$this->tail = $b;
		}
		if ( $a->nextAFE ) {
			$a->nextAFE->prevAFE = $b;
		}
		$b->nextAFE = $a->nextAFE;
		$b->prevAFE = $a;
		$a->nextAFE = $b;
		if ( $b instanceof Element ) {
			$this->addToNoahList( $b );
		}
	}
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);
        }

    }
1053791
public function postFind(Event $event, array &$results, $finder) {
        if (!in_array($finder, ['first', 'all'])) {
            return;
        }

        $repo = $this->getRepository();
        $converters = $this->getConverters();

        foreach ($results as $i => $result) {
            foreach ($result as $key => $value) {
                if (empty($converters[$key])) {
                    continue;
                }

                $converter = $converters[$key];

                // Exit if decoding should not happen
                if (!$converter['decode']) {
                    continue;
                }

                switch ($converter['type']) {
                    case self::SERIALIZE:   $value = $this->fromSerialize($value, $converter); break;
                    case self::JSON:        $value = $this->fromJson($value, $converter); break;
                    case self::BASE64:      $value = $this->fromBase64($value, $converter); break;
                    case self::CUSTOM:
                        if (method_exists($repo, $converter['decode'])) {
                            $value = call_user_func_array([$repo, $converter['decode']], [$value, $converter]);
                        }
                    break;
                }

                $results[$i][$key] = $value;
            }
        }
    }
211613
public function applyTitleSearch($finder, $fieldName = 'name')
    {
        $search = $this->state->get('filter.search');

        if (!empty($search)) {
            if (stripos($search, 'id:') === 0) {
                $finder = $finder->with('id', Operator::EQUAL, (int)substr($search, 3));
            } else {
                $finder = $finder->with($fieldName, Operator::CONTAINS, $search);
            }
        }

        return $finder;
    }
665950
public function addFormatters(FormatterInterface ...$formatters): self
    {
        foreach ($formatters as $formatter) {
            foreach ($formatter->contentTypes() as $contentType) {
                $this->formatters[$contentType] = $formatter;
            }
        }

        return $this;
    }
224665
public function addMatcher($name, $matcher)
    {
        if (is_callable($matcher)) {
            $this->matchers[$name] = $matcher;
        }

        return $this;
    }
1009889
public function standard(&$rootDoc, $formatter)
    {

        // set doclet options
        $this->_rootDoc =& $rootDoc;
        $phpdoctor =& $rootDoc->phpdoctor();
        $options =& $rootDoc->options();

        $this->formatter = $formatter;

        if (isset($options['d'])) {
            $this->_d = $phpdoctor->makeAbsolutePath($options['d'], $phpdoctor->sourcePath());
        } elseif (isset($options['output_dir'])) {
            $this->_d = $phpdoctor->makeAbsolutePath($options['output_dir'], $phpdoctor->sourcePath());
        } else {
            $this->_d = $phpdoctor->makeAbsolutePath('apidocs', $phpdoctor->sourcePath());
        }
        $this->_d = $phpdoctor->fixPath($this->_d);

        if (is_dir($this->_d)) {
            $phpdoctor->warning('Output directory already exists, overwriting');
        } else {
            mkdir($this->_d);
        }
        $phpdoctor->verbose('Setting output directory to "'.$this->_d.'"');

        if (isset($options['windowtitle'])) $this->_windowTitle = $options['windowtitle'];
        if (isset($options['doctitle'])) $this->_docTitle = $options['doctitle'];
        if (isset($options['header'])) $this->_header = $options['header'];
        if (isset($options['footer'])) $this->_footer = $options['footer'];
        if (isset($options['bottom'])) $this->_bottom = $options['bottom'];

        if (isset($options['tree'])) $this->_tree = $options['tree'];

        if (isset($options['include_source'])) $this->_includeSource = $options['include_source'];
        if ($this->_includeSource) {
            @include_once 'geshi/geshi.php';
            if (!class_exists('GeSHi')) {
                $phpdoctor->warning('Could not find GeSHi in "geshi/geshi.php", not pretty printing source');
            }
        }

        // write frame
        $frameOutputWriter =& new frameOutputWriter($this);

        // write overview summary
        $packageIndexWriter =& new packageIndexWriter($this);

        // write package overview frame
        $packageIndexFrameWriter =& new packageIndexFrameWriter($this);

        // write package summaries
        $packageWriter =& new packageWriter($this);

        // write package frame
        $packageFrameWriter =& new packageFrameWriter($this);

        // write classes
        $classWriter =& new classWriter($this);

        // write global functions
        $functionWriter =& new functionWriter($this);

        // write global variables
        $globalWriter =& new globalWriter($this);

        // write index
        $indexWriter =& new indexWriter($this);

        // write deprecated index
        $deprecatedWriter =& new deprecatedWriter($this);

        // write todo index
        $todoWriter =& new todoWriter($this);

        // write source files
        if ($this->_includeSource) {
            $sourceWriter =& new sourceWriter($this);
        }

        // copy stylesheet
        $phpdoctor->message('Copying stylesheet');
        copy($phpdoctor->docletPath().'stylesheet.css', $this->_d.'stylesheet.css');

    }
575427
public function setFormatter(FormatterInterface $formatter)
    {
        foreach ($this->results as $name) {
            $this->columns->offsetGet($name)->setFormatter($formatter);
        }

        return $this;
    }
745274
public function format($formatter, array $arguments = [])
    {
        $generator = $this->getGenerator();

        return function () use ($generator, $formatter, $arguments) {
            return $generator->format($formatter, $arguments);
        };
    }