Is there a merge in progress.

@return bool
190071
public function isMerging(): bool
    {
        foreach (['MERGE_MSG', 'MERGE_HEAD', 'MERGE_MODE'] as $fileName) {
            if (file_exists($this->dotGitDir . DIRECTORY_SEPARATOR . $fileName)) {
                return true;
            }
        }
        return false;
    }
1204057
public function checkIntegrity()
    {
        $combine = array_merge(['put' => array_diff_assoc($_SESSION, $this->sessionHandler->all())],['forget' => array_keys(array_diff_assoc($this->sessionHandler->all(), $_SESSION))]);
        if ($combine) {
            foreach($combine as $method => $dataArray) {
                if (!empty($dataArray)) {
                    $this->sessionHandler->$method($dataArray);
                }
            }
        }
        return true;
    }
1058
public static function isUpgradeAvailable()
    {
        if (self::isInstallerAvailable()) {
            $migration_version = self::getMigrationVersion();
            $current_version = Symphony::Configuration()->get('version', 'symphony');

            return version_compare($current_version, $migration_version, '<');
        }

        return false;
    }
489813
public function merge()
    {
        $args = func_get_args();

        foreach ($args as $arg) {
            if (!($arg instanceof \SplPriorityQueue)) {
                throw new \InvalidArgumentException('Only \SplPriorityQueue can merge.');
            }

            $queue = clone $arg;

            $queue->setExtractFlags(self::EXTR_BOTH);

            foreach ($queue as $item) {
                $this->insert($item['data'], $item['priority']);
            }
        }

        return $this;
    }
601483
public function isUpdateRequired(): bool
    {
        $history = $this->fetchHistory();

        if (!empty($history)) {
            $this->setDummyMigrationClass();

            foreach ($history as $migration => $time) {
                $migration = trim($migration, '\\');
                if (in_array($migration, $this->skipMigrations, true)) {
                    continue;
                }

                if (!$this->gatherChanges($this->extract($migration))) {
                    break;
                }
            }

            return $this->compareStructures();
        }

        return true;
    }
578104
public function hasToBeReloaded()
    {
        if (!$this->wurflConfig->allowReload) {
            return false;
        }
        $state = $this->persistenceStorage->load(self::WURFL_API_STATE);
        return !$this->isStateCurrent($state);
    }
167914
public function hasAlive()
    {
        foreach ($this->processes as $pid => $process) {
            if ($process->isAlive()) {
                return true;
            }
        }

        return false;
    }
1189326
public function hasChange()
    {
        return (
            count($this->getFieldsWithUpdate()) > 0
            || count($this->getIndexesWithUpdate()) > 0
            || $this->addSoftDelete
            || $this->dropSoftDelete
            || $this->addTimestamps
            || $this->dropTimestamps);
    }
734233
public function isDirty()
    {
        if (count($this) != $this->_original) {
            return true;
        }
        if (count($this->_deleted)) {
            return true;
        }
        foreach ($this as $model) {
            if (is_object($model)
                && ($model->isDirty() || $model->isNew())
            ) {
                return true;
            }
        }
        return false;
    }
1256017
private function hasUnmigratedVersions()
    {
        $needsToRun = false;

        foreach ($this->availableVersions as $migration) {
            $isTargetMigrated = in_array($migration->getVersion(), $this->migratedVersions);

            if ($isTargetMigrated) {
                continue;
            }

            $needsToRun = true;
            break;
        }

        return $needsToRun;
    }
43696
public function merge()
	{
		if($this->saveBackupBeforeMerge)
		{
			$this->saveBackup();
		}
		
		// Since the param bag has the merge functionality already, why not use it?
		$this->master->params()->merge($this->slave->params()->all());
		
		if($this->autoSaveMaster)
		{
			$this->master->save();
		}

		if($this->deleteSlaveOnMerge)
		{
			$this->slave->delete();
		}
	}
675264
public function isSuccessful()
    {
        $data = $this->getData();

        return
            (isset($data['status']) && $data['status'] !== 'KO') &&
            (isset($data['duplicate']) && $data['duplicate'] !== 'true');
    }
659013
public function mergeAttr()
    {
        $arrays = func_get_args();
        $result = array();

        foreach ($arrays as $array) {
            $result = $this->mergeRecursive($result, $array);
        }

        return $result;
    }
1243583
public function isSuccessful()
    {
        return $this->data->getStatus() === InvoiceInterface::STATUS_CONFIRMED || $this->data->getStatus() === InvoiceInterface::STATUS_COMPLETE;
    }
638077
public function isDirty()
    {
        return true === $this->attributes->areDirty()
            || true === $this->hasOneEmbeds->areDirty()
            || true === $this->hasManyEmbeds->areDirty()
        ;
    }
292032
protected function hasGitFlow()
    {
        $config = $this->gitConfig();

        if (isset($config['gitflow prefix'])
            && !empty($config['gitflow prefix'])) {
            return true;
        }

        return false;
    }
804199
public function isCoherent()
	{
		$nodes = $this->getNodes();
		foreach( $nodes as $source )
		{
			foreach( $nodes as $target )
			{
				if( $source != $target )
				{
					$forward = $this->isPath( $source, $target );
					$backward = $this->isPath( $target, $source );
					if( !$forward && !$backward )
						return false;
				}
			}
		}
		return true;
	}