Gets list of installed Windows SDKs

@return  {Version[]}  List of installed SDKs' versions
486397
function getInstalledWindowsSdks () {
    var installedSdks = [];
    return spawn('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows', '/s', '/v', 'InstallationFolder', '/reg:32'])
        .fail(function () { return ''; })
        .then(function (output) {
            var re = /\\Microsoft SDKs\\Windows\\v(\d+\.\d+)\s*InstallationFolder\s+REG_SZ\s+(.*)/gim;
            var match;
            while ((match = re.exec(output))) {
                var sdkPath = match[2];
                // Verify that SDKs is really installed by checking SDKManifest file at SDK root
                if (shell.test('-e', path.join(sdkPath, 'SDKManifest.xml'))) {
                    installedSdks.push(Version.tryParse(match[1]));
                }
            }
        }).thenResolve(installedSdks);
}
677946
def get_applications(self):
        """"""
        if ('applications' not in self.data or
                'gecko' not in self.data['applications']):
            return []
        app = self.data['applications']['gecko']
        min_version = app.get('strict_min_version', u'42.0')
        max_version = app.get('strict_max_version', u'*')
        return [{u'guid': FIREFOX_GUID,
                 u'min_version': min_version,
                 u'max_version': max_version}]
1030001
function getLockfileDependencies(root) {
  var deps = {};
  if (root.name && root.version) {
    deps[root.name + "@" + root.version] = {
      "pm": "npm",
      "name": root.name,
      "version": root.version
    };
  }

  if (root.dependencies) {
    for (var name in root.dependencies) {
      var dep = root.dependencies[name];
      if (dep.version) {
        deps[name + "@" + dep.version] = {
          "pm": "npm",
          "name": name,
          "version": dep.version
        };
      }

      var childDeps = getLockfileDependencies(root.dependencies[name]);
      for (var attr in childDeps) {
        deps[attr] = childDeps[attr];
      }
    }
  }

  return Object.keys(deps).map(function (k) { return deps[k];});
}
1135036
public java.util.List<ClusterVersion> getClusterVersions() {
        if (clusterVersions == null) {
            clusterVersions = new com.amazonaws.internal.SdkInternalList<ClusterVersion>();
        }
        return clusterVersions;
    }
620472
def get_sdk_version(self):
        """"""
        name = 'VCVarsQueryRegistry.bat'
        path = os.path.join(self.tool_dir, name)
        batch = read_file(path)
        if not batch:
            raise RuntimeError(_('failed to find the SDK version'))
        regex = r'(?<=\\Microsoft SDKs\\Windows\\).+?(?=")'
        try:
            version = re.search(regex, batch).group()
        except AttributeError:
            return ''
        else:
            logging.debug(_('SDK version: %s'), version)
            return version
1127852
function list () {
  const PATH = process.env.PATH
  const delimiter = isWindows ? ';' : ':'
  const paths = PATH.split(delimiter)

  return Promise.all(
    paths.map(fsReadDir)
  )
    .then((results) => {
      let mergedResults = []
      mergedResults = mergedResults.concat.apply(mergedResults, results)
      return filterExe(filterBlinkm(mergedResults))
    })
}
1098330
function getAvailableNPMVersions () {
  return new Promise((resolve, reject) => {
    exec('npm view npm versions --json', (err, stdout) => {
      if (err) {
        let error = 'We could not show latest available versions. Try running this script again '
        error += 'with the version you want to install (npm-windows-upgrade --npm-version 3.0.0)'
        return reject(error)
      }

      resolve(JSON.parse(stdout))
    })
  })
}
1005823
function aboutSessionRestore_getWindows() {
    var windows = [ ];
    var tree = this.tabList.getNode();

    for (var ii = 0; ii < tree.view.rowCount; ii++) {
      if (tree.view.isContainer(ii)) {
        windows.push({
                      index: windows.length,
                      listIndex : ii,
                      open: tree.view.isContainerOpen(ii),
                      restore: tree.view.getCellValue(ii, tree.columns.getColumnAt(0)),
                      title: tree.view.getCellText(ii, tree.columns.getColumnAt(2))
                     });
      }
    }

    return windows;
  }
