Finds all unique category ids in a log or a schedule
 @param entries [Hash] A parsed log or schedule
 @return [Array, String] Unique category ids
514289
def category_ids(entries)
      category_ids = []
      entries.each do |day, tasks|
        category_ids += tasks.keys
      end
      category_ids.uniq
    end
879493
function(entries) {
        for ( var assetKey in entries ) {
            if ( entries.hasOwnProperty(assetKey) === false ) { continue; }
            entry = entries[assetKey];
            if ( entry.content !== 'filters' ) { continue; }
            newAvailableLists[assetKey] = Object.assign({}, entry);
        }

        // Load set of currently selected filter lists.
        var listKeySet = new Set(µb.selectedFilterLists);
        for ( listKey in newAvailableLists ) {
            if ( newAvailableLists.hasOwnProperty(listKey) ) {
                newAvailableLists[listKey].off = !listKeySet.has(listKey);
            }
        }

        finalize();
        callback(newAvailableLists);
    }
477669
def entries(self):
        
        layout = self._entryWidget.layout()
        output = []
        for i in range(layout.count() - 1):
            widget = layout.itemAt(i).widget()
            if not isinstance(widget, XOrbQueryEntryWidget):
                continue
            output.append(widget)
        return output
79890
def categories_list=(ids)
      ids = ids.is_a?(String) ? ids.split(',') : ids
      self.categories = ids.map do |id|
        Category.where(id: id).first
      end
    end
1326663
def get_log_entries(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.LogEntryList(self._results, runtime=self._runtime)
779674
def get_unlabeled_entries(self):
        
        return [
            (idx, entry[0]) for idx, entry in enumerate(self.data)
            if entry[1] is None
        ]
71944
function entries() {
  var result = []

  this.forEach(function(val, key) {
    result.push( [ key, val ] )
  })

  return result
}
916958
def entries(self):
        
        entries_list = self._timesheets_callback('entries')()

        return reduce(lambda x, y: x + y, entries_list)
472047
def WriteFlowLogEntries(self, entries):
    """"""
    flow_ids = [(e.client_id, e.flow_id) for e in entries]
    for f in flow_ids:
      if f not in self.flows:
        raise db.AtLeastOneUnknownFlowError(flow_ids)

    for e in entries:
      dest = self.flow_log_entries.setdefault((e.client_id, e.flow_id), [])
      to_write = e.Copy()
      to_write.timestamp = rdfvalue.RDFDatetime.Now()
      dest.append(to_write)
898716
def index_all(klass, ids, options = {})
      Entry.enqueue(self, klass, ids, false, options[:priority] || self.class.default_priority)
    end
1042791
def hash_log_entries(log_entries: Iterable[Tuple[bytes, List[int], bytes]]) -> Hash32:
    
    logs = [Log(*entry) for entry in log_entries]
    encoded_logs = rlp.encode(logs)
    logs_hash = keccak(encoded_logs)
    return logs_hash
915795
def _entries_sorted(self):
        """"""
        return sorted(self.entries.values(), key=lambda e: (e.path, e.stage))
364043
def entries(self):
        
        list_of_rows = []
        try:
            list_of_rows = self.bc_dao.get_all()
        except LookupError as e:
            self.logger.error('MX Exception {0}'.format(e), exc_info=True)
        return list_of_rows
770796
def find_entities(results)
      document = ::Nokogiri::XML(results.body)
      document.remove_namespaces!
      document.xpath('//entry')
    end
1313136
private static int compareEntry(ArrayList<Entry> entries, int entry, int target) {
    return entries.get(entry).getGeneratedColumn() - target;
  }
356371
public ListInventoryEntriesResult withEntries(java.util.Collection<java.util.Map<String, String>> entries) {
        setEntries(entries);
        return this;
    }
409325
def generate_entries_for_all_tags
      puts "Generating entry..." if options[:verbose]

      entries = generate_unreleased_entry

      @tag_section_mapping.each_pair do |_tag_section, left_right_tags|
        older_tag, newer_tag = left_right_tags
        entries += generate_entry_between_tags(older_tag, newer_tag)
      end

      entries
    end