@param TransitionalInterface $flowObject

@return ConnectingObjectCollection
189918
public function filterBySource(TransitionalInterface $flowObject)
    {
        $collection = new static();

        foreach ($this as $connectingObject) { /* @var $connectingObject ConnectingObjectInterface */
            if ($connectingObject->getSource()->getId() === $flowObject->getId()) {
                $collection->add($connectingObject);
            }
        }

        return $collection;
    }
581485
public function import(array $flows): FrameworkHandler
    {
        foreach ($flows as $flow) {
            //it's gotta be an array
            if (!is_array($flow)) {
                continue;
            }

            $this->flow(...$flow);
        }

        return $this;
    }
112256
public function getTransitions($statusId, $defaultWorkflowId = null)
	{

		list($wId, $lid) = $this->parseStatusId($statusId, $defaultWorkflowId);
		$statusId = $wId.self::SEPARATOR_STATUS_NAME.$lid;

		if ( ! array_key_exists($statusId, $this->_t) ) {

			$start = $this->getStatus($statusId);
			if ( $start == null) {
				throw new WorkflowException('start status not found : id = '. $statusId);
			}

			$wDef = $this->getWorkflowDefinition($wId);

			$trDef = isset($wDef[self::KEY_NODES][$start->getId()][self::KEY_EDGES])
				? $wDef[self::KEY_NODES][$start->getId()][self::KEY_EDGES]
				: null;

			$transitions = [];
			if ( $trDef != null) {

				foreach ($trDef as $endStId => $trCfg) {
					$ids = $this->parseStatusId($endStId, $wId);
					$endId =  implode(self::SEPARATOR_STATUS_NAME, $ids);
					$end = $this->getStatus($endId);

					if ( $end == null ) {
						throw new WorkflowException('end status not found : start(id='.$statusId.') end(id='.$endStId.')');
					} else {
						$trCfg['class' ] = $this->getClassMapByType(self::TYPE_TRANSITION);
						$trCfg['start' ] = $start;
						$trCfg['end'   ] = $end;
						$trCfg['source'] = $this;
						$transitions[$endId] = Yii::createObject($trCfg);
					}
				}
			}
			$this->_t[$statusId] = $transitions;
		}
		return $this->_t[$statusId];
	}
496208
public function fillCollectionWithRelations(CollectionInterface $collection)
    {
        if (!$collection->count()) {
            return $collection;
        }

        foreach ($this->getWith() as $relation) {
            $relation->fillCollection($collection);
        }

        return $collection;
    }
330072
public function transform($object)
    {
        if (($collection = $this->normalize($object)) instanceof Collection) {
            return $this->transformCollection($collection);
        }

        // If there are relations setup, transform it along with the object.
        if ($this->relatedCount) {
            return $this->transformWithRelated($object);
        }

        // If another transformation method was requested, use that instead.
        if (is_callable($this->transformationMethod)) {
            return $this->getAlternateTransformation($object);
        }

        return $this->getTransformation($object);
    }
340590
public function reverseTransform($idObject)
    {
        if (!is_array($idObject)) {
            return;
        }

        $identifier = current(array_values($this->om->getClassMetadata($this->entityName)->getIdentifier()));
        $id = $idObject[$identifier];

        $object = $this->om
            ->getRepository($this->entityName)
            ->findOneBy([$identifier => $id]);

        if (null === $object) {
            throw new TransformationFailedException(sprintf(
                'An object with identifier key "%s" and value "%s" does not exist!',
                $identifier, $id
            ));
        }

        return $object;
    }
432024
public function object(ResourceObject $ro) : RequestInterface
    {
        return new Request($this->invoker, $ro, $this->method);
    }
720440
protected function getConnection($bindTransaction)
    {
        if (empty($this->connection)) {
            $this->connection = $this->getNewConnection(array($this->connectionInfo));
            $this->connections[] = $this->connection;

            if($bindTransaction)
                $this->TransactionManager->bindConnection($this->connection);
        }
        return $this->connection;
    }
965569
public function getLinkForObject(AttachableObjectInterface $object, $fieldName = null)
    {
        return AttachmentLinkQuery::create()
            ->filterByAttachment($this)
            ->filterByAttachableObject($object)
            ->filterByModelField($fieldName)
            ->findOne()
        ;
    }
623363
public function process(
        ObjectInterface $object,
        ResolvedFixtureSet $fixtureSet,
        GenerationContext $context,
        MethodCallInterface $methodCall
    ): ResolvedFixtureSet {
        /** @var StaticReference $reference */
        $reference = $methodCall->getCaller();

        if (false === ($reference instanceof StaticReference)) {
            throw new \LogicException('TODO');
        }

        $result = $reference->getId()::{$methodCall->getMethod()}(...$methodCall->getArguments());

        if ($context->needsCallResult()) {
            $object = $object->withInstance($result);
        }

        return $fixtureSet->withObjects(
            $fixtureSet->getObjects()->with($object)
        );
    }
1178803
public function getTransformer(?array $sourcesTypes, ?array $targetTypes, MapperConfigurationInterface $mapperConfiguration): ?TransformerInterface
    {
        if (null === $sourcesTypes || \count($sourcesTypes) === 0) {
            return null;
        }

        if (\count($sourcesTypes) > 1) {
            $transformer = new MultipleTransformer();

            foreach ($sourcesTypes as $sourceType) {
                $transformer->addTransformer($this->chainTransformerFactory->getTransformer([$sourceType], $targetTypes, $mapperConfiguration), $sourceType);
            }

            return $transformer;
        }

        return null;
    }
165983
public function getTransitions($object, $graph = 'default', $asObject = false)
    {
        if (!$asObject) {
            return $this->getStateMachine($object, $graph)->getCurrentState()->getTransitions();
        }

        $stateMachine = $this->getStateMachine($object, $graph);

        return array_map(
            function ($transition) use ($stateMachine) {
                return $stateMachine->getTransition($transition);
            },
            $stateMachine->getCurrentState()->getTransitions()
        );
    }
39366
public function addTransition(callable $transitionBuilderCallable)
    {
        $transitionBuilder = new TransitionBuilder();
        call_user_func($transitionBuilderCallable, $transitionBuilder);
        $transition = $transitionBuilder->getTransition();

        $this->transitions[$transition->getInitialStateName()][$transition->getName()] = $transition;
        return $this;
    }
1320690
public function getReference(ConnectionInterface $con = null)
    {
        if ($this->aReference === null && ($this->reference_id !== null)) {
            $this->aReference = ChildReferenceQuery::create()->findPk($this->reference_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aReference->addVideos($this);
             */
        }

        return $this->aReference;
    }
286797
public function getPossibleTransitions($object)
    {
        $transitions = [];
        $sm = $this->factory->get($object, $this->activeGraph);

        foreach ($sm->getPossibleTransitions() as $name) {
            $transitions[$name] = array(
                'name' => $name,
                'graph' => $this->activeGraph,
                'color' => $this->getTransitionColor($name),
                'label' => $this->getTransitionLabel($name),
            );
        }

        return $transitions;
    }
370440
public function getSource(ConnectionInterface $con = null)
    {
        if ($this->aSource === null && ($this->source_id != 0)) {
            $this->aSource = ChildSourceQuery::create()->findPk($this->source_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aSource->addPages($this);
             */
        }

        return $this->aSource;
    }
1002751
public function filterGeneralAttachmentsForObject(AttachableObjectInterface $object)
    {
        return $this
            ->filterAllAttachmentsForObject($object)
            ->useAttachmentLinkQuery()
                ->filterByModelField(null, Criteria::ISNULL)
            ->endUse()
        ;
    }