374101
static List<String> getExecutableNames() {
        List<String> executableNames = new ArrayList<>();
        if (Platform.getCurrent().is(Platform.WINDOWS)) {
            Collections.addAll(executableNames, ProcessNames.PHANTOMJS.getWindowsImageName(),
                    ProcessNames.CHROMEDRIVER.getWindowsImageName(), ProcessNames.IEDRIVER.getWindowsImageName(),
                    ProcessNames.EDGEDRIVER.getWindowsImageName(), ProcessNames.GECKODRIVER.getWindowsImageName());
        } else {
            Collections.addAll(executableNames, ProcessNames.PHANTOMJS.getUnixImageName(),
                    ProcessNames.CHROMEDRIVER.getUnixImageName(), ProcessNames.GECKODRIVER.getUnixImageName());
        }
        return executableNames;
    }
448413
function _getLoadedLibraries() {
			var libraries = sap.ui.getCore().getLoadedLibraries();
			var formattedLibraries = Object.create(null);

			Object.keys(sap.ui.getCore().getLoadedLibraries()).forEach(function (element, index, array) {
				formattedLibraries[element] = libraries[element].version;
			});

			return formattedLibraries;
		}
169554
public static String[] getArrayOfVersions(Map< String, Dependency> dependencies) {
        List<String> versionList = new LinkedList<String>();

        for (Dependency dependency : dependencies.values()) {
            versionList.add(dependency.getVersion());
        }

        return versionList.toArray(new String[versionList.size()]);
    }
724575
def _get_window_list(self):
        
        window_list = Quartz.CGWindowListCopyWindowInfo(Quartz.kCGWindowListExcludeDesktopElements, Quartz.kCGNullWindowID)
        return window_list
723880
function () {
            var services = [], smdServices = this.smd.services;

            Object.keys(smdServices || []).forEach(function (serviceName) {
                services.push(smdServices[serviceName]);
            });

            return services;
        }
255890
public static String[] getSupportedAbis() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
      return new String[]{Build.CPU_ABI, Build.CPU_ABI2};
    } else {
      return LollipopSysdeps.getSupportedAbis();
    }
  }
375817
function getPackages() {
	var results = [];

	if (extensions && extensions.hasOwnProperty('packages')) {
		var sourceArray = extensions.packages;

		for (index = 0; index < sourceArray.length; ++index) {
		    results.push(sourceArray[index]);
		}
	}

	return results;
}
601612
def getVersions(self):
        
        if not os.path.exists(self._path):
            return []

        result = []

        for entryName in os.listdir(self._path):
            try:
                entryVersion = Version(entryName)
                result.append(entryVersion)
            except InvalidVersionException:
                continue

        return result
103651
private List getVersions() {

        ArrayList ret = new ArrayList();

        int defaultHistoryVersions = OpenCms.getSystemInfo().getHistoryVersions();
        int historyVersions = 0;

        // Add the option for disabled version history
        ret.add(
            new CmsSelectWidgetOption(
                "-1",
                true,
                Messages.get().getBundle().key(Messages.GUI_HISTORY_CLEAR_VERSION_SELECT_0)));

        // Iterate from 1 to 50 with a stepping of 1 for the first 10 entries and a stepping of five for the entries from 10 to 50
        while (historyVersions < 50) {

            // increment the history version
            historyVersions++;

            if (((historyVersions % 5) == 0) || (historyVersions <= 10)) {

                ret.add(
                    new CmsSelectWidgetOption(String.valueOf(historyVersions), false, String.valueOf(historyVersions)));
            }
        }

        // If the default setting for the version history is more than 50
        if (defaultHistoryVersions > historyVersions) {
            ret.add(
                new CmsSelectWidgetOption(
                    String.valueOf(defaultHistoryVersions),
                    false,
                    String.valueOf(defaultHistoryVersions)));
        }

        return ret;
    }