Returns a map with library infos for the requested libraries

@param {Array} aLibrariesToTest list of libraries to load
@returns a map of library infos
12807
function getRequestedLibraries(aLibrariesToTest) {
		var mLibraries = sap.ui.getCore().getLoadedLibraries(),
			bNewLibrary,
			i;

		// make sure the explicitly requested libraries are there
		for (i = 0; i < aLibrariesToTest.length; i++) {
			if (!mLibraries[aLibrariesToTest[i]]) {
				sap.ui.getCore().loadLibrary(aLibrariesToTest[i]); // no try-catch, as this library was explicitly requested
				bNewLibrary = true;
			}
		}

		if (bNewLibrary) {
			mLibraries = sap.ui.getCore().getLoadedLibraries();
		}

		for (var sLibraryName in mLibraries) {
			if (aLibrariesToTest.indexOf(sLibraryName) === -1) {
				mLibraries[sLibraryName] = undefined;
			}
		}

		return mLibraries;
	}
506087
public function getLibraries()
    {
        $config = \Altamira\Config::getInstance();
        $libraryToPath = array(
                \Altamira\JsWriter\Flot::LIBRARY    =>    $config['js.flotlib'],
                \Altamira\JsWriter\JqPlot::LIBRARY  =>    $config['js.jqplotlib']
                );
        $libraryKeys = array_unique( array_keys( $this->libraries ) );
        $libraryPaths = array();
        
        foreach ($libraryKeys as $key) {
            $libraryPaths[] = $libraryToPath[$key];
        }
        
        return $libraryPaths;
    }
843459
def interrogate(self, platformIdentifier, configuration, libraries, libOverrides = {}):
		
		
		# Determine which libraries need their modules parsed by UBT, and which are override-only
		libModules = list([lib for lib in libraries if lib not in libOverrides])
		
		# Check that we have at least one module to parse
		details = ThirdPartyLibraryDetails()
		if len(libModules) > 0:
			
			# Retrieve the list of third-party library modules from UnrealBuildTool
			modules = self._getThirdPartyLibs(platformIdentifier, configuration)
			
			# Filter the list of modules to include only those that were requested
			modules = [m for m in modules if m['Name'] in libModules]
			
			# Emit a warning if any of the requested modules are not supported
			names = [m['Name'] for m in modules]
			unsupported = ['"' + m + '"' for m in libModules if m not in names]
			if len(unsupported) > 0:
				Utility.printStderr('Warning: unsupported libraries ' + ','.join(unsupported))
			
			# Some libraries are listed as just the filename without the leading directory (especially prevalent under Windows)
			for module in modules:
				if len(module['PublicAdditionalLibraries']) > 0 and len(module['PublicLibraryPaths']) > 0:
					libPath = (self._absolutePaths(module['PublicLibraryPaths']))[0]
					libs = list([lib.replace('\\', '/') for lib in module['PublicAdditionalLibraries']])
					libs = list([os.path.join(libPath, lib) if '/' not in lib else lib for lib in libs])
					module['PublicAdditionalLibraries'] = libs
			
			# Flatten the lists of paths
			fields = [
				'Directory',
				'PublicAdditionalLibraries',
				'PublicLibraryPaths',
				'PublicSystemIncludePaths',
				'PublicIncludePaths',
				'PrivateIncludePaths',
				'PublicDefinitions'
			]
			flattened = {}
			for field in fields:
				transform = (lambda l: self._absolutePaths(l)) if field != 'Definitions' else None
				flattened[field] = self._flatten(field, modules, transform)
			
			# Compose the prefix directories from the module root directories, the header and library paths, and their direct parent directories
			libraryDirectories = flattened['PublicLibraryPaths']
			headerDirectories  = flattened['PublicSystemIncludePaths'] + flattened['PublicIncludePaths'] + flattened['PrivateIncludePaths']
			modulePaths        = flattened['Directory']
			prefixDirectories  = list(set(flattened['Directory'] + headerDirectories + libraryDirectories + [os.path.dirname(p) for p in headerDirectories + libraryDirectories]))
			
			# Wrap the results in a ThirdPartyLibraryDetails instance, converting any relative directory paths into absolute ones
			details = ThirdPartyLibraryDetails(
				prefixDirs  = prefixDirectories,
				includeDirs = headerDirectories,
				linkDirs    = libraryDirectories,
				definitions = flattened['PublicDefinitions'],
				libs        = flattened['PublicAdditionalLibraries']
			)
		
		# Apply any overrides
		overridesToApply = list([libOverrides[lib] for lib in libraries if lib in libOverrides])
		for override in overridesToApply:
			details.merge(override)
		
		return details
