NOTE: Versions() will be replaced with this method in SilverStripe 5.0

@internal
@return DataList
495594
public function VersionsList()
    {
        $id = $this->owner->ID ?: $this->owner->OldID;
        $class = get_class($this->owner);
        return Versioned::get_all_versions($class, $id);
    }
406943
public function get_versions()
    {
        if (!$this->versions) {
            $this->versions = array();
            if ($json = $this->get_cache('versions')) {
                $this->versions = json_decode($json, true);
            }
        }

        return $this->versions;
    }
1357835
private function get_versions() {
            $versions = array();
            $versions['platform_version']             = get_bloginfo( 'version' );
            $versions['sdk_version']                  = $this->version;
            $versions['programming_language_version'] = phpversion();

            foreach ( $versions as $k => $version ) {
                if ( is_string( $versions[ $k ] ) && ! empty( $versions[ $k ] ) ) {
                    $versions[ $k ] = substr( $versions[ $k ], 0, 16 );
                }
            }

            return $versions;
        }
1173549
public function getList()
    {
        $list = new \BearFramework\DataList();
        foreach ($this->data as $queryItem) {
            $list[] = clone($queryItem);
        }
        return $list;
    }
1042191
public function version()
	{
		if (isset($this->data_cache['version']))
		{
			return $this->data_cache['version'];
		}

		// Not all subdrivers support the getAttribute() method
		try
		{
			return $this->data_cache['version'] = $this->conn_id->getAttribute(PDO::ATTR_SERVER_VERSION);
		}
		catch (PDOException $e)
		{
			return parent::version();
		}
	}
1176668
public function getAllVersions()
    {
        $versions = array();

        foreach ($this->getEntities() as $entity) {
            if ($entity->getVersion()) {
                $versions[$entity->getVersion()] = $entity->getVersion();
            } else {
                $versions['0.0'] = _t('DocumentationManifest.MASTER', 'Master');
            }
        }

        asort($versions);

        return $versions;
    }
404113
public function getData()
    {
        $data = $this->context->data;
        $result = [
            'version' => 3,
            'file' => $data['file'] ?: '',
            'sourceRoot' => $data['sourceRoot'] ?: '',
            'sources' => $this->sources->getNames(),
            'names' => $this->names->getNames(),
            'mappings' => $this->context->getMappings()->pack(),
        ];
        $contents = $this->sources->getContents();
        if (!empty($contents)) {
            $result['sourcesContent'] = $contents;
        }
        return $result;
    }
185245
public function changes()
    {
        // Check viewability of changes
        if (!Config::inst()->get(VersionFeed::class, 'changes_enabled')
            || !$this->owner->PublicHistory
            || $this->owner->Version == ''
        ) {
            return $this->owner->httpError(404, 'Page history not viewable');
        }

        // Cache the diffs to remove DOS possibility.
        $target = $this->owner;
        $key = implode('_', array('changes', $target->ID, $target->Version));
        $entries = $this->filterContent($key, function () use ($target) {
            return $target->getDiffList(null, Config::inst()->get(VersionFeed::class, 'changes_limit'));
        });

        // Generate the output.
        $title = _t(
            'SilverStripe\\VersionFeed\\VersionFeed.SINGLEPAGEFEEDTITLE',
            'Updates to {title} page',
            ['title' => $this->owner->Title]
        );
        $rss = new RSSFeed($entries, $this->owner->request->getURL(), $title, '', 'Title', '', null);
        $rss->setTemplate('Page_changes_rss');
        return $rss->outputToBrowser();
    }
231313
public function toArray(): array
    {
        $data = [
            'version' => $this->getVersion()
        ];

        if ($this->hasMetadata()) {
            $data['meta'] = $this->getMetadata();
        }

        return $data;
    }
