Sets the commands processors that need to be applied to the profile.

@param OptionsInterface $options Client options.
@param ProfileInterface $profile Server profile.
511665
protected function setProcessors(OptionsInterface $options, ProfileInterface $profile)
    {
        if (isset($options->prefix) && $profile instanceof RedisProfile) {
            // NOTE: directly using __get('prefix') is actually a workaround for
            // HHVM 2.3.0. It's correct and respects the options interface, it's
            // just ugly. We will remove this hack when HHVM will fix re-entrant
            // calls to __get() once and for all.

            $profile->setProcessor($options->__get('prefix'));
        }
    }
1160716
public function setOptions(UploadOptionsInterface $options)
    {
        foreach ($options as $name => $value) {
            $setter = 'set' . str_replace('_', '', $name);
            if (method_exists($this, $setter)) {
                $this->{$setter}($value);
            }
        }
        $this->options = $options;
    }
1147192
protected function setProfile($profile)
	{
		if ( ! is_string($profile) && $profile !== null)
		{
			throw new \InvalidArgumentException('Wrong profile value.');
		}
		
		$this->profile = $profile;
		
		return $this;
	}
430649
public function setCache($type, array $options = array())
    {
        $this->cacheType = $type;
        $this->cacheOptions = $options;

        return $this;
    }
903423
public function setOptions(SettingsContainerInterface $options):BBCode{
		$this->options = $options;

		mb_internal_encoding('UTF-8');

		if(
			ini_set('pcre.backtrack_limit', $this->options->pcre_backtrack_limit) === false
			|| ini_set('pcre.recursion_limit', $this->options->pcre_recursion_limit) === false
			|| ini_set('pcre.jit', $this->options->pcre_jit) === false
		){
			throw new BBCodeException('could not alter ini settings');
		}

		if(ini_get('pcre.backtrack_limit') !== (string)$this->options->pcre_backtrack_limit
			|| ini_get('pcre.recursion_limit') !== (string)$this->options->pcre_recursion_limit
			|| ini_get('pcre.jit') !== (string)$this->options->pcre_jit
		){
			throw new BBCodeException('ini settings differ from options');
		}

		if($this->options->sanitizeInput || $this->options->sanitizeOutput){
			$this->sanitizerInterface  = new $this->options->sanitizerInterface($this->options);

			if(!$this->sanitizerInterface instanceof SanitizerInterface){
				throw new BBcodeException('invalid SanitizerInterface');
			}
		}

		if($this->options->preParse || $this->options->postParse){
			$this->parserMiddleware = new $this->options->parserMiddlewareInterface($this->options, $this->cache, $this->logger);

			if(!$this->parserMiddleware instanceof ParserMiddlewareInterface){
				throw new BBcodeException('invalid ParserMiddlewareInterface');
			}
		}

		$this->outputInterface = new $this->options->outputInterface($this->options, $this->cache, $this->logger);

		if(!$this->outputInterface instanceof BBCodeOutputInterface){
			throw new BBcodeException('invalid BBCodeOutputInterface');
		}

		$this->tags    = $this->outputInterface->getTags();
		$this->noparse = $this->outputInterface->getNoparse();
		$this->limit   = (int)$this->options->nestingLimit;

		if(is_array($this->options->allowedTags) && !empty($this->options->allowedTags)){
			$this->allowTags($this->options->allowedTags);
		}
		elseif($this->options->allowAvailableTags === true){
			$this->allowed = $this->tags;
		}

		return $this;
	}
568283
public static function configure($object, array $options): void
    {
        foreach ($options as $property => $value) {
            if (\property_exists($object, $property)) {
                $object->$property = $value;
            }
        }
    }
242969
public function setProfile($profile) {
		if (is_string($profile)) {
			$profile = new Profile($profile);
		}
		$this->profile = $profile;
		return $this;
	}
121699
public function setOptions(array $options = array())
    {
        foreach (static::$supportedOptions as $key) {
            if (isset($options[$key])) {
                $this->$key = $options[$key];
            }
        }
    }
1356018
public function setOptions(array $options = null): void
    {
        // store options by default
        $this->options = (array)$options;

        // apply options
        foreach ($this->options as $key => $value) {
            $this->setOption($key, $value);
        }
    }
360680
protected function configure(ClientInterface $client, array $options)
    {
        if (isset($options['exceptions'])) {
            $this->exceptions = (bool) $options['exceptions'];
        } else {
            $this->exceptions = $client->getOptions()->exceptions;
        }

        if (isset($options['cas'])) {
            $this->modeCAS = (bool) $options['cas'];
        }

        if (isset($options['watch']) && $keys = $options['watch']) {
            $this->watchKeys = $keys;
        }

        if (isset($options['retry'])) {
            $this->attempts = (int) $options['retry'];
        }
    }
808435
protected function configureOptions(OptionsResolver $options): void
    {
        $options->setRequired('id');
        $options->setAllowedTypes('id', ['string']);
        $options->setDefined(['date', 'time', 'useTog', 'useBus', 'useMetro']);

        $options->addAllowedTypes('date', \DateTime::class);
        $options->setAllowedValues('useTog', [0, 1]);
        $options->setAllowedValues('useBus', [0, 1]);
        $options->setAllowedValues('useMetro', [0, 1]);
    }
698229
protected function setDefaultOptions(array $options=[])
    {
        $this->text['relation_name_text'] = $this->command->paintString('relation name', 'brown');

        if (! isset($options['name'])) {
            $refModel = new ReflectionClass($this->model);
            $name = $this->getRelationName(strtolower($refModel->getShortName()));
            $name = $this->command->ask("What {$this->text['relation_name_text']} do you use?", $name);
        } else {
            $name = $options['name'];
        }
        
        $this->defaultOptions = [
            'name' => $name,
            'pivot_table' => Str::plural($name),
            'foreign_key' => $name.'_id',
            'related_key' => $this->model->getForeignKey()
        ];
    }
1024343
protected function add(SupervisorOptions $options)
    {
        app(HorizonCommandQueue::class)->push(
            MasterSupervisor::commandQueueFor($this->master),
            AddSupervisor::class,
            $options->toArray()
        );
    }
1027709
public function setProfile($profileName)
    {
        if (!isset($this->profiles[$profileName])) {
            throw new \InvalidArgumentException('Profile "'. $profileName. '" does not exist');
        }

        $this->currentProfile = $profileName;
    }
1308386
public function setAccessTokenFromProfile(TwitterProfile $profile)
    {
        $tokens = $profile->get(['access_token', 'access_token_secret']);

        if (!empty($tokens['access_token'])) {
            $this->app['twitter']->setTokens($tokens['access_token'], $tokens['access_token_secret']);
            $this->profile = $profile;
        } else {
            // use the access token from profile that referenced this profile
            $referencingProfile = $profile->relation('most_recently_referenced_by');

            // recursion would be nice here, but could be dangerous
            $tokens = $referencingProfile->get(['access_token', 'access_token_secret']);

            if ($referencingProfile->exists() && !empty($tokens['access_token'])) {
                $this->app['twitter']->setTokens($tokens['access_token'], $tokens['access_token_secret']);
                $this->profile = $referencingProfile;
            }
        }

        return $this;
    }
722229
public function setOptions($options) {
		$this->renderer->getElement()->setOptions($options);
		$this->renderer->getHtmlElement()->setOptions($options);
	}
787214
protected function _addMenu(ItemInterface $menu, array $options)
    {
        $this->_menus[$menu->getName()] = $menu;
        $this->_menuConfigurations->attach($menu, $options);
    }