Check if a property is valid
@param string $property
@return bool
491759
public function isValidProperty(string $property)
    {
        if (!empty($this->validProperties) && !array_key_exists($property, $this->validProperties)) {
            return false;
        }

        return true;
    }
920484
public function isValid($value)
    {
        $result = filter_var($value, FILTER_VALIDATE_EMAIL);
        if (!$result) {
            $this->addMessage('email');
        }
        return (boolean) $result;
    }
210009
public function __isset($property)
	{
		if(!$this instanceof ArrayAccess)
			throw new Exception("Unable to perform this action on objects that are not children of ArrayAccess");
		
		return $this->offsetExists($property) && $this->offsetGet($property) !== null;
	}
730439
private function existenceValidation(Property $property)
    {
        $key = $property->key;

        return [
            $key,
            'exist',
            'targetClass' => StaticValue::className(),
            'targetAttribute' => 'id',
            'allowArray' => $property->allow_multiple_values,
            'filter' => ['property_id' => $property->id],
            'skipOnEmpty' => true,
        ];

    }
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;
	}
355435
public function has($property)
    {
        foreach ((array)$property as $prop) {
            $has = $this->_parentHas($prop);

            if ($has === false) {
                $has = $this->_lazyLoad($prop);
                if ($has === null) {
                    return false;
                }
            }
        }

        return true;
    }
276361
public function isDirty($property = null)
    {
        if ($property === null) {
            return !empty($this->_dirty);
        }

        return isset($this->_dirty[$property]);
    }
137412
public function isSort($property = null)
    {
        if (is_null($property)) {
            return $this->sorts->isEmpty();
        }

        if ($this->sorts->search($property, true) !== false) {
            return true;
        }

        if ($this->sorts->search('-'.$property, true) !== false) {
            return true;
        }

        return false;
    }
1011805
protected function validateValue($property, $value)
    {
        $this->isPropertyValid($property);

        $regEx = '/^' . self::CONFIRMATION_PROPERTIES[$property] . '$/';

        if (preg_match($regEx, $value) != 1) {
            throw new InvalidArgumentException("The value " . $value . " for the property " . $property . ", is invalid");
        }

        return $value;
    }
1027648
public function __isset($property)
    {
        // getField() isn't a field-specific getter and shouldn't be treated as such
        if (strtolower($property) !== 'field' && $this->hasMethod($method = "get$property")) {
            return true;
        }
        if ($this->hasField($property)) {
            return true;
        }
        if ($this->failover) {
            return isset($this->failover->$property);
        }

        return false;
    }
1358307
public function getValidations($property)
    {
        if (is_string($property)) {
            $property = $this->_description->getProperty($property);
        }

        $name = $property->getName();

        if (!$this->_validations->$name) {
            $this->_validations->$name = new AnConfig();
        }

        return $this->_validations->$name;
    }
895797
public function __isset($property)
    {
        $name = ltrim($property, '_');
        $vars = get_object_vars($this);

        return isset($vars['_'.$name]);
    }
361198
function propertyExists($attribute, $property) {
    return array_key_exists($attribute, $this->__attributes)
        && array_key_exists($property,  $this->__attributes[$attribute]);
  }
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;
    }
661722
public function isEmpty($property)
    {
        $value = $this->get($property);
        if ($value === null
            || (is_array($value) && empty($value)
            || (is_string($value) && empty($value)))
        ) {
            return true;
        }

        return false;
    }
1022532
protected function validateValue($property, $value)
    {
        $type = $this->getType($property);
        if (!$type) {
            $this->stdErr->writeln("Property not writable: <error>$property</error>");

            return false;
        }
        $valid = true;
        $message = '';
        // @todo find out exactly how these should best be validated
        $selectedEnvironment = $this->getSelectedEnvironment();
        switch ($property) {
            case 'parent':
                if ($selectedEnvironment->id === 'master') {
                    $message = "The master environment cannot have a parent";
                    $valid = false;
                } elseif ($value === $selectedEnvironment->id) {
                    $message = "An environment cannot be the parent of itself";
                    $valid = false;
                } elseif (!$parentEnvironment = $this->api()->getEnvironment($value, $this->getSelectedProject())) {
                    $message = "Environment not found: <error>$value</error>";
                    $valid = false;
                } elseif ($parentEnvironment->parent === $selectedEnvironment->id) {
                    $valid = false;
                }
                break;
        }
        switch ($type) {
            case 'boolean':
                $valid = in_array($value, ['1', '0', 'false', 'true']);
                break;
        }
        if (!$valid) {
            if ($message) {
                $this->stdErr->writeln($message);
            } else {
                $this->stdErr->writeln("Invalid value for <error>$property</error>: $value");
            }

            return false;
        }

        return true;
    }
1215652
public function isValueValid($value) {
		return $value instanceof Type\PropertyValueType || $value instanceof DataType\TextType || $value instanceof DataType\URLType;
	}