Because we are changing the case of keys and want to use camelCase throughout the application, whenever
we do isset checks we need to ensure that we check using snake_case.

@param $key
@return mixed
348646
public function __isset($key)
    {
        return parent::__isset($key) || parent::__isset($this->getSnakeKey($key));
    }
757897
public function has( $key )
	{
		$key	= !$this->caseSensitive ? strtolower( $key ) : $key;								//  lowercase key if dictionary is not case sensitive
		return array_key_exists( $key, $this->pairs );
	}
764527
public function tryGet($key)
    {
        if (isset($this->overrides[$key])) {
            return $this->overrides[$key];
        }

        if (isset($this->defaults[$key])) {
            return $this->defaults[$key];
        }

        return null;
    }
1291233
public function getKey(string $key)
    {
        $keys = explode('.', $key);
        $file = array_shift($keys);
        $keys = explode('/', implode('.', $keys));

        if (!isset($this->translations[$file])) {
            $this->addFile($file);
        }

        return $this->findKey($file, $keys);
    }
1190924
public static function get(string $key)
    {
        if (!in_array($key, self::$allowedKeys) || !isset(self::$storedValues[$key])) {
            throw new \InvalidArgumentException('Invalid key given');
        }

        return self::$storedValues[$key];
    }
274487
function __isset($key) {
        if (!is_string($key)) {
            throw new \Calf\Exception\InvalidArgument('Key must be string.');
        }

        return isset($this->_keys[$key]);
    }
75218
public function get($key) {
        $key = $this->conf['keyPrefix'] . $key;
        $s = $this->cache->get($key);
        if ($s === false) {
            X::logger()->trace("MCache miss $key");
            return false;
        }

        X::logger()->trace("MCache hit $key");
        /** @noinspection UnserializeExploitsInspection */
        return is_numeric($s) ? $s : unserialize($s);
    }
427463
public function to($key)
    {
        $getter = 'get'.ucfirst($key);
        $hasser = 'has'.ucfirst($key);
        $isser  = 'is'.ucfirst($key);

        if (is_array($this->current) && array_key_exists($key, $this->current)) {
            $this->current = &$this->current[$key];
        } elseif ($this->isObjectWithMethod($this->current, $key)) {
            $this->current = $this->current->$key();
        } elseif ($this->isObjectWithMethod($this->current, $getter)) {
            $this->current = $this->current->$getter();
        } elseif ($this->isObjectWithMethod($this->current, 'get')) {
            $this->current = $this->current->get($key);
        } elseif ($this->isObjectWithMethod($this->current, $hasser)) {
            $this->current = $this->current->$hasser();
        } elseif ($this->isObjectWithMethod($this->current, 'has')) {
            $this->current = $this->current->has($key);
        } elseif ($this->isObjectWithMethod($this->current, $isser)) {
            $this->current = $this->current->$isser();
        } elseif ($this->isObjectWithMethod($this->current, 'is')) {
            $this->current = $this->current->is($key);
        } elseif (is_object($this->current) && isset($this->current->$key)) {
            $this->current = $this->current->$key;
        } else {
            return false;
        }

        return true;
    }
629734
private function getPropertyName($snakeCaseKey)
    {
        if (strlen($snakeCaseKey) === 0) {
            return $snakeCaseKey;
        }

        $key = str_replace(' ', '', ucwords(str_replace('_', ' ', $snakeCaseKey)));
        $key = $snakeCaseKey[0] . substr($key, 1); // Keep first character as is...

        return $key;
    }
378989
private function formatApcCacheKey($key)
    {
        $pattern = $this->getApcCacheKeyPattern();
        if (preg_match($pattern, $key, $matches)) {
            $sns = $matches['stashNS'];
            $iid = trim($matches['itemID'], ':');
            $iid = preg_replace([ '/:+/', '/\.+/' ], [ '⇒', '/' ], $iid);
            $key = $matches['stashNS'].'⇒'.$iid;
        }

        return $key;
    }
1318247
public function get(string $key)
    {
        if (!isset($this->values[$key])) {
            $value = ini_get($key);

            switch (self::CONVERSIONS[$key] ?? 0) {
                case self::CONVERT_TO_BOOL:
                    $value = Str::toBoolean($value);
                    break;
                case self::CONVERT_TO_INT:
                    $value = (int) $value;
                    break;
                case self::CONVERT_TO_BYTES:
                    $value = self::convertToBytes($value);
                    break;
            }

            $this->values[$key] = $value;
        }

        return $this->values[$key];
    }
964284
protected function parseKey(&$key) {
        $key   =  trim($key);
        if(!is_numeric($key) && !preg_match('/[,\'\"\*\(\)\[.\s]/',$key)) {
           $key = '['.$key.']';
        }
        return $key;   
    }
1228104
protected function is($key)
    {
        switch ($key = strtolower($key)) {

            case 'ajax':
                if (!isset($this->isCache['ajax'])) {
                    return $this->isCache['ajax'] = $this->getService('Request')->isXmlHttpRequest();
                }

                return $this->isCache['ajax'];

            case 'put':
            case 'delete':
            case 'post':
            case 'patch':
                if (!isset($this->isCache['requestMethod'][$key])) {
                    $this->isCache['requestMethod'][$key] = $this->getService('Request')->getMethod() === strtoupper($key);
                }

                return $this->isCache['requestMethod'][$key];

            case 'ssl':
            case 'https':
            case 'secure':
                if (!isset($this->isCache['secure'])) {
                    $this->isCache['secure'] = $this->getService('Request')->isSecure();
                }

                return $this->isCache['secure'];

            default:
                throw new \InvalidArgumentException("Invalid 'is' key supplied: {$key}");

        }
    }
493523
public function get($key)
	{
		$key = $this->normalizeKey($key);

		if (!$this->exists($key))
		{
			if ($key[0] === '#')
			{
				$this->set($key, self::getDefaultFilter(substr($key, 1)));
			}
			else
			{
				$this->set($key, new AttributeFilter($key));
			}
		}

		// Get the filter from the collection
		$filter = parent::get($key);

		// Clone it to preserve the original instance
		$filter = clone $filter;

		return $filter;
	}
832858
public function get($key)
    {
        foreach ($this->style as $style) {
            if ($code = $style->get($key)) {
                return $code;
            }
        }

        return false;
    }
1082166
public function getKeyValue($key)
    {
        foreach ($this->array as $k => $v) {
            if (strtolower($key) == strtolower($k)) {
                return $v;
            }
        }

        return '';
    }
418289
protected function _modelNameFromKey($key)
    {
        $key = str_replace('_id', '', $key);

        return Inflector::camelize(Inflector::pluralize($key));
    }