Check if the object attached to this changesetitem is versionable

@return bool
183215
public function isVersioned()
    {
        if (!$this->ObjectClass || !class_exists($this->ObjectClass)) {
            return false;
        }
        /** @var Versioned|DataObject $singleton */
        $singleton = DataObject::singleton($this->ObjectClass);
        return $singleton->hasExtension(Versioned::class) && $singleton->hasStages();
    }
1133765
public function isSupported()
    {
        $result = true;
        $table  = $this->getMixer();

        //Only check if we are connected with a table object, otherwise just return true.
        if($table instanceof DatabaseTableInterface)
        {
            if($table->hasColumn('slug'))
            {
                //If unique is NULL use the column metadata
                if(is_null($this->_unique)) {
                    $this->_unique = $table->getColumn('slug', true)->unique;
                }
            }
            else $result = false;
        }

        return $result;
    }
35237
public function isEditable()
    {
        return $this->read_only || $this->never_persist
            ? false
            : (isset($this->ui['editable']) ? $this->ui['editable'] : !$this->system);
    }
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;
    }
568126
public static function isSupported()
    {
        if (self::$isSupported === null) {
            self::$isSupported = PHP_VERSION_ID >= 50600 && PHP_INT_SIZE > 4;
        }
        return self::$isSupported;
    }
477354
protected static function checkVersion()
    {
        if (self::$checked === true) {
            return true;
        }

        $process = new \SystemProcess\SystemProcess('git');
        $process->nonZeroExitCodeException = true;
        $process->argument('--version')->execute();

        if (!preg_match('(\\d+(?:\.\\d+)+)', $process->stdoutOutput, $match)) {
            throw new \RuntimeException('Could not determine GIT version.');
        }

        if (version_compare($match[0], '1.6', '>=')) {
            return self::$checked = true;
        }

        throw new \RuntimeException('Git is required in a minimum version of 1.6.');
    }
36585
public function isApprovable() {

		return $this->status == IApproval::STATUS_SUBMITTED || $this->status == IApproval::STATUS_FROJEN ||
			$this->status == IApproval::STATUS_UPLIFT_FREEZE || $this->status == IApproval::STATUS_BLOCKED ||
			$this->status == IApproval::STATUS_UPLIFT_BLOCK;
	}
1332788
public static function isCurrentVersionNewerThanDatabaseVersion()
    {
        $app = Application::getFacadeApplication();
        $db = $app->make(Connection::class);
        $config = $app->make('config');
        $database = $db->fetchColumn('select max(version) from SystemDatabaseMigrations');
        $code = $config->get('concrete.version_db');

        return $database < $code;
    }
421413
protected static function checkVersion()
    {
        if (self::$checked === true) {
            return true;
        }

        $process = new \SystemProcess\SystemProcess('bzr');
        $process->nonZeroExitCodeException = true;
        $process->argument('--version')->execute();

        if (!preg_match('/\Bazaar \(bzr\) ([0-9.]*)/', $process->stdoutOutput, $match)) {
            throw new \RuntimeException('Could not determine Bazaar version.');
        }

        if (version_compare($match[1], '1.1', '<')) {
            throw new \RuntimeException('Bazaar is required in a minimum version of 1.1.');
        }

        $process = new \SystemProcess\SystemProcess('bzr');
        $process->nonZeroExitCodeException = true;
        $process->argument('plugins')->execute();

        if (strpos($process->stdoutOutput, 'xmloutput') === false) {
            throw new \RuntimeException('Missing required bazaar pluging "xmloutput".');
        }

        return self::$checked = true;
    }
1356065
public function isCompatibleVersion()
    {
        $return = false;

        while ($this->read() && !$return) {
            $return = ($this->nodeType === \XMLReader::ELEMENT) && $this->hasAttributes &&
                ($this->getAttribute('version') === '1.4.4');
        } // while

        return $return;
    }
816835
private function areNullableReturnTypesSupported(): bool
    {
        $testVersion = trim(PHPCompatibility\PHPCSHelper::getConfigData('testVersion') ?: '');
        if (!$testVersion) {
            return false;
        }

        preg_match('`^(\d+\.\d+)(?:\s*-\s*(?:\d+\.\d+)?)?$`', $testVersion, $matches);
        $min = $matches[1] ?? null;

        return $min && version_compare($min, '7.1', '>=');
    }
53892
public function isNewVersionAvailable($currentVersion = '') : bool
    {
        $version = $currentVersion ?: $this->getVersionInstalled();

        if (! $version) {
            throw new \InvalidArgumentException('No currently installed version specified.');
        }

        // Remove the version file to forcefully update current version
        $this->deleteVersionFile();

        if (version_compare($version, $this->getVersionAvailable(), '<')) {
            if (! $this->versionFileExists()) {
                $this->setVersionFile($this->getVersionAvailable());
                event(new UpdateAvailable($this->getVersionAvailable()));
            }

            return true;
        }

        return false;
    }
692647
def is_changed(obj):
    
    revision_field = get_version_fieldname(obj)
    version = get_revision_of_object(obj)
    return not obj.__class__.objects.filter(**{obj._meta.pk.name: obj.pk,
                                               revision_field: version}).exists()
541399
private static function versionableGreaterThan(Versionable $v1, Versionable $v2)
    {
        if ($v1->getMajor() > $v2->getMajor()) {
            return true;
        }
        if ($v1->getMajor() < $v2->getMajor()) {
            return false;
        }

        if ($v1->getMinor() > $v2->getMinor()) {
            return true;
        }
        if ($v1->getMinor() < $v2->getMinor()) {
            return false;
        }

        if ($v1->getPatch() > $v2->getPatch()) {
            return true;
        }
        if ($v1->getPatch() < $v2->getPatch()) {
            return false;
        }

        return false;
    }
771590
public function isModified()
    {
        if ($this->read_only) {
            return false;
        }

        foreach ($this->getProperties() as $name => $value) {
            $hashed_value = $this->getHashValue($value);
            if (
                isset($this->property_hashes[$name]) &&
                $hashed_value !== $this->property_hashes[$name]
            ) {
                return true;
            }
        }

        foreach ($this->internal_property_autosave as $name => $autosave) {
            if ($autosave && isset($this->sub_data_objects[$name])) {
                $object = $this->sub_data_objects[$name];
                if (
                    $object instanceof SwatDBRecordable &&
                    $object->isModified()
                ) {
                    return true;
                }
            }
        }

        foreach ($this->sub_data_objects as $name => $object) {
            $saver_method =
                'save' . str_replace(' ', '', ucwords(strtr($name, '_', ' ')));

            if (method_exists($this, $saver_method)) {
                $object = $this->sub_data_objects[$name];
                if (
                    $object instanceof SwatDBRecordable &&
                    $object->isModified()
                ) {
                    return true;
                }
            }
        }

        return false;
    }
249148
public function hasChanged()
    {
        foreach ($this->modelData as $property => $value) {
            if ($this->hasPropertyChanged($property)) {
                return true;
            }
        }

        // In case model data has been manually unset
        $manuallyUnsetProperties = array_diff_key($this->changeSnapshotData, $this->modelData);
        foreach ($manuallyUnsetProperties as $property => $value) {
            // If it wasn't null before, that's a change
            if ($value !== null) {
                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;
    }