get map value

@param    mixed      $key        map key
@return   mixed                  map value
@throws   MapException
501125
public function get($key)
    {
        if ($this->isValidKey($key)) {
            if ($this->hasIndex($key)) {
                return $this->_map[$key];
            }
        } else {
            throw new MapException('try to access with invalid map key.', E_NOTICE);
        }
        return null;
    }
250960
public function getKeyValue($key)
    {
        return empty($this->_data[$key]) ? null: $this->_data[$key];
    }
1010123
protected function _get_array_value( $key ) {
		if ( ! isset( $this->types[ $key ] ) || 'array' !== $this->types[ $key ] ) {
			return null;
		}

		$default = array_key_exists( $key, $this->defaults ) ? $this->defaults[ $key ] : [];

		// @todo Could be taken a step further to array map strval?
		return (array) $this->store->get( $key, $default );
	}
268475
public function getContext($key) {
        return new SyncMapItemContext(
            $this->version,
            $this->solution['serviceSid'],
            $this->solution['mapSid'],
            $key
        );
    }
588547
public static function get($key)
    {
        $config = json_decode(file_get_contents(PATH . '/app/config.json'), true);

        if (! array_key_exists($key, $config)) {
            throw new ConfigItemNotSetException($key);
        }

        return $config[$key];
    }
642432
public function offsetGet($key)
    {
        if (array_key_exists($key, $this->parameters)) {

            return $this->parameters[$key];
        }
        throw new \LogicException(sprintf('Parameter "%s" is not defined.', $key));
    }
1051896
public function set($key, $value)
    {
        if (!is_null($key)) {
            if ($this->isValidKey($key)) {
                return $this->_map[$key] = $value;
            } else {
                throw new MapException('try to set with invalid map key.', E_NOTICE);
            }
        } else {
            throw new MapException('try to set mapping without key.', E_WARNING);
        }
    }
1253725
public function get($key)
    {
        if (!$this->isEnabled()) {
            return null;
        }

        $value = apc_fetch($this->prefix() . $key);

        return false === $value ? null : unserialize($value);
    }
126940
public static function map(string $key = '')
    {
        $ref = new \ReflectionClass(static::class);

        $value = $ref->getConstant($key);

        return $ref->getConstant('_LIST')[$value] ?? '';
    }
1002567
public function get($key)
    {
        $value = $this->apc->get($this->prefix.$key);

        if ($value !== false) {
            return $value;
        }
    }
1207298
public function getRequired($key)
    {
        $value = $this->get($key);
        if (null !== $value) {
            return $value;
        }
        throw new KeyException("Required value not found: $key");
    }
938525
public function get($key)
    {
        if (array_key_exists($key, $this->_map)) {
            return $this->_map[$key];
        }

        return null;

    }
1044959
public function get($key)
    {
        $connection = $this->getConnection($key);
        $this->writeToRemote(array(
            'cmd' => 'get',
            'key' => $key,
        ), $connection);
        return $this->readFromRemote($connection);
    }
682592
public function getType($key)
    {
        $map = $this->getMap();
        if (array_key_exists($key, $map)) {
            $type = $map[$key]->getType();
            return $type;
        }
        return 0;
    }
990052
public function getOrFail($key)
    {
        if (!ArrayUtility::dotExists($this->data, $this->getNormalizedKey($key))) {
            throw new InvalidPropertyException("Missing property '$key'");
        }

        return $this->get($key);
    }
215191
public static function getColumnMap($key=NULL)
    {
        if ($key) {
            return isset(self::$_keyColumnMap[$key]) ? self::$_keyColumnMap[$key] : NULL;
        } else {
            return self::$_keyColumnMap;
        }
    }
1341120
public function hGetAll($key)
    {
        $fields = $this->getDriver()->hGetAll($key);

        if (empty($fields)) {
            return $fields;
        }

        if ($this->hasMaxSize()) {
            foreach ($fields as $field => $value) {
                if ($this->isSplit($value)) {
                    $fields[$field] = $this->join($this->getMappedKey($key, $field), $value);
                }
            }
        }

        return $fields;
    }