Add entries to the main table.
        The *entries* variable should be an iterable yielding iterables.
549158
def add_by_steps(self, entries_by_step, table=None, columns=None):
        """"""
        for entries in entries_by_step: self.add(entries, table=table, columns=columns)
624014
def Append(self, new_values):
        
        newrow = self.NewRow()
        newrow.values = new_values
        self._table.append(newrow)
1206323
public final void addEntries(Entry<?>... entries) {
        if (entries != null) {
            for (Entry<?> entry : entries) {
                entry.setCalendar(this);
            }
        }
    }
206426
def add_variables(vars)
      # Store all the variables in the model
      # Most of the work will be done when we add the constraints
      vars.each do |var|
        var.model = self
        var.index = @variables.count
        @variables << var
      end
    end
380562
private static void addHarEntry(HarEntries entries, RecordHistory recordHistory) {
		entries.addEntry(
				HarUtils.createHarEntry(
						recordHistory.getHistoryId(),
						recordHistory.getHistoryType(),
						recordHistory.getHttpMessage()));
	}
1374914
void generateTableEntries(CodeBuilder ga) {
    for (Variable var : allVariables) {
      try {
        var.local.tableEntry(ga);
      } catch (Throwable t) {
        throw new RuntimeException("unable to write table entry for: " + var.local, t);
      }
    }
  }
1330945
void fillDeltaEntries(Set<PageLeafEntry> entries,
                        Row row,
                        int tail)
  {
    int rowOffset = _rowHead;
    
    byte []buffer = _buffer;

    while (rowOffset < tail) {
      int code = buffer[rowOffset] & CODE_MASK;

      int len = getLength(code, row);
      if (code == INSERT || code == REMOVE) {
        PageLeafEntry entry = new PageLeafEntry(this, row, rowOffset, len, code);
      
        entries.add(entry);
      }
      
      rowOffset += len;
    }
  }
1208152
def _preprocess_add_items(self, items):
        
        paths = []
        entries = []

        for item in items:
            if isinstance(item, string_types):
                paths.append(self._to_relative_path(item))
            elif isinstance(item, (Blob, Submodule)):
                entries.append(BaseIndexEntry.from_blob(item))
            elif isinstance(item, BaseIndexEntry):
                entries.append(item)
            else:
                raise TypeError("Invalid Type: %r" % item)
        # END for each item
        return (paths, entries)
437294
def add(self, *widgets):
        '''
        
        '''
        for w in widgets:
            if is_widget(w):
                if w not in self.widgets:
                    self.widgets.add(w)
                    w.add_internal(self)
            elif is_container(w):
                if w not in self.containers:
                    self.containers.add(w)
                    w.add_internal(self)
            else:
                # If it isn't an iterable, we'll get an error here.
                # Desired effect.
                self.add(*w)
795580
def _add_request_entry(self, entry=()):
        
        if not self._lookup_request_entry(entry):
            self.request_entry.append(entry)
895260
def add_entry_points(self, names):
        
        names = util.return_set(names)
        self.entry_point_names.update(names)
757708
def add(self, submission, archive, _):
        
        self.queue.put((submission, submission["result"], submission["grade"], submission["problems"], submission["tests"], submission["custom"], archive))
273889
def append(self, data):
        """"""
        for k in self._entries.keys():
            self._entries[k].append(data._entries[k])
272674
def append(self, x):
        
        super(EntriesList, self).append(x)

        if self.entries_collection is not None:
            self.entries_collection.add_entry(self.date, x)
22559
def add_table(self, t):
        
        self.push_element()
        self._page.append(t.node)
        self.cur_element = t
1263875
def add_variable(self, start, variable):
        

        size = variable.size if variable.size is not None else 1

        self.add_object(start, variable, size)
18242
def add_var_mb(table: PrettyTable,
               vardict: Dict[str, str],
               varname: str) -> None:
    
    valstr = vardict.get(varname, None)
    table.add_row([varname, val_mb(valstr), UNITS_MB])