Set transliteration system.

@param  string   $system transliteration system
@return Settings fluent interface
2264
public function setSystem($system)
    {
        if (!in_array($system, $this->getSupportedTranliterationSystems())) {
            throw new \InvalidArgumentException(
                sprintf('Transliteration system "%s" is not supported for "%s" language.',
                    $system,
                    $this->getLang()
                )
            );
        }

        $this->system = $system;

        return $this;
    }
844655
public function setTranslator(PHPTAL_TranslationService $t)
    {
        $this->_translator = $t;
        $t->setEncoding($this->getEncoding());
        return $this;
    }
1203214
public function setIgnoreChars(string $chars): self
	{
		$this->assertCharacterClass($chars);

		$this->ignoreChars = $chars;
		$this->setOptions['ignoreChars'] = null;

		return $this;
	}
214719
static function updateSettings( $settings )
    {
        unset( $GLOBALS['eZTextCodecInternalCharsetReal'] );
        unset( $GLOBALS['eZTextCodecHTTPCharsetReal'] );
        unset( $GLOBALS['eZTextCodecCharsetCheck'] );
        $GLOBALS['eZTextCodecInternalCharset'] = $settings['internal-charset'];
        $GLOBALS['eZTextCodecHTTPCharset'] = $settings['http-charset'];
        $GLOBALS['eZTextCodecMBStringExtension'] = $settings['mbstring-extension'];
        if ( function_exists( 'mb_internal_encoding' ) )
        {
            @mb_internal_encoding( $settings['internal-charset'] );
        }
    }
150391
public function setTranslatableLang($lang)
    {
        if (is_string($lang)) {
            $lang = new Lang($lang);
        }

        $this->translatableLang = $lang;

        return $this;
    }
718617
public function setCollation($collation)
    {
        $allowedTypes = [
            AdapterInterface::PHINX_TYPE_CHAR,
            AdapterInterface::PHINX_TYPE_STRING,
            AdapterInterface::PHINX_TYPE_TEXT,
        ];
        if (!in_array($this->getType(), $allowedTypes)) {
            throw new \UnexpectedValueException('Collation may be set only for types: ' . implode(', ', $allowedTypes));
        }

        $this->collation = $collation;

        return $this;
    }
1272987
public function set($servers){
        $sentence = new SentenceUtil();
        $sentence->addCommand("/ip/dns/set");
        $sentence->setAttribute("servers", $servers);
        $this->talker->send($sentence);
        return "Sucsess";
    }
701318
public static function setLanguage($language) {

		if(false === is_string($language)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($language)), E_USER_ERROR);
		}

		self :: $language = $language;
	}
613806
public function setSupportedLanguages(array $languages)
    {
        $this->languages = $languages;
        $this->fallbackLanguage = reset($languages);

        return $this;
    }
1271010
public function setLanguage($language)
    {
        if (!Icepay_Parameter_Validation::language($language))
            throw new Exception('Please enter a valid language (ISO 639-1)', 1006);

        $this->language = $language;
        return $this;
    }
916312
public function setIsolation(string $isolation)
    {
        $this->isolation = $isolation;

        $this->hostConfig = array_merge($this->hostConfig, ['Isolation' => $isolation]);

        return $this;
    }
713290
public function setCharset($charset, $method = null)
    {
        if ($method === null) {
            $method = $this->getConfig('method');
        }

        $this->query($method . ' ' . $charset);

        return $this->getConnect()->set_charset($charset);
    }
647091
public function setWriteTranslations(array $replacements)
    {
        foreach ($this->translations as $search => $replace) {
            if (!isset($replacements[$search])) {
                $this->removeFilter($search);
                unset($this->translations[$search]);
            }
        }

        foreach ($replacements as $search => $replace) {
            if (!isset($this->translations[$search])) {
                $this->addFilter(
                    $this->replacementFactory->createFilter($search, $replace), $search
                    );
                $this->translations[$search] = true;
            }
        }
    }
1186481
public function transliterate($str) {

      $str = self::preTransliterate($str);

      // Workflow:
      //  1/ Default characters
      //  2/ Sokuon
      //  3/ Choonpu

      $str = self::transliterateDefaultCharacters($str, $this->mapping);

      $str = self::transliterateSokuon($str);

      $str = self::transliterateChoonpu($str, $this->macrons);

      return self::postTransliterate($str);
    }
1358662
protected function transliterate($entity)
    {
        $entityClass = ClassUtils::getClass($entity);

        $meta = $this->extendedMetadataFactory->getExtendedMetadata($entityClass);

        if (!isset($meta['transliteratable']) || empty($meta['transliteratable'])) {
            return;
        }

        $changeSet = $this->uow->getEntityChangeSet($entity);

        $recomputeChangeSet = false;

        foreach ($meta['transliteratable'] as $property => $params) {
            if (!isset($changeSet[$property])) {
                continue;
            }
            if (!$this->propertyAccessor->isWritable($entity, $property)) {
                throw new TransliteratableException(sprintf('Property "%s::$%s" is not writable.', $entityClass, $property));
            }

            $transliterated = $this->transliterator->transliterate(
                $changeSet[$property][1],
                $params['sanitize'],
                $params['allowedSymbols'],
                $params['separator']
            );
            $this->propertyAccessor->setValue($entity, $property, $transliterated);

            $recomputeChangeSet = true;
        }
        if ($recomputeChangeSet) {
            $this->recomputeChangeSet($entity);
        }
    }
738631
public function setCharset($charset)
    {
        if (is_string($charset)) {
            if (in_array($charset, mb_list_encodings())) {
                $this->charset = $charset;
            } else {
                throw new \InvalidArgumentException(
                    "Invalid value '" . $charset . "' for argument 'charset' given. Charset not supported."
                );
            }
        } else {
            throw new \InvalidArgumentException(
                "Invalid type '" . gettype($charset). "' for argument 'charset' given."
            );
        }

        return $this;
    }
535870
public function charset($charset = null)
    {
        if (!func_num_args()) {
            return $this->_charset;
        }
        $this->_charset = $charset ? strtoupper($charset) : null;
        return $this;
    }