Return list bean ids that the assembler is currently aware of.
974631
public Set<BeanId> getIds() {
        Set<BeanId> ids = new HashSet<>();
        ids.addAll(beansQuery);
        ids.addAll(beans.keySet());
        return ids;
    }
493170
def worker_thread_ids
      thread_group = java.lang.Thread.currentThread.getThreadGroup
      threads = java.lang.reflect.Array.newInstance(
        java.lang.Thread.java_class, thread_group.activeCount)
      thread_group.enumerate(threads)
      # NOTE: we shall check the name from $servlet_context.getServletContextName
      # but that's an implementation detail of the factory currently that threads
      # are named including their context name. thread grouping should be fine !
      threads.map do |thread| # a convention is to name threads as "worker" :
        thread && thread.getName.index(WORKER_THREAD_ID) ? thread.getName : nil
      end.compact
    end
1067279
public MethodDescriptor[] getMethodDescriptors() {
        BeanInfo info = getBeanInfo();
        if (info == null) {
            return null;
        }

        MethodDescriptor[] mds = info.getMethodDescriptors();      
        getTeaToolsUtils().sortMethodDescriptors(mds);
        return mds;
    }
286868
def ids(self):
        
        if self._ids is None:
            if self._columns:
                if isinstance(self._columns, OrderedDict):
                    return [list(self._columns.keys())[0]]
                return [self._columns[0]]
        else:
            return self._ids
391565
def get_interfaces_details():
    '''
    
    '''
    _interfaces = [interface for interface in pyiface.getIfaces() if interface.flags & IFF_LOOPBACK == 0]
    if __grains__['lsb_distrib_id'] == 'nilrt':
        return {'interfaces': list(map(_get_interface_info, _interfaces))}
    # filter just the services
    _interfaces = [interface for interface in _interfaces if _interface_to_service(interface.name) is not None]
    return {'interfaces': list(map(_get_info, _interfaces))}
801812
def adj_names(self):
        
        return list(self.pst.parameter_data.parnme.loc[~self.fixed_indexer])
625369
def getInterfaceList (self, flags=0):
        """"""
        if sys.platform == 'darwin':
            command = ['ifconfig', '-l']
            if flags & self.IFF_UP:
                command.append('-u')
            # replace with subprocess.check_output() for Python 2.7
            res = subprocess.Popen(command, stdout=subprocess.PIPE).communicate()[0]
            return res.split()
        # initial 8kB buffer to hold interface data
        bufsize = 8192
        # 80kB buffer should be enough for most boxen
        max_bufsize = bufsize * 10
        while True:
            buf = array.array('c', '\0' * bufsize)
            ifreq = struct.pack("iP", buf.buffer_info()[1], buf.buffer_info()[0])
            try:
                result = self._ioctl(self.SIOCGIFCONF, ifreq)
                break
            except IOError as msg:
                # in case of EINVAL the buffer size was too small
                if msg[0] != errno.EINVAL or bufsize == max_bufsize:
                    raise
            # increase buffer
            bufsize += 8192
        # loop over interface names
        data = buf.tostring()
        iflist = []
        size, ptr = struct.unpack("iP", result)
        i = 0
        while i < size:
            ifconf = data[i:i+self.ifr_size]
            name = struct.unpack("16s%ds" % (self.ifr_size-16), ifconf)[0]
            name = name.split('\0', 1)[0]
            if name:
                if flags and not (self.getFlags(name) & flags):
                    continue
                iflist.append(name)
            i += self.ifr_size
        return iflist
