protected override bool ProcessObject(object obj, Type expectedType)
            {
                foreach (var unloadedObject in ItemsToReload)
                {
                    // If a collection, stop at parent path level (since index will be already removed, we will never visit the target slot)
                    // TODO: Check if the fact we didn't enter in an item with index affect visitor states
                    // Other case, stop on the actual member (since we'll just visit null)
                    var expectedPath = unloadedObject.Path.Decompose().Last().GetIndex() != null ? unloadedObject.ParentPath : unloadedObject.Path;

                    if (CurrentPath.Match(expectedPath))
                    {
                        var eventReader = new EventReader(new MemoryParser(unloadedObject.ParsingEvents));
                        var settings    = Log != null ? new SerializerContextSettings {
                            Logger = Log
                        } : null;
                        PropertyContainer properties;
                        unloadedObject.UpdatedObject = AssetYamlSerializer.Default.Deserialize(eventReader, null, unloadedObject.ExpectedType, out properties, settings);
                        // We will have broken references here because we are deserializing objects individually, so we don't pass any logger to discard warnings
                        var metadata = YamlAssetSerializer.CreateAndProcessMetadata(properties, unloadedObject.UpdatedObject, false);

                        var overrides = metadata.RetrieveMetadata(AssetObjectSerializerBackend.OverrideDictionaryKey);
                        unloadedObject.Overrides = overrides;

                        var references = metadata.RetrieveMetadata(AssetObjectSerializerBackend.ObjectReferencesKey);
                        if (references != null)
                        {
                            var basePath = YamlAssetPath.FromMemberPath(CurrentPath, root);
                            foreach (var reference in references)
                            {
                                var basePathWithIndex = basePath.Clone();
                                if (unloadedObject.GraphPathIndex != NodeIndex.Empty)
                                {
                                    if (unloadedObject.ItemId == ItemId.Empty)
                                    {
                                        basePathWithIndex.PushIndex(unloadedObject.GraphPathIndex.Value);
                                    }
                                    else
                                    {
                                        basePathWithIndex.PushItemId(unloadedObject.ItemId);
                                    }
                                }
                                var actualPath = basePathWithIndex.Append(reference.Key);
                                ObjectReferences.Set(actualPath, reference.Value);
                            }
                        }
                    }
                }
                return(false);
            }