439230
function getAPIDescriptionElems(){
	var resp = $('.documentation__routes');
	var namespaces = _.map(resp.children(), function(sectionChild){
		var namespace = {
			name: sectionChild.attribs.id.replace(/\s/, ''),
		};
		var methodDescWrapElems = _.map(sectionChild.children, function(child, i){
			if(child.attribs && child.attribs.class && utils.hasClass('toc-el', child.attribs.class)){
				return child; 	
			}
		});
		namespace.el = _.compact(methodDescWrapElems);
		return namespace;
	});
	return namespaces;
}
19267
function createSymbolSummaryForLib(lib) {
		let file = path.join(unpackedTestresourcesRoot, lib.replace(/\./g, "/"), "designtime/api.json");

		return readJSONFile(file).then(function (apijson) {
			if (!apijson.hasOwnProperty("symbols") || !Array.isArray(apijson.symbols)) {
				// Ignore libraries with invalid api.json content like empty object or non-array "symbols" property.
				return [];
			}
			return apijson.symbols.map(symbol => {
				let oReturn = {
					name: symbol.name,
					kind: symbol.kind,
					visibility: symbol.visibility,
					extends: symbol.extends,
					implements: symbol.implements,
					lib: lib
				};
				// We add deprecated member only when the control is deprecated to keep file size at check
				if (symbol.deprecated) {
					oReturn.deprecated = true;
				}
				collectLists(symbol);
				return oReturn;
			});
		})
	}
125471
def get_library_meta(self):
        '''
        
        '''
        parent_dir = os.path.dirname(self.library_dir)
        if self.test_file_exists(os.path.join(self.library_dir,'meta'),['libraries.json']):
            with open(os.path.join(self.library_dir,'meta','libraries.json'),'r') as f:
                meta_data = json.load(f)
                if isinstance(meta_data,list):
                    for lib in meta_data:
                        if lib['key'] == self.library_key:
                            return lib
                elif 'key' in meta_data and meta_data['key'] == self.library_key:
                    return meta_data
        if not self.test_dir_exists(os.path.join(self.library_dir,'meta')) \
            and self.test_file_exists(os.path.join(parent_dir,'meta'),['libraries.json']):
            with open(os.path.join(parent_dir,'meta','libraries.json'),'r') as f:
                libraries_json = json.load(f)
                if isinstance(libraries_json,list):
                    for lib in libraries_json:
                        if lib['key'] == self.library_key:
                            return lib
        return None
1360344
public static String getPlatformLibraryName(final String aLibraryName) {
        String libName = null;

        switch (getArchitecture()) {
            case LINUX_32:
            case LINUX_64:
            case LINUX_ARM:
                libName = LIB_PREFIX + aLibraryName + ".so";
                break;
            case WINDOWS_32:
            case WINDOWS_64:
                libName = aLibraryName + ".dll";
                break;
            case OSX_32:
            case OSX_64:
                libName = LIB_PREFIX + aLibraryName + ".dylib";
                break;
            default:
                LOGGER.warn("Unexpected architecture value: {}", getArchitecture());
                break;
        }

        LOGGER.debug(MessageCodes.UTIL_025, libName);
        return libName;
    }
76626
def library_specs(self):
    """"""
    return [Address.parse(spec, relative_to=self.address.spec_path).spec
            for spec in self.payload.library_specs]