732946
public List<MutableInputColumn<?>> getOutputColumns() {
        if (!isConfigured()) {
            // as long as the transformer is not configured, just return an
            // empty list
            return Collections.emptyList();
        }

        final Transformer<?> component = getComponentInstance();
        final TransformerBeanDescriptor<T> descriptor = getDescriptor();

        final InjectionManager injectionManager = getAnalysisJobBuilder().getConfiguration().getInjectionManager(null);
        final LifeCycleHelper lifeCycleHelper = new LifeCycleHelper(injectionManager, null, false);

        // mimic the configuration of a real transformer bean instance
        final BeanConfiguration beanConfiguration = new ImmutableBeanConfiguration(getConfiguredProperties());
        lifeCycleHelper.assignConfiguredProperties(descriptor, component, beanConfiguration);
        lifeCycleHelper.assignProvidedProperties(descriptor, component);

        // only validate, don't initialize
        lifeCycleHelper.validate(descriptor, component);

        final OutputColumns outputColumns = component.getOutputColumns();
        if (outputColumns == null) {
            throw new IllegalStateException("getOutputColumns() returned null on transformer: " + component);
        }
        boolean changed = false;

        // adjust the amount of output columns
        final int expectedCols = outputColumns.getColumnCount();
        final int existingCols = _outputColumns.size();
        if (expectedCols != existingCols) {
            changed = true;
            int colDiff = expectedCols - existingCols;
            if (colDiff > 0) {
                for (int i = 0; i < colDiff; i++) {
                    final int nextIndex = _outputColumns.size();
                    final String name = getColumnName(outputColumns, nextIndex);
                    final String id = _id + "-" + _idGenerator.nextId();
                    _outputColumns.add(new TransformedInputColumn<Object>(name, id));
                    _automaticOutputColumnNames.add(name);
                }
            } else if (colDiff < 0) {
                for (int i = 0; i < Math.abs(colDiff); i++) {
                    // remove from the tail
                    _outputColumns.remove(_outputColumns.size() - 1);
                    _automaticOutputColumnNames.remove(_automaticOutputColumnNames.size() - 1);
                }
            }

            // reset the names when the number of output columns change and the
            // initial name has changed
            for (int i = 0; i < expectedCols; i++) {
                final MutableInputColumn<?> column = _outputColumns.get(i);
                final String previousProposedName = column.getInitialName();
                final String newProposedName = outputColumns.getColumnName(i);
                if (newProposedName != null && !newProposedName.equals(previousProposedName)) {
                    column.setName(newProposedName);
                }
            }
        }

        // automatically update names and types of columns if they have not been
        // manually set
        for (int i = 0; i < expectedCols; i++) {
            final String proposedName = getColumnName(outputColumns, i);
            Class<?> dataType = outputColumns.getColumnType(i);
            if (dataType == null) {
                dataType = descriptor.getOutputDataType();
            }

            final TransformedInputColumn<?> col = (TransformedInputColumn<?>) _outputColumns.get(i);
            col.setInitialName(proposedName);
            if (dataType != col.getDataType()) {
                col.setDataType(dataType);
                changed = true;
            }

            final String automaticName = _automaticOutputColumnNames.get(i);
            final String columnName = col.getName();
            if (StringUtils.isNullOrEmpty(columnName) || automaticName.equals(columnName)) {
                if (proposedName != null) {
                    col.setName(proposedName);
                    _automaticOutputColumnNames.set(i, proposedName);
                }
            }
        }

        if (changed) {
            // notify listeners
            onOutputChanged();
        }

        return Collections.unmodifiableList(_outputColumns);
    }
1202817
def dimension_ids(self):
        
        return self._sorted_ingredients([
            d.id for d in self.values() if isinstance(d, Dimension)
        ])
765205
public final List<String> getConnectionFactoryInterfaceNames() {
        return cfInterfaceNames instanceof String ? Collections.singletonList((String) cfInterfaceNames) //
                        : cfInterfaceNames instanceof String[] ? Arrays.asList((String[]) cfInterfaceNames) //
                                        : Collections.<String> emptyList();
    }
128106
private static List<String> getAllInterfaceMethodInfo(List<InterfaceInfo> interfaceInfoList) {
        List<String> names = new ArrayList<>();

        if (interfaceInfoList == null || interfaceInfoList.isEmpty()){
            return names;
        }

        interfaceInfoList.forEach((InterfaceInfo interfaceInfo) -> {
            if (interfaceInfo.getMethodNames() != null && !interfaceInfo.getMethodNames().isEmpty()){
                names.addAll(interfaceInfo.getMethodNames());
            }

            names.addAll(getAllInterfaceMethodInfo(interfaceInfo.getExtendedInterfaces()));
        });

        return names;
    }
961348
def get_jids():
    '''
    
    '''
    conn, mdb = _get_conn(ret=None)
    map = "function() { emit(this.jid, this); }"
    reduce = "function (key, values) { return values[0]; }"
    result = mdb.jobs.inline_map_reduce(map, reduce)
    ret = {}
    for r in result:
        jid = r['_id']
        ret[jid] = salt.utils.jid.format_jid_instance(jid, r['value'])
    return ret
1370941
def list(args):
  """"""
  jm = setup(args)
  jm.list(job_ids=get_ids(args.job_ids), print_array_jobs=args.print_array_jobs, print_dependencies=args.print_dependencies, status=args.status, long=args.long, print_times=args.print_times, ids_only=args.ids_only, names=args.names)
95740
public List<FacesConfigManagedBeanType<FacesConfigType<T>>> getAllManagedBean()
   {
      List<FacesConfigManagedBeanType<FacesConfigType<T>>> list = new ArrayList<FacesConfigManagedBeanType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("managed-bean");
      for(Node node: nodeList)
      {
         FacesConfigManagedBeanType<FacesConfigType<T>>  type = new FacesConfigManagedBeanTypeImpl<FacesConfigType<T>>(this, "managed-bean", childNode, node);
         list.add(type);
      }
      return list;
   }
738487
def _get_all_scanner_ids(zap_helper):
    """"""
    scanners = zap_helper.zap.ascan.scanners()
    return [s['id'] for s in scanners]
1012914
def get_jids():
    '''
    
    '''
    conn = _get_conn(ret=None)
    cur = conn.cursor()
    sql = '''SELECT distinct jid, load FROM jids'''

    cur.execute(sql)
    data = cur.fetchall()
    ret = {}
    for jid, load in data:
        ret[jid] = salt.utils.jid.format_jid_instance(jid, salt.utils.json.loads(load))
    _close_conn(conn)
    return ret
1192133
private List<JawrConfigManagerMBean> getInitializedConfigurationManagers() {

		final List<JawrConfigManagerMBean> mBeans = new ArrayList<>();
		if (jsMBean != null) {
			mBeans.add(jsMBean);
		}

		if (cssMBean != null) {
			mBeans.add(cssMBean);
		}
		if (binaryMBean != null) {
			mBeans.add(binaryMBean);
		}

		return mBeans;
	}