protected function getDumpOrder(array $classes)
{
$calc = new CommitOrderCalculator();
foreach ($classes as $class) {
if (!$class->getReflectionClass()->isInstantiable() || $class->isMappedSuperclass) {
continue;
}
if ($class->getTableName() === 'Group') {
continue;
}
$calc->addClass($class);
// $class before its parents
foreach ($class->parentClasses as $parentClass) {
$parentClass = $this->objectManager->getClassMetadata($parentClass);
if (!$calc->hasClass($parentClass->name)) {
$calc->addClass($parentClass);
}
$calc->addDependency($class, $parentClass);
}
foreach ($class->associationMappings as $assoc) {
if ($assoc['isOwningSide']) {
$targetClass = $this->objectManager->getClassMetadata($assoc['targetEntity']);
if (!$calc->hasClass($targetClass->name)) {
$calc->addClass($targetClass);
}
// add dependency ($targetClass before $class)
$calc->addDependency($targetClass, $class);
// parents of $targetClass before $class, too
foreach ($targetClass->parentClasses as $parentClass) {
$parentClass = $this->objectManager->getClassMetadata($parentClass);
if (!$calc->hasClass($parentClass->name)) {
$calc->addClass($parentClass);
}
$calc->addDependency($parentClass, $class);
}
}
}
}
return $calc->getCommitOrder();
}
protected function getCommitOrder(EntityManager $em, array $classes)
{
$calc = new CommitOrderCalculator();
foreach ($classes as $class) {
$calc->addClass($class);
foreach ($class->associationMappings as $assoc) {
if ($assoc->isOwningSide) {
$targetClass = $em->getClassMetadata($assoc->targetEntityName);
if (!$calc->hasClass($targetClass->name)) {
$calc->addClass($targetClass);
}
// add dependency ($targetClass before $class)
$calc->addDependency($targetClass, $class);
}
}
}
return $calc->getCommitOrder();
}
/**
* Returns the reverse commit order for the given classes
*
* @param array $classes An array of ClassMetadata instances
*
* @return array
*/
private function getReverseCommitOrder(array $classes)
{
$calculator = new CommitOrderCalculator();
foreach ($classes as $class) {
$calculator->addClass($class);
}
return array_reverse($calculator->getCommitOrder());
}
private function _getCommitOrder(array $classes)
{
$calc = new CommitOrderCalculator();
// Calculate dependencies
foreach ($classes as $class) {
$calc->addClass($class);
foreach ($class->associationMappings as $assoc) {
if ($assoc->isOwningSide) {
$targetClass = $this->_em->getClassMetadata($assoc->targetEntityName);
if (!$calc->hasClass($targetClass->name)) {
$calc->addClass($targetClass);
}
// add dependency ($targetClass before $class)
$calc->addDependency($targetClass, $class);
}
}
}
return $calc->getCommitOrder();
}
/**
* Gets the commit order.
*
* @return array
*/
private function _getCommitOrder(array $entityChangeSet = null)
{
if ($entityChangeSet === null) {
$entityChangeSet = array_merge($this->_entityInsertions, $this->_entityUpdates, $this->_entityDeletions);
}
// TODO: We can cache computed commit orders in the metadata cache!
// Check cache at this point here!
// See if there are any new classes in the changeset, that are not in the
// commit order graph yet (dont have a node).
$newNodes = array();
foreach ($entityChangeSet as $entity) {
$className = get_class($entity);
if (!$this->_commitOrderCalculator->hasNodeWithKey($className)) {
$this->_commitOrderCalculator->addNodeWithItem($className, $this->_em->getClassMetadata($className));
$newNodes[] = $this->_commitOrderCalculator->getNodeForKey($className);
}
}
// Calculate dependencies for new nodes
foreach ($newNodes as $node) {
$class = $node->getClass();
foreach ($class->associationMappings as $assocMapping) {
//TODO: should skip target classes that are not in the changeset.
if ($assocMapping->isOwningSide) {
$targetClass = $this->_em->getClassMetadata($assocMapping->targetEntityName);
$targetClassName = $targetClass->name;
// If the target class does not yet have a node, create it
if (!$this->_commitOrderCalculator->hasNodeWithKey($targetClassName)) {
$this->_commitOrderCalculator->addNodeWithItem($targetClassName, $targetClass);
}
// add dependency
$otherNode = $this->_commitOrderCalculator->getNodeForKey($targetClassName);
$otherNode->before($node);
}
}
}
return $this->_commitOrderCalculator->getCommitOrder();
}
private function getCommitOrder(EntityManagerInterface $em, array $classes)
{
$calc = new CommitOrderCalculator();
foreach ($classes as $class) {
$calc->addClass($class);
// $class before its parents
foreach ($class->parentClasses as $parentClass) {
$parentClass = $em->getClassMetadata($parentClass);
if (!$calc->hasClass($parentClass->name)) {
$calc->addClass($parentClass);
}
$calc->addDependency($class, $parentClass);
}
foreach ($class->associationMappings as $assoc) {
if ($assoc['isOwningSide']) {
$targetClass = $em->getClassMetadata($assoc['targetEntity']);
if (!$calc->hasClass($targetClass->name)) {
$calc->addClass($targetClass);
}
// add dependency ($targetClass before $class)
$calc->addDependency($targetClass, $class);
// parents of $targetClass before $class, too
foreach ($targetClass->parentClasses as $parentClass) {
$parentClass = $em->getClassMetadata($parentClass);
if (!$calc->hasClass($parentClass->name)) {
$calc->addClass($parentClass);
}
$calc->addDependency($parentClass, $class);
}
}
}
}
return $calc->getCommitOrder();
}
