Checks if the component is enabled

@param   string   $option  The component option.
@param   boolean  $strict  If set and the component does not exist, false will be returned.
@return  boolean
164810
public function isEnabled($option, $strict = false)
	{
		$result = $this->load($option, $strict);

		return ($result->enabled == 1);// | $this->app->isAdmin());
	}
961087
public function match($value, string $field, bool $strict = false): bool
    {
        if ($strict) {
            return $value === $this->getValidator()->getValue($field, null);
        }

        return $value == $this->getValidator()->getValue($field, null);
    }
447145
public function isShipped( $strict = true ) {

		if( $strict ) {

			return $this->status == self::STATUS_SHIPPED;
		}

		return $this->status >= self::STATUS_SHIPPED;
	}
861765
public static function equals($value, $required, $strict = false)
    {
        return Validator::equals($value, $strict)->validate($required);
    }
1117441
protected function isSelected($option)
	{
		if(!$this->multiple && $this->isSelectedSet)
		{
			return '';
		}

		$check = parent::isSelected($option);

		$this->isSelectedSet = ($check != '');

		return $check;
	}
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');
    }
1222535
public static function enable($option) {

		if(false === is_int($option)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type integer, "%s" given', __METHOD__, gettype($option)), E_USER_ERROR);
		}
		
		static :: $options[$option] = true;
	}
1155192
public static function isEmpty($line, $strict = false)
    {
        if (!is_array($line)) {
            throw new \RuntimeException("got a string that should already have been split into an array");
        }
        $test = array_filter($line, function ($element) use ($strict) {
            return !Reader::isEmpty($element, $strict);
        });
        return empty($test);
    }
505479
public function contains($value, $strict = TRUE)
    {
        return $this->containsIn($value, $strict, $this->all());
    }
920846
protected function matchIncrementalOption(IOption $option, array $groupedArgs, $strict) {
        if (array_has($groupedArgs, $option->getNameOrAlias())) {
            $values = array_take($groupedArgs, $option->getNameOrAlias());
            $optionCount = array_get($groupedArgs, s('options.%s', $option->getNameOrAlias()), 0);
            $valueProvided = false;

            foreach ($values as $value) {
                if (is_numeric($value)) {
                    $option->setValue(intval($value));
                    $valueProvided = true;
                }
            }

            if ( ! $valueProvided) {
                $option->setValue($optionCount);
            }
        }

        return $groupedArgs;
    }
437682
public static function has($key, $strict = false)
    {
        $isset = isset($_COOKIE[$key]);

        if (!$strict) {
            return $isset;
        }

        if ($isset) {
            $isset = $isset && !empty($_COOKIE[$key]);
        }

        return $isset;
    }
1048206
public function matchOption(IOption $option, array $groupedArgs, $strict = true) {
        $groupedArgs = $this->argumentsParser
            ->mergeNameAndAlias($groupedArgs, $option->getName(), $option->getAlias());

        if ($option->isIncremental()) {
            $groupedArgs = $this->matchIncrementalOption($option, $groupedArgs, $strict);
        } else if ($option->isBoolean()) {
            $groupedArgs = $this->matchBooleanOption($option, $groupedArgs, $strict);
        } else {
            $groupedArgs = $this->matchRegularOption($option, $groupedArgs, $strict);
        }

        return $groupedArgs;
    }
895909
public function contains($value, $key = null, $strict = false)
    {
        if ($key !== null) {
            foreach ($this->items as $item) {
                $v = isset($item[$key]) ? $item[$key] : null;
                if ((!$strict && $v == $value) || $v === $value) {
                    return true;
                }
            }
            return false;
        }

        if ($this->useAsCallable($value)) {
            return $this->first($value) !== null;
        }

        return in_array($value, $this->items, $strict);
    }
600291
public function enableSSL($strict = false)
    {
        $this->setScheme(self::SCHEME_SSL);
        if ($strict === false) {
            $this->setOption(CURLOPT_SSL_VERIFYPEER, 0);
            $this->setOption(CURLOPT_SSL_VERIFYHOST, 0);
        } else {
            $this->setOption(CURLOPT_SSL_VERIFYPEER, 0);
            $this->setOption(CURLOPT_SSL_VERIFYHOST, 1);
        }
    }
1241321
public function compare($strict = false)
    {
        $compare2 = $this->compare2;

        if (is_string($this->compare2)) {
            $compare2 = explode($this->separator, $this->compare2);

            $compare2 = array_map('trim', $compare2);
        }

        return CompareHelper::compare($this->compare1, $this->operator, $compare2, $strict);
    }
216097
public function contains($field, $value, $strict = false)
    {
        return in_array($value, $this->$field, $strict);
    }
818845
public function inEnum($enum, $strict = true) {
        if (!$this->_isValid) {
            return $this;
        }
        if (!in_array($this->_unsafeVar, $enum, $strict)) {
            $this->_isValid = false;
        }
        return $this;
    }