@param int $options

@return bool
549698
protected function is($options) {
        return ($this->getOutputVerbosity() & $options) === $options
            || ($this->getOutputFormat() & $options) === $options;
    }
1315417
public function setOptions($options = []) {

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

		$this -> options = array_merge($this -> options, $options);
	}
40069
public function saveIfExists(array $options = []): bool
    {
        if ($this->exists === false) {
            return false;
        }

        return $this->save($options);
    }
743762
public function isValid($value = null, array $options = []): bool
    {
        if (\count($options) > 0) {
            $this->setOptions($options);
        }
        $this->setValue($value);
        $this->errors = [];

        $validIP = $this->validateIPNumber();
        $validPrivRange = $this->validatePrivateRange();
        $validResRange = $this->validateReservedRange();

        return $validIP && $validPrivRange && $validResRange;
    }
99130
public function url(array $options) {
        if (empty($this->elementData) || filter_var($this->elementData, FILTER_VALIDATE_URL)) {
            $this->elementData = filter_var($this->elementData, FILTER_SANITIZE_URL);
            return true;
        }

        $this->addError($this->checkMessage('Value is not a valid url', $options));
        return false;
    }
184432
protected function validateOptions($options)
    {
        foreach ($options as $key => $value) {
            if (!in_array($key, $this->allowed_options)) {
                throw new FilestackException("Invalid policy option: $key:$value", 400);
            }
        }

        return true;
    }
439400
protected function optionSet(string $option) : bool
    {
        return isset($this->allOptions[$option]) && $this->allOptions[$option] === true
            || (isset($this->allOptions['all']) && $this->allOptions['all'] === true && $option !== 'overwrite' && $option !== 'prompt');
    }
534645
public function setOptions($options)
    {
        if (array_key_exists('allow', $options)) {
            $this->setAllow($options['allow']);
        }

        if (array_key_exists('idn', $options)) {
            $this->setValidateIdn($options['idn']);
        }

        if (array_key_exists('tld', $options)) {
            $this->setValidateTld($options['tld']);
        }

        if (array_key_exists('ip', $options)) {
            $this->setIpValidator($options['ip']);
        }

        return $this;
    }
969434
public function deleteBucket(array $options)
    {
        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        try {
            $this->generateAuthenticatedClient([
                'accountId' => $this->accountId,
                'bucketId'  => $options['BucketId'],
            ])->request('POST', $this->apiUrl.'/b2_delete_bucket');
        } catch (\Exception $e) {
            return false;
        }

        return true;
    }
1255866
public function delete($options)
    {
        $where = $this->parseWhere($options['where']);
        $bulk = new BulkWrite;
        if (1 == $options['limit']) {
            $deleteOptions = ['limit' => 1];
        } else {
            $deleteOptions = ['limit' => 0];
        }
        $bulk->delete($where, $deleteOptions);
        $this->log('remove', $where, $deleteOptions);
        return $bulk;
    }
209627
public function options($options)
    {
        foreach ($this->queries as $query) {
            $query->options($options);
        }

        return $this;
    }
1225954
public function addOptions($options)
    {
        if (is_array($this->options)) {
            $this->options = array_merge($this->options, $options);
        } else {
            $this->options = $options;
        }

        return $this;
    }
1097492
public function login($options = []) {
		$options = Hash::merge($this->getConfig('login'), $options);
		$this->_handleUserBeingAlreadyLoggedIn($options);
		$entity = $this->UserTable->newEntity(null, ['validate' => false]);

		if ($this->_getRequest()->is('post')) {
			$user = $this->_beforeLogin($entity, $options);
			if ($user) {
				return $this->_afterLogin($user, $options);
			} else {
				$this->handleFlashAndRedirect('error', $options);
			}
		}

		if ($options['setEntity']) {
			$this->_setViewVar('userEntity', $entity);
		}

		return false;
	}
360041
public function start(array $options = array())
    {
        if ($this->isStarted() === false) {
            // Cookie parameters must be defined before session_start()!
            if (!empty($options)) {
                $this->setCookieParams($options);
            }

            if (!session_start()) {
                return false;
            }
        }

        // Reference is important! Because we are going to deal with $_SESSION itself
        // not with its copy, or this simply won't work the way we expect
        $this->session =& $_SESSION;

        // Store unique data to validator
        $this->sessionValidator->write($this);

        return true;
    }
535979
public function isValid($value = null, array $options = []): bool
    {
        $this->setOptions($options);
        $this->setValue($value);
        $this->errors = [];

        $isValid = $this->validatePesel();

        return $isValid;
    }
925188
public function setOptions(array $options)
    {
        foreach ($options as $opt => $val) {
            $this->setOption($opt, $val);
        }

        return $this;
    }
1321247
public function delete($options = array())
    {
        $this->__preDelete();

        if ($this->_exist) {
            $deleted =  $this->_connection->remove($this->collectionName(), array("_id" => $this->getId() ), $options);
            if ($deleted) {
                $this->_exist = false;
            }
        }
        $this->__postDelete();

        return true;
    }