Add a fixture object instance to the loader.

@param Neo4jFixtureInterface $fixture
424246
public function addFixture(Neo4jFixtureInterface $fixture)
    {
        $fixtureClass = get_class($fixture);

        if (isset($this->fixtures[$fixtureClass])) {
            return;
        }

        $this->fixtures[$fixtureClass] = $fixture;

        if ($fixture instanceof Neo4jDependentFixtureInterface) {
            $this->orderFixturesByDependencies = true;

            foreach ($fixture->getDependencies() as $class) {
                if (class_exists($class)) {
                    $this->addFixture(new $class());
                }
            }
        }
    }
583585
public function add(ItemInterface $item)
    {
        if ($this->has($item->getId()) === true) {
            throw new \RuntimeException(sprintf('A previous item exists with the same id: "%s".', $item->getId()));
        }

        $this->set($item);
    }
205189
@Override
	public Fixture addObjects(Object... objectsToAdd) {
		if (0 < objectsToAdd.length) {
			Collections.addAll(objects, objectsToAdd);
		}

		return this;
	}
747465
public function addConfiguration(ConfigurationInterface $configuration)
    {
        // Clear the parent map.
        $this->parentMap = null;

        $id = $configuration->getResourceId();

        if (array_key_exists($id, $this->configurations)) {
            throw new \RuntimeException(sprintf("Configuration for resource '%s' is already registered.", $id));
        }

        $this->configurations[$id] = $configuration;
    }
750002
public function populateFields(DataObject $object, $data, $fixtures)
    {
        // Iterate Data:
        
        foreach ($data as $name => $value) {
            
            if ($this->isField($object, $name)) {
                $this->populateField($object, $name, $value);
            }
            
        }
        
        // Answer Object:
        
        return $object;
    }
424040
public function register(FixtureLoader $loader)
    {
        $value = new Pair($loader->getName(), $loader);
        $this->loaders->add($value);
        return $this;
    }
341776
public function nodeUpdated(NodeInterface $node)
    {
        if (!$this->eventEmittingService->isEnabled()) {
            return;
        }

        if (!isset($this->changedNodes[$node->getContextPath()])) {
            $this->changedNodes[$node->getContextPath()] = ['node' => $node];
        }
    }
564217
public function registerNodeTypes(SessionInterface $session)
    {
        $cnd = sprintf(
            '<%s=\'https://github.com/symfony-cmf/content-type\'>',
            $this->encoder->getPrefix(),
            $this->encoder->getUri()
        );

        $nodeTypeManager = $session->getWorkspace()->getNodeTypeManager();
        $nodeTypeManager->registerNodeTypesCnd($cnd, true);
    }
1261818
public function load(ObjectManager $manager, FixtureInterface $fixture)
    {
        if ($this->logger) {
            $prefix = '';
            if ($fixture instanceof OrderedFixtureInterface) {
                $prefix = sprintf('[%d] ',$fixture->getOrder());
            }
            $this->log('loading ' . $prefix . get_class($fixture));
        }
        // additionally pass the instance of reference repository to shared fixtures
        if ($fixture instanceof SharedFixtureInterface) {
            $fixture->setReferenceRepository($this->referenceRepository);
        }
        $fixture->load($manager);
        $manager->clear();
    }
637230
public function setFixtures($table, $fixtures, $generator = null, $baseIndex = 0)
    {
        $loading = $this->currentSession->into($table);
        if ($generator) {
            $loading = $loading->with($generator);
        }
        return $loading->load($fixtures, $baseIndex);
    }
1077566
private function addNode(NodeInterface $node)
    {
        $this->nodeIndex++;
        $this->graph['nodes'][] = $node->toArray();

        return $this->nodeIndex;
    }
1026163
public function parse(Fixture $fixture, array $fixtures, $spec)
    {
        preg_match(self::REGEX, $spec, $ranges);
        if (empty($ranges)) {
            return;
        }

        $range = $ranges[0];
        $name = substr($spec, 0, strpos($spec, $range));

        preg_match_all('/\d+/', $range, $keys);
        if (empty($keys)) {
            return;
        }

        $start = $keys[0][0];
        $end = $keys[0][1];

        if ($start > $end) {
            throw new \Exception('Range start can not be biggen than range end for fixture ' . $spec);
        }

        for ($i = $start; $i <= $end; ++$i) {
            $newFixture = clone $fixture;
            $newFixture->setName($name . $i);
            $newFixture->setSpec($i);
            $fixtures[$name . $i] = $newFixture;
        }

        return $fixtures;
    }
1115002
public function registerNodeChange(NodeInterface $node)
    {
        if (in_array($node->getIdentifier(), $this->tagsToFlush)) {
            return;
        }
        if (!$node->getNodeType()->isOfType('Neos.Neos:Document')) {
            return;
        }
        $this->tagsToFlush[] = $node->getIdentifier();
    }
79673
public function add(DefinitionInterface $definition)
    {
        $index = count($this->_names);
        $this->_definitionSource[$index] = $definition;
        $this->_names[$definition->getName()] = $index;
        return $this;
    }
899478
protected function processFixture($fixture)
    {
        $tableName = basename($fixture, '.php');
        $records = include $fixture;

        if (!is_array($records)) {
            throw new Exceptions\InvalidFixtureDataException(
                "Invalid fixture: $fixture, please ensure this file returns an array of data.",
                1
            );

        }

        $this->fixtures[$tableName] = $this->driver->buildRecords($tableName, $records);
    }
784059
private function tryToMarkObjectAsComplete(FixtureInterface $fixture, ResolvedFixtureSet $set, GenerationContext $context): ResolvedFixtureSet
    {
        $object = $set->getObjects()->get($fixture);

        if ($object instanceof CompleteObject || false === $this->isObjectComplete($fixture, $set, $context)) {
            return $set;
        }

        return $set->withObjects(
            $set->getObjects()->with(
                new CompleteObject($object)
            )
        );
    }
350498
public function get(string $id): FixtureInterface
    {
        if ($this->has($id)) {
            return clone $this->fixtures[$id];
        }

        throw FixtureNotFoundExceptionFactory::create($id);
    }