load_assemblers
 Collect all valid names for available assemblers

 @return [Array<String>] names and shortnames (if
          applicable) for available assemblers.
197464
def assembler_names
      a = []
      @assemblers.each do |t|
        a << t.name
        a << t.shortname if t.shortname
      end
      a
    end
241726
public static String[] loadParameterNames(Method m) {
        CapturedParameterNames cpn = m.getAnnotation(CapturedParameterNames.class);
        if(cpn!=null)   return cpn.value();

        // debug information, if present, is more trustworthy
        try {
            String[] n = ASM.loadParametersFromAsm(m);
            if (n!=null)    return n;
        } catch (LinkageError e) {
            LOGGER.log(FINE, "Incompatible ASM", e);
        } catch (IOException e) {
            LOGGER.log(WARNING, "Failed to load a class file", e);
        }

        // otherwise check the .stapler file
        Class<?> c = m.getDeclaringClass();
        URL url = c.getClassLoader().getResource(
                    c.getName().replace('.', '/').replace('$','/') + '/' + m.getName() + ".stapler");
        if(url!=null) {
            try {
                return IOUtils.toString(url.openStream()).split(",");
            } catch (IOException e) {
                LOGGER.log(WARNING, "Failed to load "+url,e);
                return EMPTY_ARRAY;
            }
        }

        // couldn't find it
        return EMPTY_ARRAY;
    }
1071848
def _get_valid_checkers(self, ds, checker_names):
        

        assert len(self.checkers) > 0, "No checkers could be found."

        if len(checker_names) == 0:
            checker_names = list(self.checkers.keys())

        args = [(name, self.checkers[name]) for name in checker_names if name in self.checkers]
        valid = []

        all_checked = set([a[1] for a in args])  # only class types
        checker_queue = set(args)
        while len(checker_queue):
            name, a = checker_queue.pop()
            # is the current dataset type in the supported filetypes
            # for the checker class?
            if type(ds) in a().supported_ds:
                valid.append((name, a))

            # add any subclasses of the checker class
            for subc in a.__subclasses__():
                if subc not in all_checked:
                    all_checked.add(subc)
                    checker_queue.add((name, subc))

        return valid
25003
private function loadPackageDescriptors()
    {
        $descriptors = [];
        try {
            /** @var JsonFile $autoload */
            $autoload = $this->extFs->get('vendor/autoload.json');
        } catch (FileNotFoundException $e) {
            return $descriptors;
        }

        // Get extensions we're managing via the autoloader
        foreach ((array) $autoload->parse() as $name => $loader) {
            $descriptors[$name] = PackageDescriptor::create($loader);
        }

        return $descriptors;
    }
1261398
def ir_instrs(self):
        
        ir_instrs = []

        for asm_instr in self._instrs:
            ir_instrs += asm_instr.ir_instrs

        return ir_instrs
228108
public List<String> getNames() {
        if (this.isEmpty()) {
            return Collections.emptyList();
        } else {
            final List<String> names = new ArrayList<>(this.size());
            for (final T i : this) {
                names.add(i.getName());
            }
            return names;
        }
    }
559537
def compile_mpim_users(self):
        

        mpim_data = self._read_from_json("mpims.json")
        mpims = [c for c in mpim_data.values()]
        all_mpim_users = []

        for mpim in mpims:
            mpim_members = {"name": mpim["name"], "users": [self.__USER_DATA[m] for m in mpim["members"]]}
            all_mpim_users.append(mpim_members)

        return all_mpim_users
1050289
def get_assembly_names():
    

    return [
        n.replace(".json.gz", "")
        for n in pkg_resources.resource_listdir(__name__, _assy_dir)
        if n.endswith(".json.gz")
    ]
969978
private Set<String> getSearchIndexNames() {

        Set<String> names = new HashSet<String>();
        @SuppressWarnings("unchecked")
        Set<I_CmsSearchIndex> indexes = (Set<I_CmsSearchIndex>)getValue();
        for (I_CmsSearchIndex index : indexes) {
            names.add(index.getName());
        }
        return names;
    }
427241
private List<String> extractIndexNames() {

        List<String> modules = new ArrayList<String>();

        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(getParamIndexes())) {
            StringTokenizer tok = new StringTokenizer(getParamIndexes(), ",");
            while (tok.hasMoreTokens()) {
                String module = tok.nextToken();
                modules.add(module);
            }
        }
        return modules;
    }
26632
def run
      if @options[:list_assemblers]
        puts @assemblerman.list_assemblers
        return
      elsif @options[:install_assemblers]
        @assemblerman.install_assemblers(@options[:install_assemblers])
        return
      end

      if (@options[:left].nil? || @options[:right].nil?)
        logger.error "Reads must be provided with --left and --right"
        logger.error "Try --help for command-line help"
        exit(1)
      end

      unless (@options[:timelimit].nil?)
        logger.info "Time limit set to #{@options[:timelimit]}"
      end

      subsample_input

      res = @assemblerman.run_all_assemblers @options
      write_metadata res
      merge_assemblies res

    end
575000
def get_netki_names(self, fetch=False):
        """"""
        return NetkiNames(self.resource.netki_names, self.client, populate=fetch)
429271
def load_all_objects
            return if loaded? or @parser.nil?

            @revisions.each do |revision|
                if revision.xreftable?
                    xrefs = revision.xreftable
                elsif revision.xrefstm?
                    xrefs = revision.xrefstm
                else
                    next
                end

                xrefs.each_with_number do |xref, no|
                    self.get_object(no) unless xref.free?
                end
            end

            loaded!
        end
230766
def load_deps(deps)
      deps.each do |file|
        if File.file?(file)
          Rake::MakefileLoader.new.load(file)
        end
      end
    end
1169400
def _iter_names(self):
        
        table_format, count, strings_offset = self._table_header
        table_bytes = self._table_bytes

        for idx in range(count):
            platform_id, name_id, name = self._read_name(
                table_bytes, idx, strings_offset
            )
            if name is None:
                continue
            yield ((platform_id, name_id), name)
890058
def names(self):
        
        pkg_names = []
        for line in self.SLACKBUILDS_TXT.splitlines():
            if line.startswith(self.line_name):
                pkg_names.append(line[17:].strip())
        return pkg_names
737219
def _get_names(self, path: str) -> Iterator[str]:
        
        for i in RequirementsFinder._get_names_cached(path):
            yield i