{@inheritdoc}

@param Reference $object
964294
public function guessType($object, $name, $reference, Registry $registry)
    {
        $resolved = $this->resolve($object, $this->getSchemaClass());
        $classKey = (string) $object->getMergedUri();

        if ((string) $object->getMergedUri() === (string) $object->getMergedUri()->withFragment('')) {
            $classKey .= '#';
        }

        if ($registry->hasClass($classKey)) {
            $name = $registry->getClass($classKey)->getName();
        }

        return $this->chainGuesser->guessType($resolved, $name, $classKey, $registry);
    }
547091
public function extract($object)
    {
        $this->prepare($object);

        if ($this->byValue) {
            return $this->extractByValue($object);
        }

        return $this->extractByReference($object);
    }
149080
public function loadFromArray ($object)
    {
        parent::loadFromArray($object);

        if (!empty($object->items)) {
            foreach($object->items AS &$item) {
                $Contact = new Contact();
                $Contact->loadFromArray($item);

                $item = $Contact;
            }
        }
345852
public function remove($object)
    {
        $this
            ->objectManager
            ->remove($object);

        $this
            ->objectManager
            ->flush($object);
    }
1346592
public function setRefid(Reference $r)
    {
        if ($this->path !== null) {
            throw $this->noChildrenAllowed();
        }

        $this->refid = $r;
    }
1063967
private function callObjectMethod($object, DoctrineCallback $constraint): void
    {
        $callback = (string) $constraint->callback;

        if (!method_exists($object, $callback)) {
            throw new ConstraintDefinitionException(sprintf('Method "%s" targeted by Callback constraint does not exist', $callback));
        }

        $reflMethod = new \ReflectionMethod($object, $callback);

        if ($reflMethod->isStatic()) {
            $reflMethod->invoke(null, $object, $this->context, $this->registry);
        } else {
            $reflMethod->invoke($object, $this->context, $this->registry);
        }
    }
602484
protected function doValidateObject($object)
    {
        if ($object === null || (empty($object) && $object !==0 && $object !=='0') )
            throw new \InvalidArgumentException(sprintf(
                'Object can`t be empty, given: (%s).'
                , \Poirot\Std\flatten($object)
            ));
    }
155825
public function add($object, $value)
    {
        $newValue = $object->{$this->local};

        if($newValue instanceof PropertyReference)
            $value->saveAfter($object);

        $value->set($this->foreign, $newValue);
    }
436498
public function setRefid(Reference $r)
    {
        if (!empty($this->includeList) || !empty($this->excludeList)) {
            throw $this->tooManyAttributes();
        }
        parent::setRefid($r);
    }
653378
public function remove($object, $flush = true)
    {
        $this->isExpectedObject($object);
        $this->objectManager->remove($object);
        if ($flush) {
            $this->flush();
        }
    }
698257
public static function reset($object)
	{
		if (!($object instanceof MethodDescriptorProto)) {
			throw new \InvalidArgumentException('You have to pass object of class Google\Protobuf\MethodDescriptorProto.');
		}
		$object->name = NULL;
		$object->inputType = NULL;
		$object->outputType = NULL;
		$object->options = NULL;
		$object->clientStreaming = NULL;
		$object->serverStreaming = NULL;
	}
780177
public function preUpdate($object)
    {
        $this->messageManager->addMissingTranslations($object);
        foreach ($object->getTranslations() as $translation) {
            $translation->setState(MessageTranslation::STATE_USER);
            $translation->setTranslation((string)$translation->getTranslation());
        }
    }
1320972
public static function render($object, string $context = null): void
    {
        self::$renderer->render($object, $context);
    }
783545
public function findByReference(Reference $reference)
    {
        try {
            $object = $this->getCachedDataByReference($reference);
        } catch (CacheMissException $e) {
            if ($object = $this->rm->getRepositoryForClassName($reference->getClassName())->findById($reference->getId())) {
                $object = clone $object;
                $this->setCachedData($reference->getClassName(), $reference->getId(), $object);
                $this->mm->getMetadataForObject($object)->prepareToLoad($this, $object);
            }
        }

        return $object;
    }
895810
private function objectDereference(Node $object) {
    while ($this->currentType === T_OBJECT_OPERATOR) {
      $operator_node = new PartialNode();
      $this->mustMatch(T_OBJECT_OPERATOR, $operator_node, 'operator');

      $object_property = $this->objectProperty();
      if ($this->currentType === '(') {
        $node = new ObjectMethodCallNode();
        $node->addChild($object, 'object');
        $node->mergeNode($operator_node);
        $node->addChild($object_property, 'methodName');
        $this->functionCallParameterList($node);
        $node = $this->arrayDeference($node);
      }
      else {
        $node = new ObjectPropertyNode();
        $node->addChild($object, 'object');
        $node->mergeNode($operator_node);
        $node->addChild($object_property, 'property');
        $node = $this->offsetVariable($node);
        if ($this->currentType === '(') {
          $call = new CallbackCallNode();
          $call->addChild($node, 'callback');
          $this->functionCallParameterList($call);
          $node = $this->arrayDeference($call);
        }
      }
      $object = $node;
    }

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

        return true;
    }
317799
public function offsetUnset($object)
       {
            if (parent::contains($object)) {
                parent::offsetUnset($object);
                $index = array_search(spl_object_hash($object), $this->map, true);
                unset($this->map[$index]);
            }
       }