<pre>
Use this operation to get recommendations for version matrix.
</pre>
767765
public static version_recommendations[] get(nitro_service client) throws Exception
	{
		version_recommendations resource = new version_recommendations();
		resource.validate("get");
		return (version_recommendations[]) resource.get_resources(client);
	}
595977
public Versions getVersions(String versionsURL, String authorizationToken) {

		LOG.info("getVersions with token: " + authorizationToken);

		VersionsResponse versionsResponse = (VersionsResponse) doRequest(new HttpGet(versionsURL), authorizationToken,
				VersionsResponse.class);
		return new Versions(versionsResponse.data);
	}
841880
protected int getMajorVersion() {
        return this.cluster.authenticate(this.passwordAuthenticator).clusterManager().info(5,TimeUnit.SECONDS).getMinVersion().major();
    }
537011
function getFunctionVersions(name, marker) {
    // Grab functions
    return new Promise((resolve, reject) => {
        lambda.listVersionsByFunction({
            FunctionName: name,
            Marker: marker
        }, function(err, data) {
            if (err) return reject(err);

            // Check if we can grab even more
            if (data.NextMarker) {
                return getFunctionVersions(name, data.NextMarker).then((versions) => {
                    resolve(data.Versions.concat(versions));
                });
            }

            resolve(data.Versions);
        });
    });
}
1334622
public List<Long> getAllVersions() throws IOException {
        List<Long> ret = new ArrayList<>();
        for (String s : listDir(_root)) {
            if (s.endsWith(FINISHED_VERSION_SUFFIX)) {
                ret.add(validateAndGetVersion(s));
            }
        }
        Collections.sort(ret);
        Collections.reverse(ret);
        return ret;
    }
862139
public static version_matrix_file[] get_filtered(nitro_service service, String filter) throws Exception
	{
		version_matrix_file obj = new version_matrix_file();
		options option = new options();
		option.set_filter(filter);
		version_matrix_file[] response = (version_matrix_file[]) obj.getfiltered(service, option);
		return response;
	}
125233
private static Version recommendVersion(ErrorCorrectionLevel ecLevel,
                                          Mode mode,
                                          BitArray headerBits,
                                          BitArray dataBits) throws WriterException {
    // Hard part: need to know version to know how many bits length takes. But need to know how many
    // bits it takes to know version. First we take a guess at version by assuming version will be
    // the minimum, 1:
    int provisionalBitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, Version.getVersionForNumber(1));
    Version provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel);

    // Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
    int bitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion);
    return chooseVersion(bitsNeeded, ecLevel);
  }
1322184
public List<Version<Attributes<T>>> getAllVersion()
   {
      List<Version<Attributes<T>>> list = new ArrayList<Version<Attributes<T>>>();
      List<Node> nodeList = childNode.get("version");
      for(Node node: nodeList)
      {
         Version<Attributes<T>>  type = new VersionImpl<Attributes<T>>(this, "version", childNode, node);
         list.add(type);
      }
      return list;
   }
1165956
def newest(versions)
      versions.sort { |x,y| compare(x,y) }.last
    end
691320
def query_versions(self, version=None):
        """"""
        if version not in RELEASE_AND_CANDIDATE_LATEST_VERSIONS:
            return [version]

        url = urljoin(self.base_url, 'releases/')
        parser = self._create_directory_parser(url)
        if version:
            versions = parser.filter(RELEASE_AND_CANDIDATE_LATEST_VERSIONS[version])
            from distutils.version import LooseVersion
            versions.sort(key=LooseVersion)
            return [versions[-1]]
        else:
            return parser.entries
386944
public static version_matrix_status[] get(nitro_service client) throws Exception
	{
		version_matrix_status resource = new version_matrix_status();
		resource.validate("get");
		return (version_matrix_status[]) resource.get_resources(client);
	}
414847
@Override
	public Object getCurrentVersion(Serializable id, SharedSessionContractImplementor session) throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "Getting version: " + MessageHelper.infoString( this, id, getFactory() ) );
		}
		final Tuple resultset = getFreshTuple( EntityKeyBuilder.fromPersister( this, id, session ), session );

		if ( resultset == null ) {
			return null;
		}
		else {
			return gridVersionType.nullSafeGet( resultset, getVersionColumnName(), session, null );
		}
	}
1316245
protected int findMatchingVersionIndex(String dbVersion) {
        int index = 0;
        int matchingVersionIndex = -1;
        while (matchingVersionIndex < 0 && index < ACTIVITI_VERSIONS.size()) {
            if (ACTIVITI_VERSIONS.get(index).matches(dbVersion)) {
                matchingVersionIndex = index;
            } else {
                index++;
            }
        }
        return matchingVersionIndex;
    }
89252
@Override
    public List<String> findVersions(final Artifact artifact) {
        return Arrays.asList(new String[]{artifact.getVersion()});
    }
881775
public static Version getStrictVersion(Collection<? extends VersionRangeCollection> ranges)
    {
        for (VersionRangeCollection collection : ranges) {
            if (collection.getRanges().size() == 1) {
                VersionRange range = collection.getRanges().iterator().next();
                if (range instanceof DefaultVersionRange) {
                    DefaultVersionRange defaultRange = (DefaultVersionRange) range;
                    Version lowerBound = defaultRange.getLowerBound();
                    if (lowerBound != null && (lowerBound.equals(defaultRange.getUpperBound()))) {
                        return lowerBound;
                    }
                }
            }
        }

        return null;
    }
257148
public Iterator<Node> getOrderedVersions(final Graph g, final Node subject, final Resource predicate) {
        final List<Node> vs = listObjects(g, subject, predicate.asNode()).toList();
        vs.sort(Comparator.comparing(v -> getVersionDate(g, v)));
        return vs.iterator();
    }
767422
public String getLastRelease(final Collection<String> versions) {
        final List<Version> sorted = versions.stream()
                .filter(Version::isValid)               // filter invalid input values
                .map(Version::make)
                .filter(Optional::isPresent)
                .map(Optional::get)
                .filter(Version::isRelease)
                .sorted((v1, v2) -> {
                    try {
                        return v1.compare(v2);
                    } catch (IncomparableException e) {
                        return 0;
                    }
                })
                .collect(Collectors.toList());

        if(sorted.isEmpty()) {
            if(LOG.isWarnEnabled()) {
                LOG.warn(String.format("Cannot obtain last release from collection %s", versions.toString()));
            }
            return null;
        }

        return sorted.get(sorted.size() - 1).toString();
    }