Inserts the given values into the chronological placeholders

@param array ...$replacements Collection of items to insert into the string

@return $this
429180
public function format(...$replacements): Utility
    {
        $string = $this->string;

        foreach ($replacements as $index => $value) {
            if (!is_scalar($value) || (is_object($value) && !method_exists($value, '__toString'))) {
                $type = is_object($value) ? get_class($value) : gettype($value);
                throw new InvalidFormatArgumentException(
                    sprintf('Placeholder %s could not convert type %s to a string', $index, $type)
                );
            }

            $string = str_replace('{' . $index . '}', $value, $string);
        }

        return new static($string, $this->encoding);
    }
621528
public function replace(array $replacements)
    {
        foreach ($this->files() as $file) {
            (new Replacer($file))->swap($replacements);
        }
    }
368110
public function setReplacement($replacement)
    {
        if (!is_array($replacement) && !is_string($replacement)) {
            throw new Exception\InvalidArgumentException(sprintf(
                '%s expects replacement to be array or string; received "%s"',
                __METHOD__,
                (is_object($replacement) ? get_class($replacement) : gettype($replacement))
            ));
        }
        $this->options['replacement'] = $replacement;
        return $this;
    }
1286609
public function replace($items = array(), $recursive = true)
	{
		$items = (array) $items;

		if ($recursive) {
			$this->data = array_replace_recursive($this->data, $items);
		} else {
			$this->data = $items;
		}
	}
686884
private function replaceAll(array $options, array $placeholders, array $values)
    {
        foreach ($options as $key => $option) {
            $options[$key] = $this->replace($option, $placeholders, $values);
        }

        return $options;
    }
72515
public static function fillPlaceholders(string $msg, array $values)
    {
        foreach ($values as $key => $value)
            $msg = str_replace('{' . $key . '}', self::str($value), $msg);
        return $msg;
    }
1292136
public function replace(array $items): parent {
        $ac = new ArrayCover($this->_data);
        $this->_data = $ac($items);
        return $this;
    }
1076551
public function setChanges($changes)
    {
        if ($changes instanceof Records) {
            $this->changes = $changes;
        } else {
            if (is_array($changes)) {
                $changes       = new Records($changes);
                $this->changes = $changes;
            }
        }
        return $this;
    }
922816
public function addReplacers(array $replacers)
	{
		if ($replacers)
		{
			$keys = array_map('snake_case', array_keys($replacers));

			$replacers = array_combine($keys, array_values($replacers));
		}

		$this->replacers = array_merge($this->replacers, $replacers);
	}
1070904
public function setTransliterationReplacements($replacements)
        {
            if(!is_array($replacements)) {
                throw new \Thin\Exception(__METHOD__ . ': method expects a keyed array as argument.', 500);
            }
            foreach($replacements as $key => $value) {
                $this->transliteration[$key] = $value;
            }
            return $this;
        }
670711
public function addReplace($replace, $version = '*', $overwrite = false)
    {
        if (!isset($this->getReplace()->$replace) || $overwrite) {
            $this->getReplace()->$replace = $version;
        }

        return $this;
    }
216285
public function setHeaders(array $headers, $replace = false)
    {
        if ($replace) {
            $this->headers = $headers;
        } else {
            foreach ($headers as $key => $value) {
                $this->headers[$key] = $value;
            }
        }

        return $this;
    }
1099053
public function addAll($values)
    {
        if (!WF::is_array_like($values))
            throw new \DomainException("Invalid value to merge: " . WF::str($values));
        $this->addAllRecursive($values, $this);
        return $this;
    }
70532
function replacePlaceholders(array $symbols, array $placeholders = array()) {
    $placeholders = array_merge(array(
      self::SYMBOL_SPECIAL_GROUPING_SEPARATOR,
      self::SYMBOL_SPECIAL_INFINITY,
      self::SYMBOL_SPECIAL_MINUS,
      self::SYMBOL_SPECIAL_NAN,
      self::SYMBOL_SPECIAL_PLUS,
    ), $placeholders);
    $replacements = array();
    foreach (array_unique($placeholders) as $placeholder) {
      $replacements[$placeholder] = $this->getReplacement($placeholder);
    }
    foreach ($symbols as $symbol) {
      foreach ($replacements as $placeholder => $replacement) {
        if (!$symbol->replacement && $symbol->symbol == $placeholder) {
          $symbol->replacement = $replacement;
        }
      }
    }
  }
857445
public function replace(array $items): self {
        foreach ($items as $key => $value) {
            $this->has($key) && $this->set($key, $value);
        }
        return $this;
    }
1080799
public function setPunctuationReplacements($replacements)
        {
            if(!is_array($replacements)) {
                throw new \Thin\Exception(__METHOD__ . ': method expects a keyed array as argument.', 500);
            }
            foreach($replacements as $key => $value) {
                $this->punctuation[$key] = $value;
            }
            return $this;
        }
933348
protected function values(array $values)
    {
        if (is_numeric(key($values))) {
            $this->insertValues[] = $values;
        } else {
            // Reorder the submitted values to match the fields array.
            foreach ($this->insertFields as $key) {
                $insert_values[$key] = $values[$key];
            }
            $this->insertValues[] = array_values($insert_values);
        }
        return $this;
    }