Gets the CommitOrderCalculator used by the UnitOfWork to order commits.

@return \Doctrine\ORM\Internal\CommitOrderCalculator
161800
public function getCommitOrderCalculator()
    {
        if ($this->commitOrderCalculator === null) {
            $this->commitOrderCalculator = new Internal\CommitOrderCalculator;
        }

        return $this->commitOrderCalculator;
    }
1226947
public function getCLIApplication()
    {
        $application = new Application('Doctrine Manager Builder Command Line Interface');
        $application->setCatchExceptions(true);

        foreach ($this->builders as $builder) {
            foreach ($builder->getConsoleCommands() as $command) {
                $helperSet = $command->getHelperSet();

                $application->add($command)->setHelperSet($helperSet);
            }
        }

        $this->registerGlobalAnnotationLoader();

        return $application;
    }
289836
public function getDependentFilteredCommits() {
		// check if this environment depends on another environemnt
		$dependsOnEnv = $this->DependsOnEnvironment();
		if(empty($dependsOnEnv)) return null;

		// Check if there is a filter
		$config = $this->GenericPipelineConfig();
		$filter = isset($config->PipelineConfig->FilteredCommits)
			? $config->PipelineConfig->FilteredCommits
			: null;
		if (empty($filter)) return null;

		// Create and execute filter
		if (!class_exists($filter)) throw new Exception(sprintf("Class %s does not exist", $filter));
		$commitClass = $filter::create();
		// setup the environment to check for commits
		$commitClass->env = $dependsOnEnv;
		return $commitClass->getCommits();
	}
125130
protected function getOrder()
    {
        /** @var EntityRepository $repo */
        $repo = $this->getRepository();
        $table = $repo->getEntityDescriptor()->getTableName();
        $pmk = $repo->getEntityDescriptor()->getPrimaryKey()->getField();
        return "{$table}.{$pmk} DESC";
    }
507645
public function getTransactional() {
		if ($this->transactionalEm !== null && $this->transactionalEm->isOpen()) {
			return $this->transactionalEm;
		}
		
		$pdo = $this->pdoPool->getPdo($this->persistenceUnitName);
		if (!$pdo->inTransaction()) {
			throw new IllegalStateException('No tranaction open.');
		}
		
		$this->transactionalEm = new LazyEntityManager($this->persistenceUnitName, $this->pdoPool, true);
		$this->transactionalEm->bindPdo($pdo);
	
		return $this->transactionalEm;
	}
83784
public function getTotalOrderSum()
    {
        $oCur = \OxidEsales\Eshop\Core\Registry::getConfig()->getActShopCurrencyObject();

        return number_format((double) $this->oxorder__oxtotalordersum->value, $oCur->decimal, '.', '');
    }
954285
public function getOrder()
    {
        if ($this->_oOrder === null) {
            $this->_oOrder = oxNew(\OxidEsales\Eshop\Application\Model\Order::class);
            // loading order sometimes needed in template
            if ($sOrderId = $this->getBasket()->getOrderId()) {
                $this->_oOrder->load($sOrderId);
            }
        }

        return $this->_oOrder;
    }
194169
protected function getSortableColumn()
    {
        $reader = new AnnotationReader();
        $reflClass = new ReflectionClass($this->getEntityClass());
        foreach ($reflClass->getProperties() as $property) {
            $reflProperty = new ReflectionProperty($this->getEntityClass(), $property->name);
            $annotation = $reader->getPropertyAnnotation($reflProperty, '\Gedmo\Mapping\Annotation\SortablePosition');
            if ($annotation) {
                return $property->name;
            }
        }
    }
225974
public function getCommitMessage()
    {
        $rtn = parent::getCommitMessage($this->data['commit_message']);

        $project = $this->getProject();

        if (!is_null($project)) {
            $reference = $project->getReference();
            $commitLink = '<a target="_blank" href="https://github.com/' . $reference . '/issues/$1">#$1</a>';
            $rtn = preg_replace('/\#([0-9]+)/', $commitLink, $rtn);
            $rtn = preg_replace('/\@([a-zA-Z0-9_]+)/', '<a target="_blank" href="https://github.com/$1">@$1</a>', $rtn);
        }

        return $rtn;
    }