719036
public function renderItems()
    {
        $rows = [];
        $this->dataProvider->setKeys([]);
        $models = array_values($this->dataProvider->getModels());
        $models = $this->normalizeData($models, $this->parentRootValue);
        $this->dataProvider->setModels($models);
        $this->dataProvider->setKeys(null);
        $this->dataProvider->prepare();
        $keys = $this->dataProvider->getKeys();
        foreach ($models as $index => $model) {
            $key = $keys[$index];
            if ($this->beforeRow !== null) {
                $row = call_user_func($this->beforeRow, $model, $key, $index, $this);
                if (!empty($row)) {
                    $rows[] = $row;
                }
            }

            $rows[] = $this->renderTableRow($model, $key, $index);

            if ($this->afterRow !== null) {
                $row = call_user_func($this->afterRow, $model, $key, $index, $this);
                if (!empty($row)) {
                    $rows[] = $row;
                }
            }
        }

        if (empty($rows)) {
            $colspan = count($this->columns);
            return "<tr><td colspan=\"$colspan\">" . $this->renderEmpty() . "</td></tr>";
        } else {
            return implode("\n", $rows);
        }
    }
956042
public function getDataSchema()
    {
        $schema = [
            'description' => $this->Description,
            'link' => 'https://addons.silverstripe.org/add-ons/' . $this->Name,
            'linkTitle' => _t(
                __CLASS__ . '.ADDONS_LINK_TITLE',
                'View {package} on addons.silverstripe.org',
                ['package' => $this->Title]
            ),
            'rating'=> (int) $this->Rating
        ];

        $this->extend('updateDataSchema', $schema);

        return $schema;
    }
417202
public function getMigrations()
    {
        $path = $this['path'];

        $files = Filesystem::files($path);

        $migrations = new DataSet();

        foreach ($files as $file) {
            $ext = File::getExtension($file->getBasename());

            if ($ext !== 'php') {
                continue;
            }

            $name = $file->getBasename();

            list($id, $name) = explode('_', $name, 2);

            $mig = new Data();

            $mig['id']      = $id;
            $mig['version'] = $id;
            $mig['name']    = File::stripExtension($name);
            $mig['class']   = StringNormalise::toCamelCase(File::stripExtension($name));
            $mig['file']    = $file->getBasename();
            $mig['path']    = $file->getPathname();

            $migrations[$id] = $mig;
        }

        return $migrations;
    }
1099315
public static function getVersionList()
    {
        $app = Application::getFacadeApplication();
        $config = $app->make('config');
        $createHightDPIVersions = (bool) $config->get('concrete.file_manager.images.create_high_dpi_thumbnails');

        $types = static::getList();
        $versions = [];

        foreach ($types as $type) {
            $versions[] = $type->getBaseVersion();
            if ($createHightDPIVersions) {
                $versions[] = $type->getDoubledVersion();
            }
        }

        return $versions;
    }
244110
public function getDataModelSettings()
    {
        if (! $this->exists) {
            return array();
        }

        $fieldSettings = array();

        foreach ($this->_fields as $key => $field) {
            if ($field instanceof FieldInterface) {
                $fieldSettings[$key] = $field->getDataModelSettings();
            }
        }

        return $fieldSettings;
    }
645925
public function getVersionsBehind()
    {
        $current = $this->getCurrentVersion();
        $versions = array_filter($this->getVersions(),
                function ($version) use ($current) {
                    return $version > $current;
                }
        );

        return count($versions);
    }
285904
public function getDataChangesList() {
        return DataChangeRecord::get()->filter([
            'ChangeRecordID' => $this->owner->ID,
            'ChangeRecordClass' => $this->owner->ClassName
        ]);
    }
1364714
function dataMap()
    {
        if ( !isset( $this->DataMap[$this->Version] ) )
        {
            $attributes = $this->fetchAttributes( false, true, $this->Version );
            foreach ( $attributes as $attribute )
            {
                $this->DataMap[$this->Version][$attribute->attribute( 'identifier' )] = $attribute;
            }
        }
        return $this->DataMap[$this->Version];
    }