If at least one data has been updated.
If property name is specified, check only property.

@param  string $property
@return bool
343526
public function isUpdated($property = null)
    {
        if (null === $property) {
            return (count($this->updated) > 0);
        }

        return (isset($this->updated[$property]) && $this->updated[$property] === true);
    }
1157213
public function hasProperty(Node $node = null, $property) {
        if (!isset($node))
            return false;
        
        return ($node->getProperty($this->expand($property)) != null);
    }
1064557
public function is($property)
    {
        if (isset($this->container[$property])) {
            return 'true' === $this->container[$property];
        }

        return null;
    }
381255
public function __isset($property)
    {
        switch ($property) {
            case 'mainLocation':
            case 'content':
                return true;
        }

        if (property_exists($this, $property) || property_exists($this->innerContentInfo, $property)) {
            return true;
        }

        return parent::__isset($property);
    }
877794
public function hasPropertyMetadata($property, $index)
    {
        return isset($this->propertyMetadata[$property], $this->propertyMetadata[$property][$index]);
    }
288399
public function hasProperty($property)
    {
        return
            property_exists($this, $property)
            ||
            $this->hasAttribute($property)
            ||
            $this->hasData($property);
    }
115413
public function __isset($name)
    {
        return isset($this->properties[$name]) && !empty($this->properties[$name]);
    }
1104845
public function is_changed($property = null)
	{
		$properties = static::properties();
		$relations = static::relations();
		$property = (array) $property ?: array_merge(array_keys($properties), array_keys($relations));

		foreach ($property as $p)
		{
			if (isset($properties[$p]))
			{
				if (array_key_exists($p, $this->_original))
				{
					if ((array_key_exists('type', $properties[$p]) and $properties[$p]['type'] == 'int') or
						(array_key_exists('data_type', $properties[$p]) and $properties[$p]['data_type'] == 'int'))
					{
						if ($this->{$p} != $this->_original[$p])
						{
							return true;
						}
					}
					elseif ($this->{$p} !== $this->_original[$p])
					{
						return true;
					}
				}
				else
				{
					if (array_key_exists($p, $this->_data))
					{
						return true;
					}
				}
			}
			elseif (isset($relations[$p]))
			{
				if ($relations[$p]->singular)
				{
					if (empty($this->_original_relations[$p]) !== empty($this->_data_relations[$p])
						or ( ! empty($this->_original_relations[$p])
							and $this->_original_relations[$p] !== $this->_data_relations[$p]->implode_pk($this->{$p})))
					{
						return true;
					}
				}
				else
				{
					if (empty($this->_original_relations[$p]))
					{
						if ( ! empty($this->_data_relations[$p]))
						{
							return true;
						}
						continue;
					}

					$orig_rels = $this->_original_relations[$p];
					foreach ($this->{$p} as $rk => $r)
					{
						if ( ! in_array($r->implode_pk($r), $orig_rels))
						{
							return true;
						}
						unset($orig_rels[array_search($rk, $orig_rels)]);
					}
					if ( ! empty($orig_rels))
					{
						return true;
					}
				}
			}
			else
			{
				throw new \OutOfBoundsException('Unknown property or relation: '.$p);
			}
		}

		return false;
	}
65958
public function &__get($property)
    {
        $value = null;
        switch ($property) {
            case 'url':
                if (isset($this->settings['url']))
                    return $this->settings['url'];
                break;
            case 'frequency':
                if (isset($this->settings['frequency']))
                    return $this->settings['frequency'];
                break;
            case 'nextCheck':
                if (isset($this->settings['next_check']))
                    return $this->settings['next_check'];
                break;
            case 'request':
                return $this->request;
            case 'data':
                return $this->data;
            case 'isOffline':
                $value = isset($this->settings['offline']);
                break;
            case 'isOfflineValid':
                $value = $this->isOffline
                    && ($this->settings['offline'] === true
                        || time() < $this->settings['offline']
                    );
                break;
            case 'isValid':
                $value = false;
                if (isset($this->settings['frequency'])
                    && !empty($this->settings['frequency'])
                    && isset($this->data)
                    && !empty($this->data)
                    && is_numeric($this->data['activation_id'])
                ) {
                    $value = $this->data['expire'] === null || time() < $this->data['expire'];
                }
                break;
            case 'isEmpty':
                $value = empty($this->data);
                break;
            case 'version':
                if (isset($this->settings['version']))
                    return $this->settings['version'];
                break;
            case 'retries':
                if (isset($this->settings['retries']))
                    return $this->settings['retries'];
                break;
        }
        return $value;
    }
197660
public function dec($property, $value = 1) {
		if (isset($this->_data[$property])) {
			$this->_data[$property] -= $value;
		} else {
			$this->_data[$property] =- $value;
		}
		
		$this->_changed[$property] = true;
		
		return $this->_data[$property];
	}
920876
public function shouldSkipProperty(PropertyMetadata $property)
    {
        if ((null !== $version = $property->getSinceVersion()) && version_compare($this->version, $version, '<')) {
            return true;
        }

        if ((null !== $version = $property->getUntilVersion()) && version_compare($this->version, $version, '>')) {
            return true;
        }

        return false;
    }
677660
private function checkProperty($property = self::LOGIN_PROPERTY, $strict = false)
    {
        if (!isset($this->properties[$property])) {
            if ($strict) {
                throw new \LogicException(sprintf(
                    'Cannot get property "%s"!',
                    $property
                ));
            }

            return false;
        }

        return true;
    }
123973
public function isModified($property = null)
    {
        $result = false;
        if($row = $this->getIterator()->current()) {
            $result = $row->isModified($property);
        }

        return $result;
    }
405604
public function get(string $property) {
		
		// since our $errors property is special, we don't want to return it
		// here.  instead, it should be returned when someone calls the validate
		// method below.
		
		return property_exists($this, $property) && $property !== "errors"
			? $this->{$key}
			: null;
	}
491759
public function isValidProperty(string $property)
    {
        if (!empty($this->validProperties) && !array_key_exists($property, $this->validProperties)) {
            return false;
        }

        return true;
    }
553095
public static function hasSoftProperty(String $property=null) : Bool
	{
		return (isset($this->softProperties[$property])) ? true : false; 
	}
39350
public function checkProperty(&$property)
    {
        if (parent::checkProperty($property)) {
            if (preg_match(
                '/^(?:src|unicode-range|font-(?:family|variant|feature-settings|stretch|weight|style))$/D',
                $property)) {
                return true;
            } else {
                $this->setIsValid(false);
                $this->addValidationError("Invalid property '$property' for @font-face declaration.");
            }
        }

        return false;
    }