Try to determined what object type the given objectData belongs to and return that type.

@param ObjectDataInterface $objectData
@return ObjectTypeInterface|null The object type or <code>null</code> if type could not be determined
764656
public function getTypeFromObjectData(ObjectDataInterface $objectData)
    {
        if ($objectData->getProperties() === null || count($objectData->getProperties()->getProperties()) === 0) {
            return null;
        }

        $typeProperty = $objectData->getProperties()->getProperties()[PropertyIds::OBJECT_TYPE_ID];

        if (!$typeProperty instanceof PropertyId) {
            return null;
        }

        return $this->session->getTypeDefinition($typeProperty->getFirstValue());
    }
1060314
public function visitObjectType(ObjectType $type)
    {
        $difference = $this->comparePrimaryType($type);

        if (0 !== $difference) {
            return $difference;
        }

        return $this->compareAttribute($this->type->ofType(), $type->ofType());
    }
1110892
public function getObjectData(Varien_Object $object, $key = null)
    {
        if ($key) {
            return $object->getDataUsingMethod($key);
        } else {
            return $object->getData();
        }
    }
819609
protected function loadObject($objectTypePath, array $objectInfo)
    {
        $objectTypeInfo = explode(IObjectType::PATH_SEPARATOR, $objectTypePath, 2);
        if (count($objectTypeInfo) < 2) {
            throw new LoadEntityException($this->translate(
                'Cannot load object from data row. Object type path "{path}" is not correct.',
                ['path' => $objectTypePath]
            ));
        }

        list($objectCollectionName, $objectTypeName) = $objectTypeInfo;
        $objectCollection = $this->getCollectionManager()
            ->getCollection($objectCollectionName);
        $objectType = $objectCollection->getMetadata()
            ->getType($objectTypeName);

        $object = $objectCollection->loadObject($objectType, $objectInfo);

        return $object;
    }
756056
public function getFieldsByDatatype($objectName, $datatype)
    {
        $datatypeFieldConfigurations = array();

        $fieldConfigurations = $this->getFields($objectName);
        foreach ($fieldConfigurations as $fieldConfiguration) {
            if ($fieldConfiguration['datatype'] == $datatype) {
                $datatypeFieldConfigurations[] = $fieldConfiguration;
            }
        }

        return $datatypeFieldConfigurations;
    }
883002
public function makeData(Data $data): ?DataObjectFormat
    {
        if (!$data->isInstanceOf(Data::class)) {
            return null;
        }

        return DataObjectFormat::make($data);
    }
710032
public function convertObjectParentData(array $data = null)
    {
        if (empty($data)) {
            return null;
        }
        $parent = new ObjectParentData();

        $object = $this->convertObject($data[JSONConstants::JSON_OBJECTPARENTS_OBJECT] ?? null);
        if ($object !== null) {
            $parent->setObject($object);
        }

        $parent->setRelativePathSegment((string) ($data[JSONConstants::JSON_OBJECTPARENTS_RELATIVE_PATH_SEGMENT] ?? ''));
        $parent->setExtensions($this->convertExtension($data, JSONConstants::getObjectParentsKeys()));

        return $parent;
    }
1313691
public function determineObjectLanguage($objectString)
    {
        $atPos = strpos($objectString, '"@');

        // check for language @
        if (false !== $atPos) {
            $language = substr($objectString, $atPos + 2);

            return 2 <= strlen($language) ? $language : null;
        }

        return null;
    }
962535
public static function getEntityClassFromObjectID($objectID)
    {
        $type = explode('::', $objectID)[0];

        if (in_array($type, static::getEntities(), true)) {
            return $type;
        }

        throw new EntityNotFoundInObjectID("Entity class from ObjectID {$objectID} not found.");
    }
111391
public function determineListDisplayStrategy(ModelRelationData $data)
    {
        switch ($data->type) {

            case RelationType::BELONGS_TO:
            case RelationType::BELONGS_TO_THROUGH:
            case RelationType::HAS_ONE:
            case RelationType::MORPH_ONE:
            case RelationType::MORPH_TO:
                return ListDisplayStrategy::RELATION_REFERENCE;

            case RelationType::BELONGS_TO_MANY:
            case RelationType::HAS_MANY:
            case RelationType::MORPH_MANY:
            case RelationType::MORPH_TO_MANY:
            case RelationType::MORPHED_BY_MANY:
                return ListDisplayStrategy::RELATION_COUNT;
        }

        return null;
    }