682646
public function getOrderPaymentStatusCalculator()
    {
        /** @var \OxidEsales\PayPalModule\Model\OrderPaymentStatusCalculator $statusCalculator */
        $statusCalculator = oxNew(\OxidEsales\PayPalModule\Model\OrderPaymentStatusCalculator::class);
        $statusCalculator->setOrder($this->getEditObject()->getPayPalOrder());

        return $statusCalculator;
    }
667008
protected function defaultOrdering()
    {
        collect($this->request->orderableColumns())
            ->map(function ($orderable) {
                $orderable['name'] = $this->getColumnName($orderable['column'], true);

                return $orderable;
            })
            ->reject(function ($orderable) {
                return $this->isBlacklisted($orderable['name']) && ! $this->hasOrderColumn($orderable['name']);
            })
            ->each(function ($orderable) {
                $column = $this->resolveRelationColumn($orderable['name']);

                if ($this->hasOrderColumn($column)) {
                    $this->applyOrderColumn($column, $orderable);
                } else {
                    $nullsLastSql = $this->getNullsLastSql($column, $orderable['direction']);
                    $normalSql = $this->wrap($column) . ' ' . $orderable['direction'];
                    $sql = $this->nullsLast ? $nullsLastSql : $normalSql;
                    $this->query->orderByRaw($sql);
                }
            });
    }
13343
public function unions(): self
    {
        $sequence = $this
            ->sorted([$this, 'sortByStartDate'])
            ->reduce([$this, 'calculateUnion'], new self())
        ;

        if ($sequence->intervals === $this->intervals) {
            return $this;
        }

        return $sequence;
    }
403330
public function getPayPalOxOrder()
    {
        if (is_null($this->payPalOxOrder)) {
            $order = oxNew(\OxidEsales\Eshop\Application\Model\Order::class);
            $order->loadPayPalOrder();
            $this->setPayPalOxOrder($order);
        }

        return $this->payPalOxOrder;
    }
345976
public function commit()
    {
        $res = null;

        if ($this->transLevel == 0) {
            $this->cleanAfterCommit();
            throw $this->createException('Commit without transaction');
        }

        if (!empty($this->transLevelRolledBack[$this->transLevel])) {
            $this->transLevel--;
            return $this;
        }

        if (empty($this->pendingTransactionBegin[$this->transLevel])) {
            $this->dbTransLevel--;

            if ($this->dbTransLevel == 0) {
                $res = pg_query($this->pgConn, 'commit');
            }

            if ($res === false) {
                $this->cleanAfterCommit();
                throw $this->createException();
            }
        }

        $this->afterCommit();
        $this->transLevel--;

        return $this;
    }
229702
protected function transactionCommit() {
		$this->transactionCounter--;
		if ( $this->transactionCounter == 0 ) {
			return $this->dbh->commit();
		}
		return $this->transactionCounter >= 0;
	}
107183
protected function setSortingOrder()
    {
        if (null !== $this->info->list->default_sort) {
            return $this;
        }

        if ($this->info->list->orderable && $this->info->list->getOrderableColumn()) {
            $this->info->list->default_sort = $this->info->list->getOrderableColumn();
        } elseif ($this->info->timestamps) {
            $this->info->list->default_sort = $this->info->timestamp_created;
        } elseif ($this->info->incrementing) {
            $this->info->list->default_sort = $this->model->getKeyName();
        }

        return $this;
    }
915823
public static function getDecimalSeparator()
    {
        if (!isset(self::$decimalSeparator)) {
            $localeconv = localeconv();
            self::$decimalSeparator = ($localeconv['decimal_point'] != '')
                ? $localeconv['decimal_point'] : $localeconv['mon_decimal_point'];

            if (self::$decimalSeparator == '') {
                // Default to .
                self::$decimalSeparator = '.';
            }
        }
        return self::$decimalSeparator;
    }