Indicates whether a Pair is existing by its Key.
@access		public
@param		string		$key		Column Key
@return		bool
970476
public function offsetExists( $key )
	{
		if( !isset( $this->____pairs ) )
			$this->getPairs();
		return array_key_exists( $key, $this->____pairs );
	}
1005396
protected function has($key)
    {
        if (!is_array($key)) {
            return (array_key_exists($key, $this->item));
        }

        foreach ($key as $value) {
            if (!array_key_exists($value, $this->item)) {
                return false;
            }
        }

        return true;
    }
856790
public function has(string $key): bool
    {
        if (array_key_exists($key, $this->ttl) &&
            $this->time() - $this->ttl[$key] > 0
        ) {
            unset($this->ttl[$key]);
            unset($this->storage[$key]);

            return false;
        }

        return array_key_exists($key, $this->storage);
    }
417126
public function has($key)
    {
        $keys = explode('.', (string)$key);
        $data = &$this->data;
        foreach ($keys as $key) {
            if (!isset($data[$key])) {
                return false;
            }
            $data = &$data[$key];
        }

        return true;
    }
1297481
public function isHasMany($key)
    {
        if (false === $this->isRelationship($key)) {
            return false;
        }
        return $this->getMetadata()->getRelationship($key)->isMany();
    }
77941
public function has($key)
    {
        try {
            $ttlColumn = $this->columns['ttl'];

            return (bool) $this->db->from($this->table)
                    ->where($this->columns['key'])->eq($this->prefix . $key)
                    ->andWhere(function ($group) use ($ttlColumn) {
                        $group->where($ttlColumn)->eq(0)
                        ->orWhere($ttlColumn)->gt(time());
                    })
                    ->count();
        } catch (PDOException $e) {
            return false;
        }
    }
1141697
public function has($key)
    {
        if ($this->offsetExists($key) && (bool) $this->offsetGet($key)) {
            return true;
        }

        return false;
    }
433328
public function has(string $key): bool
    {
        $key = $this->prepareKey($key);
        return Arr::has($this->properties, $key);
    }
301211
function has($key)
    {
        return (array_key_exists($key, $this->properties)) && $this->properties[$key] !== null;
    }
1272101
public function exists( $key ) {
		return ( is_array( $this->data ) && array_key_exists( $key, $this->data ) ) ||
			( is_object( $this->data ) && property_exists( $this->data, $key ) );
	}
483447
final public function offsetExists($key)
	{
		return	array_key_exists($key, $this->_stack) && isset($this->_stack[$key]);
	}
220977
public function containsKey($key)
    {
        if (!$this->enabled)
            return false;

        $has_key = array_key_exists($this->key($key), $this->cache);

        // $this->Logger->debug("Cache contains {$key}? " . (($has_key) ? 'TRUE' : 'FALSE'));

        return $has_key;
    }
926924
public function has(string $key): bool
    {
        return $this->customTypes && $this->customTypes->has($key) || array_key_exists($key, $this->types);
    }
1349419
public function has($key)
    {
        return isset($this->data[$key]) || array_key_exists($key, $this->data);
    }
100092
public function containsKey($key)
    {
        if (strpos($key, ".") !== false) {
            //we have a dot, we need to split the ket by the dot and check
            //individual string if they are part of the nestes array
            $keys = explode('.', $key);
            $keysCount = count($keys);
            
            
            $tmpArray = $this->properties;
            foreach ($keys as $index=>$subKey) {
             
                
                if (empty($tmpArray) || empty($subKey))
                {
                    return false;
                } 
                else if ($index+1 < $keysCount)
                {
                    //arizzini: if the current $index is not the last $subKey
                    //we want to check is the $tmpArray is an array
                    $tmpArray = $this->getArrayObject($tmpArray, $subKey);
                }
                else {
//                  echo "checking if subkey=$subKey exists";
//                  print_r($tmpArray);
                    //
                    return $this->getArrayObject($tmpArray, $subKey) !== null;
                    //return array_key_exists($subKey, $tmpArray);
                    
                }
            }
        } else {
            return $this->getArrayObject($this->properties, $key) !== null;
            
        }
        
    }
308526
public function has($key): bool {
        $key = trim($key);
        $path = explode('.', $key);
        $pathLength = count($path);
        $target = &$this->data;
        for ($i = 1; $i <= $pathLength; ++$i) {
            $subKey = $path[$i - 1];

            // no such key!
            if (!isset($target[$subKey]) || ($i < $pathLength && !is_array($target[$subKey]))) {
                return false;
            }

            if ($i < $pathLength) {
                $target = &$target[$subKey];
            }
        }
        return true;
    }
379742
public function exists(string $key) : bool
    {
        $this->checkCallback();
        return isset($this->members[$key]);
    }