Populate hive array variable with item contents
@return NULL
@param $key string
556370
function copyto($key) {
		$var=&\Base::instance()->ref($key);
		foreach ($this->item as $key=>$field)
			$var[$key]=$field;
	}
1302005
public function hmget($key) {

        $set     = $this->getKey($collection, $key, []);
        $fields  = func_get_args();
        $values  = [];

        for ($i=1; $i<count($fields); $i++){
            $field = $fields[$i];
            $values[] = isset($set[$field]) ? $set[$field]:null;
        }

        return $values;
    }
41867
public static function get($key)
    {
        $path = Cache::path($key);

        if (file_exists($path)) {
            return file_get_contents($path);
        }

        return null;
    }
942760
public function getStorageField($key)
    {
        $pos = strpos($key, $this->keySeparator);

        if ($pos) {
            return substr($key, 0, $pos);
        }

        return null;
    }
982470
static function Get($key) {
	/*//
	@argv string Key
	@argv array(string Key, ...)
	fetch a specific option or list of options.
	//*/

		// if requesting an array of keys, then return an array of values
		// indexed by their respective keys.
		if(is_array($key)) {
			$return = [];

			foreach($key as $k)
			$return[$k] = self::Get($k);

			return $return;
		}

		// else if only asking for one key return the direct value stored
		// in that key.
		else {
			if(array_key_exists($key,self::$Storage))
			return self::$Storage[$key];

			else
			return null;
		}

	}
1153840
function meta( $key )
    {
        $content = array();
        if ( file_exists( $this->MetaFileName ) )
        {
            $content = unserialize( file_get_contents( $this->MetaFileName ) );
        }
        return isset( $content[$key] ) ? $content[$key] : null;
    }
758738
protected function getCacheContent($key = null)
    {
        if (!$this->cache instanceof CacheInterface) {
            return false;
        }
        if (isset($key) && ($result = $this->cache->get($key)) !== false) {
            if (is_array($result) && isset($result['placeholders'], $result['result'])) {
                $this->addMultiPlaceholders($result['placeholders']);
                $result = $result['result'];
            }

            return $result;
        }

        return false;
    }
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 );
	}
243573
public function getArray($key)
    {
        try {
            $result = $this->get(self::DATA_ARRAY, $key);
            if (!settype($result, 'array')) {
                return null;
            }
        } catch (\Exception $e) {
            return null;
        }
        return $result;
    }
1136506
public function get($key)
    {
        $response = $this->dynamo->getItem([
            'TableName' => $this->table,
            'ConsistentRead' => false,
            'Key' => [
                $this->keyAttribute => [
                    'S' => $this->prefix.$key,
                ],
            ],
        ]);

        if (! isset($response['Item'])) {
            return;
        }

        if ($this->isExpired($response['Item'])) {
            return;
        }

        if (isset($response['Item'][$this->valueAttribute])) {
            return $this->unserialize(
                $response['Item'][$this->valueAttribute]['S'] ??
                $response['Item'][$this->valueAttribute]['N'] ??
                null
            );
        }
    }
1280790
public function getValueStored($key)
    {
        if (isset($this->storedValues[$key])) {
            return $this->storedValues[$key];
        } else {
            return null;
        }
    }
1192877
public function &offsetGet($key)
    {
        if (!isset($this->storage[$key])) {
            $this->storage[$key] = null;
        }

        return $this->storage[$key];
    }
207792
public function pluck($collection=null, $key=null) {
    list($collection, $key) = self::_wrapArgs(func_get_args(), 2);
    
    $collection = (array) self::_collection($collection);
        
    $return = array();
    foreach($collection as $item) {
      foreach($item as $k=>$v) {
        if($k === $key) $return[] = $v;
      }
    }
    return self::_wrap($return);
  }
147562
public function getMetadata($key)
    {
        if (!is_array($this->metadata)) {
            $this->metadata = json_decode(json_encode($this->metadata), true);
        }
        return (isset($this->metadata[$key])) ? $this->metadata[$key] : null;
    }
380641
public function load($key)
    {
        $data = $this->adapter->getItem($key, $success);

        if ($success && $this->automaticSerialization) {
            $data = unserialize($data);
            
            if ($data === false) {
                $this->remove($key);
            }
        }

        return $data;
    }
1041761
public function load($key)
    {
        if (file_exists($path = $this->path . $key)) {
            return unserialize(file_get_contents($path));
        }

        return null;
    }
352119
public function getDbStatement($key)
    {
        return (isset($this->data[$key])) ? $this->data[$key] : null;
    }