1353764
protected function convertObject($data)
    {

        if ($this->isIgnoredObject($data)) {
            return;
        }

        if ($this->isXMLElement($data)) {
            return $data;
        }

        $reflection = new ReflectionObject($data);

        if ($this->isArrayAble($reflection)) {
            $data = $data->toArray();
            return $this->ensureBuildable($data);
        }

        if ($this->isCircularReference($data)) {
            return;
        }

        $out = [];

        $methods    = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);
        $properties = $reflection->getProperties(ReflectionProperty::IS_PUBLIC);

        $this->getObjectGetterValues($methods, $data, $out);

        $this->setObjectProperties($properties, $data, $out);

        return $out;
    }
566476
public function parseType(Object\TypeObjectInterface $type, $data)
    {
        if($type instanceof Object\ReferentialInterface && $type->hasRef()) {
            $objectType = $type->getRef();
            $type = $this->resolveReference($type);
        } else {
            try {
                $objectType = $type->getType();
            } catch(SwaggerException\MissingDocumentPropertyException $e) {
                $objectType = null;
            }
        }
        
        if($objectType == 'array') {
            $schemaObject = [];
            
            $arrayItemType = $type->getItems();
            
            foreach($data as $key => $value) {
                $schemaObject[$key] = $this->parseType($arrayItemType, $value);
            }
        } elseif($type instanceof Object\Schema) {
            $schemaObject = new SchemaObject($objectType);
        
            foreach(array_keys(get_object_vars($data)) as $propertyKey) {
                try {
                    $propertySchema = $this->findSchemaForProperty($type, $propertyKey);
                } catch(SwaggerException\MissingDocumentPropertyException $e) {
                    throw (new SwaggerException\UndefinedPropertySchemaException)
                        ->setPropertyName($name)
                        ->setSchema($type);
                }
            
                $propertyValue = $this->parseType(
                    $propertySchema,
                    $data->$propertyKey
                );
                
                $schemaObject->setProperty($propertyKey, $propertyValue);
            }
        } else {
            $schemaObject = $data;
        }
        
        return $schemaObject;
    }
372517
protected function createNodeForVariant(NodeData $nodeData): NodeInterface
    {
        $contextProperties = $this->context->getProperties();
        $contextProperties['dimensions'] = $nodeData->getDimensionValues();
        unset($contextProperties['targetDimensions']);
        $adjustedContext = $this->contextFactory->create($contextProperties);

        return $this->nodeFactory->createFromNodeData($nodeData, $adjustedContext);
    }
1047594
public function updateObjectState(
        ObjectStateUpdateData $data = null,
        ?string $name = null
    ): FormInterface {
        $name = $name ?: sprintf('update-object-state-%d', $data->getObjectState()->id);

        return $this->formFactory->createNamed($name, ObjectStateUpdateType::class, $data);
    }
616200
public static function load($fieldData, $objectClass = null)
    {
        //====================================================================//
        // Decode Object Type & Id
        $objectType = self::objectType($fieldData);
        $objectId = self::objectId($fieldData);
        if (!$objectType || !$objectId) {
            return null;
        }
        //====================================================================//
        // Load Splash Object
        $splashObject = Splash::object($objectType);
        if (empty($splashObject)) {
            return null;
        }
        //====================================================================//
        // Ensure Splash Object uses InteliParserTrait
        if (!in_array(IntelParserTrait::class, class_uses($splashObject), true)) {
            return null;
        }
        if (!method_exists($splashObject, 'load')) {
            return null;
        }
        //====================================================================//
        // Load Remote Object
        $remoteObject = $splashObject->load($objectId);
        if (!$remoteObject) {
            return null;
        }
        //====================================================================//
        // Verify Remote Object
        if (!empty($objectClass) && !($remoteObject instanceof $objectClass)) {
            return null;
        }
        //====================================================================//
        // Return Remote Object
        return   $remoteObject;
    }
312346
public function getDataType(string $dataTypeHandle)
    {
        if (!isset($this->dataTypes[$dataTypeHandle])) {
            Schematic::error('DataType '.$dataTypeHandle.' is not registered');

            return null;
        }

        $dataTypeClass = $this->dataTypes[$dataTypeHandle];
        if (!class_exists($dataTypeClass)) {
            Schematic::error('Class '.$dataTypeClass.' does not exist');

            return null;
        }

        $dataType = new $dataTypeClass();
        if (!$dataType instanceof DataTypeInterface) {
            Schematic::error($dataTypeClass.' does not implement DataTypeInterface');

            return null;
        }

        return $dataType;
    }
18125
public function mapToObjects(array $objectsData)
    {
        $objects = [];
        foreach ($objectsData as $objectData) {
            $objects[] = $this->mapToObject($objectData);
        }

        return $objects;
    }