Populate list of levels.
547139
private static void populateLevels() {
        levelList = new LinkedList();

        levelList.add(Level.FATAL.toString());
        levelList.add(Level.ERROR.toString());
        levelList.add(Level.WARN.toString());
        levelList.add(Level.INFO.toString());
        levelList.add(Level.DEBUG.toString());
		Level trace = Level.toLevel(5000, null);
		if (trace != null) {
			levelList.add(trace.toString());
		}

        utilLoggingLevelList = new LinkedList();

        utilLoggingLevelList.add(UtilLoggingLevel.SEVERE.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.WARNING.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.INFO.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.CONFIG.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.FINE.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.FINER.toString());
        utilLoggingLevelList.add(UtilLoggingLevel.FINEST.toString());

    }
648314
def levels(self, with_mem=True):
        """"""
        p = self.first_level
        while p is not None:
            yield p
            # FIXME bad hack to include victim caches, need a more general solution, probably
            # involving recursive tree walking
            if p.victims_to is not None and p.victims_to != p.load_from:
                yield p.victims_to
            if p.store_to is not None and p.store_to != p.load_from and p.store_to != p.victims_to:
                yield p.store_to
            p = p.load_from

        if with_mem:
            yield self.main_memory
1208305
private static void createList( int data[], int k , int level , List<int[]> ret )
    {
        data[k] = level;

        if( level < data.length-1 ) {
            for( int i = 0; i < data.length; i++ ) {
                if( data[i] == -1 ) {
                    createList(data,i,level+1,ret);
                }
            }
        } else {
            int []copy = new int[data.length];
            System.arraycopy(data,0,copy,0,data.length);
            ret.add(copy);
        }
        data[k] = -1;
    }
588106
def populate(self, **values):
        """"""
        values = values.copy()
        fields = list(self.iterate_with_name())
        for _, structure_name, field in fields:
            if structure_name in values:
                field.__set__(self, values.pop(structure_name))
        for name, _, field in fields:
            if name in values:
                field.__set__(self, values.pop(name))
608838
def populate_records(self):
        

        self.object_list = self.get_valuesqueryset(self.object_list)
        super(ValuesDatatable, self).populate_records()
1035793
def descendants(self):
        """"""
        for i in self.current_item.items:
            self.move_to(i)
            if i.type == TYPE_COLLECTION:
                for c in self.children:
                    yield c
            else:
                yield i
            self.move_up()
1306300
private void updateLevel() {

        @SuppressWarnings("unchecked")
        List<Logger> logger = (List<Logger>)m_container.getItemIds();

        for (Logger item : logger) {
            m_container.getItem(item).getItemProperty(TableColumn.Level).setValue(LoggerLevel.fromLogger(item));
        }
        resetPageBuffer();
        refreshRenderedCells();
        refreshRowCache();
    }
789967
function list(node) {
  var self = this
  var start = node.start
  var children = node.children
  var length = children.length
  var index = -1
  var values = []
  var bullet

  self.level++

  while (++index < length) {
    bullet = start ? start + index + '.' : '\\(bu'
    values.push(listItem.call(self, children[index], bullet, index))
  }

  self.level--

  return ['.RS ' + (this.level ? 4 : 0), values.join('\n'), '.RE 0\n'].join(
    '\n'
  )
}
537105
def get_levels_of_description(self):
        
        if not hasattr(self, "levels_of_description"):
            cursor = self.db.cursor()
            levels = set()
            cursor.execute("SELECT distinct(resourceLevel) FROM Resources")
            for row in cursor:
                levels.add(row)
            cursor.execute("SELECT distinct(resourceLevel) FROM ResourcesComponents")
            for row in cursor:
                levels.add(row)
            self.levels_of_description = list(levels)

        return self.levels_of_description
815885
def get_level(self, level=2):
        """"""
        if level == 1:
            for child in self.children.values(): yield child
        else:
            for child in self.children.values():
                for node in child.get_level(level-1): yield node
1083991
def ListChildren(self, urn):
    """"""
    result = self.MultiListChildren([urn])
    try:
      return result[urn]
    except KeyError:
      return []
1263677
def tempkeys(self):
    
    self.levels.append(dict(self.levels[-1]))
    try: yield
    finally: self.levels.pop()
530104
def children_to_list(node):
    """"""
    if node['type'] == 'item' and len(node['children']) == 0:
        del node['children']
    else:
        node['type'] = 'folder'
        node['children'] = list(node['children'].values())
        node['children'].sort(key=lambda x: x['name'])
        node['children'] = map(children_to_list, node['children'])
    return node
1153333
def get_items(self):
        """"""
        itemlist = []
        def add_to_itemlist(item):
            for index in range(item.childCount()):
                citem = item.child(index)
                itemlist.append(citem)
                add_to_itemlist(citem)
        for tlitem in self.get_top_level_items():
            add_to_itemlist(tlitem)
        return itemlist
42825
public static void populateFilesList(File dir, List<File> filesListInDir) {
		File[] files = dir.listFiles();
		for(File file : files){
			if(file.isFile()){
				filesListInDir.add(file);
			}else{
				populateFilesList(file, filesListInDir);
			}
		}
	}
223076
public void setLevels(Map<Integer, Long> levels) {
        SystemAssert.requireArgument(levels != null, "Levels cannot be null");
        this.levels.clear();
        this.levels.putAll(levels);
    }
129073
def multi(self, lvl_list, msg, *args, **kwargs):
        
        for level in lvl_list:
            self.log(level, msg, args, **kwargs)