{@inheritdoc}

@return bool
486293
public function unlock()
    {
        $this->shouldLock = false;

        if (!$handle = $this->resource()) {
            return false;
        }

        return $this->applyLock($handle);
    }
1240793
public function has($key)
    {
        $data = $this->parameters;

        foreach (explode('.', $key) as $pkey) {
            if (!array_key_exists($pkey, $data) || !is_array($data)) {
                return false;
            }

            $data = $data[$pkey];
        }

        return true;
    }
467384
public function has($key)
    {
        $value = $this->get($key);

        return ! is_null($value) && $value !== false;
    }
41751
public function has($id): bool
    {
        return isset($this->alias[$id]) ||
               isset($this->bindings[$id]) ||
               isset($this->objects[$id]);
    }
763828
public function exists() : bool
    {
        $query = static::createQuery();
        $pks = static::getPrimaryKeys();
        $pkValues = $this->getPrimaryKeyValues();

        if (count($pks) != count($pkValues)) {
            return false;
        }

        $filterFunction = function (WhereClause $whereClause) use (&$pkValues, $query) {
            foreach ($pkValues as $field => $value) {
                $whereClause->and($field, '=', '?');
                $query->bind($value);
            }
        };
        $query->where($filterFunction)
            ->count('*');

        $row = $query->execute()->fetch();

        return $row['all_count'] > 0;
    }
1339380
public function has($id)
    {
        $id = (string) $id;

        return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
    }
222321
public function methodExists($method)
    {
        $key = 'method.'.$method;

        if (!self::_cache($this)->offsetExists($key)) {
            $result = false;

            if (method_exists($this, $method)) {
                $result = true;
            } elseif (self::_cache($this)->offsetExists('behavior.'.$method)) {
                $result = self::_cache($this)->offsetGet('behavior.'.$method);
            } else {
                $behaviors = $this->getRepository()->getBehaviors();

                foreach ($behaviors as $behavior) {
                    if (in_array($method, $behavior->getMixableMethods($this))) {
                        $result = true;
                        break;
                    }
                }
            }

            self::_cache($this)->offsetSet($key, $result);
        }

        return self::_cache($this)->offsetGet($key);
    }
637435
public function has($id) {
		if (isset($this->_definitions[$id])) {
			return true;
		}
		
		return $this->getLocatorByServiceId($id) !== null;
	}
165895
public function has($key)
    {
        $keys = is_array($key) ? $key : func_get_args();

        $input = $this->all();

        foreach ($keys as $value) {
            if (! Arr::has($input, $value)) {
                return false;
            }
        }

        return true;
    }
115751
public function has($id) {
		if(array_key_exists($id, $this->instances)) {
			return true;
		}

		return $this->parent !== null ? $this->parent->has($id) : false;
	}
1342768
public function has($id) {
		$source = $id;
		while (is_string($source) && isset($this->getter[$source])) {
			$source = $this->getter[$source];
		}
		if (!is_string($source)) {
			return $source instanceof \Closure;
		} else {
			if (isset($this->instance[$source]) || class_exists($source)) {
				return true;
			}
			return false;
		}
	}
1062651
public function has($name)
    {
        if (isset($this->names[$name])) {
            return true;
        }

        $normalized = $this->normalizeName($name);

        if (isset($this->names[$normalized])) {
            return true;
        }

        foreach ($this->entries as $key => $entry) {
            if ($entry['type'] === self::ENTRY_TYPE_ABSTRACT_FACTORY && $this->hasAbstract($name, $key, $entry)) {
                return true;
            }
        }

        return false;
    }
812961
public function hasService(/*# string */ $id = '')/*# : bool */
    {
        $sid = $this->getSectionId($id);

        // direct match
        if ($this->has($sid)) {
            return true;
        }

        // autoclass
        if ($this->autoClassName($id)) {
            return true;
        }

        // translation
        if ($this->serviceTranslation($id)) {
            return true;
        }

        return false;
    }
650445
public function process()
    {
        $value = $this->value();
        if (!is_scalar($value)) {
            return false;
        }

        if (is_string($value)) {
            $value = strtolower($value);
        }

        $bool = null;
        if (in_array($value, $this->getConfig('truthy'), true)) {
            $bool = true;
        } elseif (in_array($value, $this->getConfig('falsy'), true)) {
            $bool = false;
        }

        if ($bool !== null) {
            if (!$this->manager()->getRepository() instanceof Table) {
                foreach ($this->fields() as $field) {
                    $this->getQuery()->where([
                        $field => $bool,
                    ]);
                }

                return true;
            }

            $conditions = [];
            foreach ($this->fields() as $field) {
                $conditions[] = [$field => $bool];
            }

            $this->getQuery()->andWhere([$this->getConfig('mode') => $conditions]);
        }

        return false;
    }
334911
public function has($key) {
		$keys = explode('.', $key);
		$conf = empty($this->environment) ? $this->conf : $this->conf[$this->environment];
		foreach ($keys as $v) {
			if (isset($conf[$v])) {
				$conf = $conf[$v];
			} else {
				return false;
			}
		}
		return true;
	}
41723
public function validate(): bool
    {
        foreach ($this as $element) {
            if ($element instanceof HasValueValidationInterface) {
                $element->validate();
            }
        }
        return $this->errors()->empty();
    }
381311
public function has($key){
        if($this->offsetExists($key) && (bool)$this->offsetGet($key)){
            return TRUE;
        }
        return FALSE;
    }