Get the value of the given option.

@param string $categoryKey Category key
@param string $optionKey   Option key

@throws InvalidArgumentException

@return string option value
770802
public function getOption($categoryKey, $optionKey)
    {
        $this->requireOptionExists($categoryKey, $optionKey);


        return $this->options[$categoryKey][$optionKey];
    }
458299
public function useKeyAsIndexAttribute($key, $normalize = false)
    {
        if (null === $key) {
            $this->indexAttrKey = null;
            return;
        }

        if (true !== $normalize && !$this->isValidNodeName($key)) {
            throw new \InvalidArgumentException(sprintf('%s is an invalid attribute name', $key));
        }

        $this->indexAttrKey = $normalize ? $this->normalizer->normalize($key) : $key;
    }
581479
public function getParam($key)
    {
        if (!isset($this->params[$key])) {
            throw new InvalidArgumentException("The request parameter with key '$key' is invalid."); 
        }
        return $this->params[$key];
    }
830206
public function get($key)
    {
        if (!array_key_exists($key, $this->options)) {
            throw new InvalidArgumentException(sprintf('The key %s does not exist.', $key));
        }

        return $this->options[$key];
    }
914176
public function getRawValue($key)
    {
        if (!array_key_exists($key, $this->data())) {
            throw new \InvalidArgumentException(sprintf('key [%s] is not present in response array.', $key));
        }

        return $this->data()[$key];
    }
1240121
public function get_categories_display_option($optionname, $defaultvalue = null) {
        if (array_key_exists($optionname, $this->categoriesdisplayoptions)) {
            return $this->categoriesdisplayoptions[$optionname];
        } else {
            return $defaultvalue;
        }
    }
983168
protected function getHelpValue($key)
    {
        if (!isset($this->helpValues[$key])) {
            throw new \InvalidArgumentException(sprintf('The required help value "%s" doesn\'t exist.', $key));
        }

        return $this->helpValues[$key];
    }
299177
public function find(string $key): Option
    {
        // Error out if option is not found in schema.
        if (! $this->has($key)) {
            throw UnknownOptionKey::fromKey($key);
        }

        // If we already had instantiated the option, we need to make sure to use the same reference, to keep all
        // consumers in sync.
        if (! $this->identityMap->has($key)) {
            // We don't have an instance in our identity map yet, so we clone one from our schema.
            $option = clone $this->schema[$key];
            $this->identityMap->put($option, $this);
        }
        $option = $this->identityMap->getOption($key);

        // Retrieve the value from persistence, while falling back to the default value if no persisted one was found.
        // Then, cache the value so that we only hit the persistent storage once.
        if (! isset($this->values[$key])) {
            $this->values[$key] = $this->readOption($key, $this->schema[$key]->getValue() ?? null);
        }

        // Keep the value of the option up-to-date with latest changes.
        if (isset($this->values[$key])
            && $option->getValue() !== $this->values[$key]
        ) {
            $option->setValue($this->values[$key], $persist = false);
        }

        return $option;
    }
105035
public function update(User $user, $option, $categoryKey)
    {
        if (!empty($option)) {
            return $user->hasPermission('options-update-' . $categoryKey);
        }
        return false;
    }
424073
public function &__get($key)
    {
        if (!isset($this->service[$key])) {
            throw new InvalidArgumentException(sprintf('Value "%s" is not defined.', $key));
        }

        return
            isset($this->service[$key]) &&
            is_callable($this->service[$key]) ?
                $this->service[$key]($this) :
                $this->service[$key];
    }
575663
public function get(string $key)
    {
        if (!$this->has($key)) {
            throw new \InvalidArgumentException(\sprintf('The value identified by "%s" does not exist.', $key));
        }

        return $this->values[$key];
    }
836233
public static function getValue($key, $data, $allowNull = false)
    {
        if (is_object($key)) {
            $key = get_class($key);
        }

        $value = self::getViaPath($key, $data);

        if (is_null($value)) {
            if ($allowNull) {
                return null;
            }
            throw new \InvalidArgumentException(sprintf('%s does not exist in the haystack', $key));
        }

        return $value;
    }
62176
public function value($key = null)
    {
        if (!is_string($key)) {
            throw new \InvalidArgumentException("Invalid argument provided, string required!");
        } elseif(method_exists('\Illuminate\Config\Repository', 'get') &&  \Config::get('breadcrumb::' . $key, false) !== false) {
            return \Config::get('breadcrumb::' . $key, false);
        } elseif (!array_key_exists($key, $this->configs)) {
            throw new \OutOfRangeException("There is no " . $key . " key in the Configurations!");
        } else {
            return $this->configs[$key];
        }
    }
815643
public function getValue($key): Option
	{
		if ($this->containsKey($key))
		{
			return new Option($this->data[$key], true);
		}
		else
		{
			return new Option(null, false);
		}
	}
718963
function get($key) {
        if(\is_array($key) || \is_object($key)) {
            throw new \InvalidArgumentException('Key can not be an array or object');
        }
        
        $key = (string) $key;
        return parent::get($key);
    }
806993
protected function getColumnOption($column_key, $option_name, $default = NULL)
    {
        return isset($this->columns[$column_key][$option_name]) ? $this->columns[$column_key][$option_name] : value($default);
    }
1092554
public function set(string $category_key, string $config_key, string $value)
    {
        $config = ConfigCategory::where('key', $category_key)
            ->first()
            ->configs()
            ->where('key', $config_key)
            ->first();
        $config->value = $value;
        return $config->save();
    }