Put a build side row to hash table.
512742
public void putBuildRow(BaseRow row) throws IOException {
		final int hashCode = hash(this.buildSideProjection.apply(row).hashCode(), 0);
		// TODO: combine key projection and build side conversion to code gen.
		insertIntoTable(originBuildSideSerializer.baseRowToBinary(row), hashCode);
	}
327456
def build(self, output_path=""):
        """"""

        self.output_path = self.checkOutputPath(output_path)
        self._buildStaticFiles()
        self.final_url = self._buildTemplates()
        printDebug("Done.", "comment")
        printDebug("=> %s" % (self.final_url), "comment")
        return self.final_url
302155
def build(self, stmts=None, set_check_var=True, invert=False):
        """"""
        out = ""
        if set_check_var:
            out += self.check_var + " = False\n"
        out += self.out()
        if stmts is not None:
            out += "if " + ("not " if invert else "") + self.check_var + ":" + "\n" + openindent + "".join(stmts) + closeindent
        return out
138946
function buildTable(tbody, data) {
  tbody.empty();
  data.forEach(function(item) {
    var row = $('<tr>').appendTo(tbody);
    $('<td>').appendTo(row).text(item.price);
    $('<td>').appendTo(row).text(item.weight);
    $('<td>').appendTo(row).text(item.taste);

    // Associate underlying data with row node so we can access it later
    // for filtering.
    row.data('item', item);
  });
}
902055
def insert_seperator_results(results):
    """"""
    sepbench = BenchmarkResult(*[' ' * w for w in COLUMN_WIDTHS])
    last_bm = None
    for r in results:
        if last_bm is None:
            last_bm = r.benchmark
        elif last_bm != r.benchmark:
            yield sepbench
            last_bm = r.benchmark
        yield r
673982
def update_table_row(self, table, row_idx):
        """"""
        table[row_idx]['path'] = self.path
        table[row_idx]['key'] = self.key
        table[row_idx]['creator'] = self.creator
        table[row_idx]['timestamp'] = self.timestamp
        table[row_idx]['status'] = self.status
        table[row_idx]['flags'] = self.flags
64928
private Put preparePut(String columnFamily, Object rowKey, Map<String, Attribute> columns, Map<String, Object> values)
            throws IOException
    {
        Put p = new Put(HBaseUtils.getBytes(rowKey));
        for (String columnName : columns.keySet())
        {
            Attribute column = columns.get(columnName);
            if (!column.isCollection() && !((SingularAttribute) column).isId())
            {
                String qualifier = columnName;
                try
                {
                    Object o = values.get(columnName);
                    byte[] value = HBaseUtils.getBytes(o);
                    if (value != null && columnFamily != null)
                    {
                        p.add(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier), value);
                    }
                }
                catch (PropertyAccessException e1)
                {
                    throw new IOException(e1);
                }
            }
        }
        return p;
    }
400356
final long buildHashCode(Object... keys) {
        ArrayList<Object> keyList = new ArrayList<>();

        Collections.addAll(keyList, keys);

        return buildHashCode(keyList);
    }
1271241
def append_to_table(self, table):
        
        table.add_row(dict(path=self.path,
                           key=self.key,
                           creator=self.creator,
                           timestamp=self.timestamp,
                           status=self.status,
                           flags=self.flags))
781738
def put(self, key, value):
    ''''''
    self.shardDatastore(key).put(key, value)
613997
def hashes
      all_rows = rows.locate
      header_row = all_rows.first || raise(Error, 'no rows in table')

      all_rows.entries[1..-1].map do |row|
        cell_size_check(header_row, row)
        Hash[headers(header_row).map(&:text).zip(row.cells.map(&:text))]
      end
    end
358008
def hashes
      all_rows = rows.to_a
      header_row = all_rows.shift or raise Exception::Error, "no rows in table"

      headers = header_row.ths.map { |header_cell| header_cell.text  }
      result = []

      all_rows.each_with_index do |row, idx|
        cells = row.cells.to_a
        if cells.length != headers.length
          raise Exception::Error, "row at index #{idx} has #{cells.length} cells, expected #{headers.length}"
        end

        result << headers.inject({}) { |res, header| res.merge(header => cells.shift.text) }
      end

      result
    end
355910
def process_hash_row(hsh)
      if @headers.any?
        keys_or_values = hsh.values
        @row_id = hsh[:row_id]
      else
        keys_or_values = hsh.keys.map(&:to_s)
      end

      file_line = keys_or_values.join(',')
      validated_line = utf_filter(check_utf(file_line))
      res = line_parse(validated_line)
      res
    end
1264798
def build(id=None, name=None, revision=None,
          temporary_build=False, timestamp_alignment=False,
          no_build_dependencies=False,
          keep_pod_on_failure=False,
          force_rebuild=False,
          rebuild_mode=common.REBUILD_MODES_DEFAULT):
    
    data = build_raw(id, name, revision, temporary_build, timestamp_alignment, no_build_dependencies,
              keep_pod_on_failure, force_rebuild, rebuild_mode)
    if data:
        return utils.format_json(data)
1014012
protected void addRow(final KeyValue row) {
    long last_ts = 0;
    if (rows.size() != 0) {
      // Verify that we have the same metric id and tags.
      final byte[] key = row.key();
      final iRowSeq last = rows.get(rows.size() - 1);
      final short metric_width = tsdb.metrics.width();
      final short tags_offset = 
          (short) (Const.SALT_WIDTH() + metric_width + Const.TIMESTAMP_BYTES);
      final short tags_bytes = (short) (key.length - tags_offset);
      String error = null;
      if (key.length != last.key().length) {
        error = "row key length mismatch";
      } else if (
          Bytes.memcmp(key, last.key(), Const.SALT_WIDTH(), metric_width) != 0) {
        error = "metric ID mismatch";
      } else if (Bytes.memcmp(key, last.key(), tags_offset, tags_bytes) != 0) {
        error = "tags mismatch";
      }
      if (error != null) {
        throw new IllegalArgumentException(error + ". "
            + "This Span's last row key is " + Arrays.toString(last.key())
            + " whereas the row key being added is " + Arrays.toString(key)
            + " and metric_width=" + metric_width);
      }
      last_ts = last.timestamp(last.size() - 1);  // O(n)
    }

    final RowSeq rowseq = new RowSeq(tsdb);
    rowseq.setRow(row);
    sorted = false;
    if (last_ts >= rowseq.timestamp(0)) {
      // scan to see if we need to merge into an existing row
      for (final iRowSeq rs : rows) {
        if (Bytes.memcmp(rs.key(), row.key(), Const.SALT_WIDTH(), 
            (rs.key().length - Const.SALT_WIDTH())) == 0) {
          rs.addRow(row);
          return;
        }
      }
    }
    
    rows.add(rowseq);
  }
187671
def row(self, fields):
        """"""

        d = self.dict

        row = [None] * len(fields)

        for i, f in enumerate(fields):
            if f in d:
                row[i] = d[f]

        return row
262623
def build_table_body
      data.each_with_index do |row, i|
        output << ",\n" if i > 0 
        build_row(row)
      end
      output << "\n"
    end