Returns a numeric representation of all version parts, used for comparison

@return array
484065
public function numeric()
    {
        $ret = array();
        foreach (self::$ordinality as $part) {
            if ($part === self::STABILITY) {
                $ret[]= array_search($this->get($part), self::$stabilities);
            } else {
                $ret[]= $this->get($part);
            }
        }
        return $ret;
    }
753293
public function getDealerAdminVersions()
    {
        if (null === $this->dealer_admin_versions_unserialized) {
            $this->dealer_admin_versions_unserialized = array();
        }
        if (!$this->dealer_admin_versions_unserialized && null !== $this->dealer_admin_versions) {
            $dealer_admin_versions_unserialized = substr($this->dealer_admin_versions, 2, -2);
            $this->dealer_admin_versions_unserialized = $dealer_admin_versions_unserialized ? explode(' | ', $dealer_admin_versions_unserialized) : array();
        }

        return $this->dealer_admin_versions_unserialized;
    }
394325
public function getVersionNumber() {
        if ($this->versionNumber === null) {
            $version = $this->getVersionString();
            if (!preg_match('/^(\d+)\.(\d+).(\d+)/', $version, $match))
                throw new \UnexpectedValueException('Unexpected version string "'.$version.'"');

            $major   = (int) $match[1];
            $minor   = (int) $match[2];
            $release = (int) $match[3];

            $this->versionNumber = $major*1000000 + $minor*1000 + $release;
        }
        return $this->versionNumber;
    }
1033869
public function getOperatingSystemVersion()
    {
        $os = $this->getOperatingSystem();

        return $this->prepareVersion([$os->major, $os->minor, $os->patch]);
    }
1102968
private function getAvailableVersions()
    {
        if (!isset($this->availableVersions)) {
            $this->availableVersions = [];
            foreach ($this->getManifest() as $key => $item) {
                if ($missing = array_diff(self::$requiredKeys, array_keys($item))) {
                    throw new \RuntimeException(sprintf(
                        'Manifest item %s missing required key(s): %s',
                        $key,
                        implode(',', $missing)
                    ));
                }
                $this->availableVersions[$item['version']] = $item;
            }
        }

        return $this->availableVersions;
    }
777763
public function CMSVersionNumber()
    {
        $moduleName = array_keys($this->getVersionProvider()->getModules())[0];
        $lockModules = $this->getVersionProvider()->getModuleVersionFromComposer([$moduleName]);

        if (!isset($lockModules[$moduleName])) {
            return '';
        }

        return $lockModules[$moduleName];
    }
196521
public function getVersions()
    {
        if (!isset($this->_versions)) {
            $versions = array();

            foreach ($this->getMethods() as $method) {
                $matches = array();

                if (preg_match('/(up)(\d+)/', $method, $matches)) {
                    $versions[] = $matches[2];
                }
            }

            $path = dirname($this->getIdentifier()->filepath);

            if (file_exists($path)) {
                if (file_exists($path.'/migrations')) {
                    $files = new DirectoryIterator($path.'/migrations');
                    foreach ($files as $file) {
                        $matches = array();
                        if (preg_match('/(\d+)\.sql/', (string) $file, $matches)) {
                            $versions[] = $matches[1];
                        } elseif (preg_match('/(\d+)\.php/', (string) $file, $matches)) {
                            $versions[] = $matches[1];
                        }
                    }
                }
            }
            sort($versions);
            $this->_versions = array_unique($versions);
            $this->_max_version = array_pop($versions);
        }

        return $this->_versions;
    }
183869
public function getVersion()
  {
    $composerJson = config('app.dir') . 'composer.json';

    if (file_exists($composerJson)) {
      $composer = json_decode(file_get_contents($composerJson, true));

      $version  = isset($composer->version) ? $composer->version : '1';
      $require  = isset($composer->require) ? (array)$composer->require : false;

      if (!is_array($require)) return "{$version} (1)";

      if (isset($require['modulusphp/framework'])) {
        return $version . " ({$require['modulusphp/framework']})";
      } else {
        return "{$version} (1)";
      }
    }

    return '1';
  }
704596
protected function getCurrentVersion()
    {
        $version = $this->getBinary()->run('--version');
        $version = str_replace('v', null, $version);

        return $version;
    }
1238678
protected Integer[] getVersionParts() {

        String[] sParts = version.split("\\.");
        ArrayList<Integer> iParts = new ArrayList<>();
        int trailingZeros = 0;

        for (String sPart : sParts) {
            Integer iPart = new Integer(sPart);

            if (iPart == 0) {
                ++trailingZeros;
            } else {
                for (int i = 0; i < trailingZeros; ++i) {
                    iParts.add(0);
                }
                trailingZeros = 0;
                iParts.add(iPart);
            }
        }
        return iParts.toArray(new Integer[iParts.size()]);
    }
382263
public function getVersion()
    {
        $version = $this->getProjectVersion();

        if (APPLICATION_ENV !== 'production' && APPLICATION_ENV !== 'acceptance' && APPLICATION_ENV !== 'demo') {
            $version .= '.' . $this->getBuild() . ' [' . APPLICATION_ENV . ']';
        }

        return $version;
    }
1175501
public function getVersion()
    {
        $separator = $this->config->useUnicode() ? '—' : '-';

        return \sprintf('Psy Shell %s (PHP %s %s %s)', self::VERSION, PHP_VERSION, $separator, PHP_SAPI);
    }
11264
public function getDealerShedulesVersions()
    {
        if (null === $this->dealer_shedules_versions_unserialized) {
            $this->dealer_shedules_versions_unserialized = array();
        }
        if (!$this->dealer_shedules_versions_unserialized && null !== $this->dealer_shedules_versions) {
            $dealer_shedules_versions_unserialized = substr($this->dealer_shedules_versions, 2, -2);
            $this->dealer_shedules_versions_unserialized = $dealer_shedules_versions_unserialized ? explode(' | ', $dealer_shedules_versions_unserialized) : array();
        }

        return $this->dealer_shedules_versions_unserialized;
    }
136602
public function getAvailableVersions()
    {
        $availableVersions = [];
        foreach ($this->migrations as $migration) {
            $availableVersions[] = $migration->getVersion();
        }

        return $availableVersions;
    }
317225
public function requestVersion(): array
    {
        try {
            $versions = json_decode(file_get_contents($this->apiURL), true)['packages']['orchid/platform'];

            return array_reverse($versions);
        } catch (\Exception $exception) {
            Log::alert($exception->getMessage());

            return [['version' => '0.0.0']];
        }
    }
526547
public function getSortedRefs()
    {
        $versions = $this->versions;

        usort($versions, function (version $v1, version $v2) {


            return version::gt($v1, $v2) ? -1 : 1;
        });

        $versions = array_map(function (version $v) {


            return $v->getVersion();
        }, $versions);

        return array_merge($this->branches, $versions);
    }
1081220
protected function getNumbers() {
        if (!$this->_numbers) {
            $this->_numbers = new NumberList($this->version);
        }

        return $this->_numbers;
    }