Determine if a value exists for a given object / hash.

@param  mixed  $object
@param  string  $backtraceHash

@return bool
434415
public static function has($object, string $backtraceHash): bool
    {
        $objectHash = static::objectHash($object);

        if (! isset(static::$values[$objectHash])) {
            return false;
        }

        return array_key_exists($backtraceHash, static::$values[$objectHash]);
    }
111355
public static function hasMethod($object, $method)
    {
        if (empty($object)) {
            return false;
        }
        if (method_exists($object, $method)) {
            return true;
        }
        return method_exists($object, 'hasMethod') && $object->hasMethod($method);
    }
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;
    }
1329506
private function isValidObjectInstance($object)
    {
        if (!is_null($this->classname) && !$this->isInstanceOrSubclassOf($object)) {
            return false;
        }

        return true;
    }
1026299
public function tmb($hash) {
		$path = $this->decode($hash);
		$stat = $this->stat($path);
		
		if (isset($stat['tmb'])) {
			return $stat['tmb'] == "1" ? $this->createTmb($path, $stat) : $stat['tmb'];
		}
		return false;
	}
116827
public function is_object_exist($bucket, $object, $opt = array()) {
		$this->assertParameterArray ( $opt );
		$opt [self::BUCKET] = $bucket;
		$opt [self::METHOD] = 'HEAD';
		$opt [self::OBJECT] = $object;
		$response = $this->get_object_info ( $bucket, $object, $opt );
		if ($response->isOK ()) {
			return true;
		} elseif ($response->status === 404) {
			return false;
		}
		return $response;
	}
1012686
public function find($path, $object = false)
    {
        return $this->from($path)->prepare()->get($object);
    }
454172
public static function hash($object, $algoOrCtx = 'md5', $raw = FALSE)
	{
		if (is_string($algoOrCtx)) {
			$ctx = hash_init($algoOrCtx);
		} else {
			$ctx = $algoOrCtx;
		}

		if (isset($object->name)) {
			hash_update($ctx, 'name');
			hash_update($ctx, (string)$object->name);
		}

		if (isset($object->insertionPoint)) {
			hash_update($ctx, 'insertionPoint');
			hash_update($ctx, (string)$object->insertionPoint);
		}

		if (isset($object->content)) {
			hash_update($ctx, 'content');
			hash_update($ctx, (string)$object->content);
		}

		if (is_string($algoOrCtx)) {
			return hash_final($ctx, $raw);
		} else {
			return null;
		}
	}
1077889
private function find($value, $add = false)
    {
        $hash = self::hash($value);
        if(array_key_exists($hash, $this->objects)) {
            return true;
        }
        else if($add) {
            $this->objects[$hash] = $value;
        }
        return false;
    }
445400
public function offsetGet($object)
    {
        $hash = spl_object_hash($object);

        if (isset($this->objects[$hash])) {
            return $this->data[$hash];
        }

        throw new \UnexpectedValueException('Object not found.');
    }
1175513
public function contains(KObjectHandlable $object)
    {
        $result = false;

        if($handle = $object->getHandle()) {
            $result = $this->__object_list->offsetExists($handle);
        }

        return $result;
    }
1303057
public function doesObjectExist($bucket, $object, $options = NULL)
    {
        $this->precheckCommon($bucket, $object, $options);
        $options[self::OSS_BUCKET] = $bucket;
        $options[self::OSS_METHOD] = self::OSS_HTTP_HEAD;
        $options[self::OSS_OBJECT] = $object;
        $response = $this->auth($options);
        $result = new ExistResult($response);
        return $result->getData();
    }
784840
public static function hash($object, $algoOrCtx = 'md5', $raw = FALSE)
	{
		if (is_string($algoOrCtx)) {
			$ctx = hash_init($algoOrCtx);
		} else {
			$ctx = $algoOrCtx;
		}

		if (isset($object->name)) {
			hash_update($ctx, 'name');
			hash_update($ctx, (string)$object->name);
		}

		if (isset($object->method)) {
			hash_update($ctx, 'method');
			foreach ($object->method instanceof \Traversable ? $object->method : (array)$object->method as $v0) {
				MethodDescriptorProtoMeta::hash($v0, $ctx);
			}
		}

		if (isset($object->options)) {
			hash_update($ctx, 'options');
			ServiceOptionsMeta::hash($object->options, $ctx);
		}

		if (is_string($algoOrCtx)) {
			return hash_final($ctx, $raw);
		} else {
			return null;
		}
	}
458819
public function equals(PlayerContract $object): bool
    {
        return static::class === get_class($object)
        && $this->id() === $object->id()
        && $this->name() === $object->name()
        && $this->wallet() === $object->wallet();
    }
711854
public function getObjectByHash($hash)
       {
            $index = array_search($hash, $this->map, true);
            if (false !== $index) {
                parent::rewind();
                while(parent::valid()) {
                    if (parent::key() === $index) {
                        return parent::current();
                    }
                    parent::next();
                }
            }
       }
1322987
private function _checkAndReturnHasOne($method, $value)
    {
        $cls = get_called_class();
        if (array_key_exists($cls, self::$_has_one)
            && array_key_exists($method, self::$_has_one[$cls])
        ) {
            return $this->_resolveHasOne($method, $value);
        }
    }
1313535
public function hasObject($object)
    {
        $oid = spl_object_hash($object);
        if (!isset($this->objectsRepository[$oid])) {
            return false;
        }
        $repository = $this->objectsRepository[$oid];
        $data = $repository->getHydrator()->unhydrate($object);
        $id = isset($data['_id']) ? serialize($data['_id']) . $repository->getCollection() : $oid;

        return isset($this->objects[$oid]) || isset($this->objects[$id]);
    }