Returns true if there is a value assignment or a property declaration, but which can be without an assignment.

@return bool
556835
protected function areRequirementsMet(): bool
    {
        $var = $this->token['content'];

        // We need to check everything != $this.
        if ($return = $var !== '$this') {
            $nextPos = (int) TokenHelper::findNextEffective($this->file->getBaseFile(), $this->stackPos + 1);

            if ($nextPos > 0) {
                $isProperty = PropertyHelper::isProperty($this->file->getBaseFile(), $this->stackPos);
                $nextTokenCode = $this->tokens[$nextPos]['code'];

                // The var should be followed by an "=" or can be followed by a semicolon if its a property.
                $return = ($nextTokenCode === T_EQUAL) || ($nextTokenCode === T_SEMICOLON && $isProperty);
            }
        }

        return $return;
    }
593871
public function hasValue($value)
    {
        return ! is_null($this->findValueByName($value)) || ! is_null($this->findValueById($value));
    }
470761
public function has_overrides() {
        global $DB;

        $override = $DB->record_exists('assign_overrides', array('assignid' => $this->get_instance()->id));

        if ($override) {
            return true;
        }

        return false;
    }
206841
protected function assignDefaultValues()
	{
		foreach ($this->defaultValues as $key => $value) {
			$this->model[$key] = $value;
		}

        return true;
	}
870409
public function __isset($property)
    {
        if (null !== $this->findProperty($property)) {
            return true;
        } else {
            return isset($this->$property);
        }
    }
1357557
public function hasProperty()
    {
        if (!array_key_exists($this->data[1], (array)$this->data[0])) {
            throw new DidNotMatchException();
        }

        return $this->data[0]->{$this->data[1]};
    }
459676
public function __isset($name)
    {
        foreach ($this->values as $valueObject) {
            if ($valueObject->getAttribute()->getName() == $name) {
                return true;
            }
        }

        return false;
    }
891101
public function hasCompleteExportIgnores()
    {
        $expectedExportIgnores = $this->collectExpectedExportIgnores();

        if ($expectedExportIgnores === [] || $this->hasGitattributesFile() === false) {
            return false;
        }

        $actualExportIgnores = $this->getPresentExportIgnores();

        if ($this->isStrictAlignmentCamparisonEnabled()) {
            $expectedExportIgnores = $this->getAlignedExportIgnoreArtifacts(
                $expectedExportIgnores
            );
        }

        return array_values($expectedExportIgnores) === array_values($actualExportIgnores);
    }
874188
public function doSetValue($value)
    {
        $items = $value;
        if ($value instanceof PropertyValue) {
            $items = $value->getValue();
        }

        if (null == $items) {
            return;
        }

        // check value for single value
        if (array_keys($items) !== range(0, count($items) - 1)) {
            $items = [$items];
        }

        $this->properties = [];

        for ($i = 0; $i < count($items); ++$i) {
            $item = $items[$i];
            $type = $this->initProperties($i, $item['type']);

            /** @var PropertyInterface $subProperty */
            foreach ($type->getChildProperties() as $subProperty) {
                if (!isset($item[$subProperty->getName()])) {
                    continue;
                }

                $subName = $subProperty->getName();
                $subValue = $item[$subName];

                if ($subValue instanceof PropertyValue) {
                    $subValueProperty = new PropertyValue($subName, $subValue);
                    $subProperty->setPropertyValue($subValueProperty);
                    $item[$subName] = $subValueProperty;
                } else {
                    $subProperty->setValue($subValue);
                }
            }

            $items[$i] = $item;
        }

        if ($value instanceof PropertyValue) {
            $value->setValue($items);
        }
    }
1092127
public function __isset($property)
	{
		if(!empty($property))
		{
			# generic isset check
			$call = "isset_".$property;
			
			if(method_exists($this, $call))
				return $this->{$call}() && true;
			
			# now to see if the value is set?
			$call = "getter_".$property;
			
			if(method_exists($this, $call))
				return $this->{$call}() !== null;
			
			/*
				if($this instanceof ArrayAccess)
					return $this->offsetExists($property);
			*/
		}
		
		return false;
	}
1045398
protected function hasValue()
    {
        list($start, $end) = $this->getValue();
        return $start !== null && $start !== '' && $end !== null && $end !== '';
    }
961011
public function hasObj()
    {
        if ($this->obj === null) {
            try {
                $this->obj();
            } catch (InvalidArgumentException $e) {
                return false;
            }
        }

        return !empty($this->obj);
    }
1137310
public function isKey()
    {
        $args = func_get_args();
        
        if (count($args) == 0) {
            return $this;
        }
        
        $last = array_pop($args);
        
        $pointer = &$this->data;
        foreach ($args as $i => $step) {
            if (!isset($pointer[$step])
                || !is_array($pointer[$step])
            ) {
                return false;
            }

            $pointer = &$pointer[$step];
        }
        
        if (!isset($pointer[$last])) {
            return false;
        }
        
        return true;
    }
1362514
protected function hasValue($value)
    {
        $value = (int) $value;

        return isset(static::$names[$value]) || array_key_exists($value, static::$names);
    }
1051702
protected function isValidPropertyValue($value)
    {
        return (is_scalar($value) ||
               (is_object($value) &&
                ((($value instanceof NodeInterface) && ($value->getGraph() === $this->graph)) ||
                 ($value instanceof Value))));
    }
961948
public function __isset($name)
    {
        $normalized = lcfirst($name);
        $property = "_{$normalized}";
        if (property_exists($this, $property)) {
            return true;
        }
        return false;
    }
692361
public function isArray()
    {
        return
        (
            (
                (
                    ($this->isStruct() && $this->countOwnAttributes() === 1) ||
                    (!$this->isStruct() && $this->countOwnAttributes() <= 1)
                ) &&
                mb_stripos($this->getName(), 'array') !== false
            ) ||
            (!$this->isStruct() && $this->getMetaValueFirstSet(['arraytype', 'arrayType'], false) !== false)
        );
    }