1211690
function listSearchPaths(output) {
    var book = output.getBook();
    var plugins = output.getPlugins();

    var searchPaths = plugins
        .valueSeq()
        .map(function(plugin) {
            return plugin.getPath();
        })
        .toList();

    return searchPaths.unshift(book.getContentRoot());
}
305163
function getLibOptions(aliases, itemsToOmit) {
    let aliased = _.transform(options, function(result, value, key) {
      let alias = aliases[key];
      result[alias || key] = value;
    });
    return _.omit(aliased, itemsToOmit);
  }
1354904
function mapStructures (structures) {
  var result = [];

  if (structures === undefined) return result;

  _getElementChildNodes(structures).forEach(function (c) {
    _getElementChildNodes(c).forEach(function (s) {
      if ((s.localName === undefined) || (s.localName === null)) return;

      var handler = {
        'Categorisation': mapSimpleMaintainable,
        'CategoryScheme': mapItemScheme,
        'Dataflow': mapSimpleMaintainable,
        'AgencyScheme': mapItemScheme,
        'Codelist': mapItemScheme,
        'ConceptScheme': mapItemScheme,
        'HierarchicalCodelist': mapHierarchicalCodelist,
      }[s.localName];

      if (handler === undefined) {
        console.log('No mapping for ' + s.localName);
      } else {
        result.push(handler(s));
      }
    });
  });

  return result;
}
1007768
public static String getElasticSearchAddDocument(Map<String, String> values) {
    StringBuilder builder = new StringBuilder();
    builder.append("{");
    boolean first = true;
    for (Map.Entry<String, String> pair : values.entrySet()) {
      if (!first) {
        builder.append(",");
      }
      JSONUtils.addElasticSearchField(builder, pair);
      first = false;
    }
    builder.append("}");
    return builder.toString();
  }
85789
private String[] requiredLibraries() {
        List<String> libraries = new ArrayList<String>(Arrays.asList(
            "org.dbunit",
            "org.apache.commons",
            "org.apache.log4j",
            "org.slf4j",
            "org.yaml",
            "org.codehaus.jackson"
        ));

        if (!dbunitConfigurationInstance.get().isExcludePoi()) {
            libraries.add("org.apache.poi");
        }

        return libraries.toArray(new String[libraries.size()]);
    }
1109046
def list(search = nil)
      list = {}
      each_file_in_index('.js') do |filename|
        if /lib\/([^\/\-]+)-([\d\w\.\-]+)\/.+/.match filename
          name    = $1
          version = $2
        else
          name, version = Jim::VersionParser.parse_filename(filename)
        end
        if name && version
          list[name] ||= []
          list[name] << [version, filename]
        end
      end
      if search
        search = /#{search}/i
        list = list.find_all {|lib| lib[0] =~ search }
      end
      list.sort
    end
1104397
def check_for_libraries
      output = []

      required_libraries.each do |library|
        begin
          require library
        rescue LoadError
          install_command = @config['install_command']
          install_command = " -- install via #{install_command}" if install_command

          output << "Unable to load '#{library}'#{install_command}"
        end
      end

      return if output.empty?

      output.join("\n")
    end
33538
def getThirdPartyLibFiles(self, libs):
		
		platformDefaults = True
		if libs[0] == '--nodefaults':
			platformDefaults = False
			libs = libs[1:]
		
		details = self.getThirdpartyLibs(libs, includePlatformDefaults=platformDefaults)
		return details.getLibraryFiles(self.getEngineRoot(), delimiter='\n')
301541
def find_library(name, cached=True, internal=True):
    

    # a new one
    if not cached:
        return cdll.LoadLibrary(_so_mapping[name])

    # from the shared internal set or a new one
    if internal:
        if name not in _internal:
            _internal[name] = cdll.LoadLibrary(_so_mapping[name])
        return _internal[name]

    # a shared one
    return getattr(cdll, _so_mapping[name])