@param object       $object
@param string|array $property

@return bool
555058
public static function property_exists( $object, $property )
    {
        if ( !is_array( $property ) )
        {
            $property = array($property);
        }

        foreach ( $property as $_property )
        {
            if ( property_exists( $object, $_property ) )
            {
                return $_property;
            }
        }

        return false;
    }
927426
public function propertyNotVal($object, $property, $value, $message = '')
    {
        $this->assertion->setActual($object);

        return $this->assertion->to->not->have->property($property, $value, $message);
    }
343898
private function propertyExists($object, $fieldName)
    {
        if (property_exists($object, $fieldName)) {
            return true;
        }

        foreach (explode('.', $fieldName) as $field) {
            if (property_exists($object, $field)) {
                $object = $object->{$field};
                if (!is_object($object)) {
                    break;
                }
                continue;
            } else {
                return false;
            }
        }
        return true;
    }
520306
public static function email($object): bool
    {
        if (Any::isEmpty($object)) { // allow empty
            return true;
        }

        if (!Any::isLine($object)) {
            return false;
        }

        return Str::isEmail($object);
    }
1092605
public function has($object) : bool
    {
        $hash = spl_object_hash($object);

        return isset($this->objects[$hash]);
    }
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;
	}
1218363
private function readPrivateProperty($object, string $property)
    {
        $reflectionClass = new \ReflectionClass($object);
        $reflectionProperty = null;
        do {
            if ($reflectionClass->hasProperty($property)) {
                $reflectionProperty = $reflectionClass->getProperty($property);
            }
            $reflectionClass = $reflectionClass->getParentClass();
        } while ($reflectionClass);

        if ($reflectionProperty === null) {
            throw new \InvalidArgumentException("Unable to find property '".$property.'" in object of class '.get_class($object).". Please check your @URL annotation.");
        }

        $reflectionProperty->setAccessible(true);
        return $reflectionProperty->getValue($object);
    }
728889
public function __isset( $property )
    {
        // Check if property exists as a custom document property
        if ( array_key_exists( $property, $this->properties ) ||
             in_array( $property, self::$specialProperties ) )
        {
            return true;
        }

        // If none of the above checks passed, the request is invalid.
        return false;
    }
274228
public function renderProperty($object, $property = null)
    {
        if (!empty($property)) {
            $property = '.'.$property;
        }

        return $object.$property;
    }
1329506
private function isValidObjectInstance($object)
    {
        if (!is_null($this->classname) && !$this->isInstanceOrSubclassOf($object)) {
            return false;
        }

        return true;
    }
1154832
public static function readProperty($object, $property, array $access)
    {
        if (AccessInfo::METHOD === $access['type']) {
            $value = $object->{$access['name']}();
        } elseif (AccessInfo::PROPERTY === $access['type']) {
            $value = $object->{$access['name']};
        } elseif (!$access['has_property'] && property_exists($object, $property)) {
            $value = $object->$property;
        } else {
            throw new \RuntimeException($access['name']);
        }

        return $value;
    }
892267
public function getProperty(&$object, $propertyName)
    {
        $property = $this->getPropertyInstance($object, $propertyName);
        $property->setAccessible(true);

        return $property->getValue($object);
    }
256538
protected function setValue($object, $property, $value)
    {
        $reflectionClass = new ReflectionClass($object);

        if (!$reflectionClass->hasProperty($property)) {
            $object->{$property} = $value;

            return;
        }

        $reflectionProperty = $reflectionClass->getProperty($property);
        $reflectionProperty->setAccessible(true);

        $reflectionProperty->setValue($object, $value);
    }
164519
public static function getPropertyValue($object, $property)
    {
        $ref = new \ReflectionClass($object);
        $prop = static::getPrivateProperty($ref, $property);
        $prop->setAccessible(true);
        $value = $prop->getValue($object);
        $prop->setAccessible(false);

        return $value;
    }
204198
protected function isPropertyGettable($object, $propertyName)
    {
        $flag = false;

        if (ObjectAccess::isPropertyGettable($object, $propertyName)) {
            $flag = true;
            $getterMethodName = 'get' . ucfirst($propertyName);

            if (false === method_exists($object, $getterMethodName)
                && is_callable([$object, $getterMethodName])
            ) {
                try {
                    $object->$getterMethodName();
                } catch (\Exception $e) {
                    if ($e instanceof MethodNotFoundException
                        || false === $e instanceof SilentExceptionInterface
                    ) {
                        $flag = false;
                    }
                }
            }
        }

        return $flag;
    }
247190
public static function setProperty(string $property, ?object $object, $value, ?string $classOverride = null): bool
    {
        $reflectionClass = self::getReflectionClass($object, $classOverride);
        try {
            $property = $reflectionClass->getProperty($property);
            $property->setAccessible(true);
            $property->setValue($object, $value);
        } catch (Exception $e) {
            return false;
        }
        return true;
    }
158191
public function deepPropertyVal($object, $property, $value, $message = '')
    {
        $this->assertion->setActual($object);

        return $this->assertion->to->have->deep->property($property, $value, $message);
    }