Using the table structure, return the array of entries based
		on the table size.
763770
def entries(self):
		
		table = self.get_table()
		entries_array = self.row_structure * table.num_entries
		pointer_type = ctypes.POINTER(entries_array)
		return ctypes.cast(table.entries, pointer_type).contents
1107041
private void loadTableEntries() {

        setVisibleColumns(PROP_RESOURCENAME, PROP_PROJECT, PROP_KEY, PROP_VARIATIONS);

        Iterator<String> itResources = new ArrayList<String>(
            m_cache.getCachedResources(A_CmsUI.getCmsObject())).iterator();
        while (itResources.hasNext()) {
            String resource = itResources.next();
            String resName = resource;
            String project = "";
            String key = "";
            if (resource.endsWith(CmsFlexCache.CACHE_OFFLINESUFFIX)) {
                resName = resource.substring(0, resource.length() - CmsFlexCache.CACHE_OFFLINESUFFIX.length());
                project = "Offline";
            }
            if (resource.endsWith(CmsFlexCache.CACHE_ONLINESUFFIX)) {
                resName = resource.substring(0, resource.length() - CmsFlexCache.CACHE_ONLINESUFFIX.length());
                project = "Online";
            }
            key = m_cache.getCachedKey(resource, A_CmsUI.getCmsObject()).toString();

            Item item = m_container.addItem(resource);
            item.getItemProperty(PROP_RESOURCENAME).setValue(resName);
            item.getItemProperty(PROP_PROJECT).setValue(project);
            item.getItemProperty(PROP_KEY).setValue(key);
            item.getItemProperty(PROP_VARIATIONS).setValue(
                new Integer(m_cache.getCachedVariations(resource, A_CmsUI.getCmsObject()).size()));
        }
    }
1048945
def index(self, sort=True):
        """"""
        from casacore.tables import tableindex
        return tableindex(self._table, [self._column], sort)
629966
def get_term_size():
        ''''''
        rows, columns = os.popen('stty size', 'r').read().split()
        return int(rows), int(columns)
674906
public List<String> getRowContents(Row row, int size) {
        logger.entering(new Object[] { row, size });
        List<String> rowData = new ArrayList<String>();
        if (row != null) {
            for (int i = 1; i <= size; i++) {
                String data = null;
                if (row.getCell(i) != null) {
                    data = row.getCell(i).toString();
                }
                rowData.add(data);
            }
        }
        logger.exiting(rowData);
        return rowData;
    }
295235
private int[] getColumnList(OrderedHashSet set, Table table) {
        if (set == null) {
            return null;
        }
        return table.getColumnIndexes(set);
    }
71944
function entries() {
  var result = []

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

  return result
}
1044438
private void resize() {
        final Entry[] old = table;
        table = new Entry[old.length * 2];

        for (int i = 0; i < old.length; i++) {
            Entry next = old[i];
            while (next != null) {
                final Entry entry = next;
                next = next.next;
                final int index = indexFor(entry.hash);
                entry.next = table[index];
                table[index] = entry;
            }
            old[i] = null;
        }
        threshold = (int) (table.length * loadFactor);
    }
155574
private function getTableStructure()
    {
        return array(
            'columns' => array(
                // Unique auto-incrementing primary key
                new BigInteger('id', false, null, array('auto_increment' => true, 'unsigned' => true)),

                // Identifier column
                new Varchar($this->getIdentifierColumn(), 64),

                // The blob column creates a length specification if(length), so length 0 is a nice hack to not specify length
                new Blob($this->getDataColumn(), 0)
            ),
            'constraints' => array(
                // Primary key and index constraints
                new PrimaryKey('id'),
                new UniqueKey(array($this->getIdentifierColumn()), $this->getIdentifierColumn())
            ),
        );
    }
685706
def _GetTable(self):
    
    result = []
    # Avoid the global lookup cost on each iteration.
    lstr = str
    for row in self._table:
      result.append(
          '%s\n' %
          self.separator.join(lstr(v) for v in row))

    return ''.join(result)
1177150
def size_on_disk(self):
        
        return int(self.connection.query(
            """
            SELECT SUM(data_length + index_length)
            FROM information_schema.tables WHERE table_schema='{db}'
            """.format(db=self.database)).fetchone()[0])
870970
def get_minimum_size(self, data):
        """"""

        # Gat a list of elements with their sizes, so we don't have to
        # recalculate that each time.
        sized_elements = [
            (col, row, cols, rows, element, element.get_minimum_size(data))
            for col, row, cols, rows, element in self.elements
            ]

        # Create the heights and widths for each cell.
        self.col_widths = [0] * self.cols
        self.row_heights = [0] * self.rows
        self._compile_dimension_size(0, self.col_widths, 'x', sized_elements)
        self._compile_dimension_size(1, self.row_heights, 'y', sized_elements)

        # The final size is the total width and height
        om = 2*self.outside_margin
        return datatypes.Point(
            sum(self.col_widths) + (self.cols-1)*self.margin + om,
            sum(self.row_heights) + (self.rows-1)*self.margin + om
            )
1174234
def size(self):
        
        if self._instrs is []:
            return None

        return sum([instr.size for instr in self._instrs])
126650
def get_entry(self, key, column=None, table=None):
        """"""
        if table is None:  table  = self.main_table
        if column is None: column = "id"
        if isinstance(key, basestring): key = key.replace("'","''")
        query = 'SELECT * from "%s" where "%s"=="%s" LIMIT 1;'
        query = query % (table, column, key)
        self.own_cursor.execute(query)
        return self.own_cursor.fetchone()
832354
def _get_rows_height(self):
        """"""

        tab = self.grid.current_table
        no_rows = self.grid.code_array.shape[0]
        default_row_height = self.grid.code_array.cell_attributes.\
            default_cell_attributes["row-height"]

        non_standard_row_heights = []
        __row_heights = self.grid.code_array.row_heights
        for __row, __tab in __row_heights:
            if __tab == tab:
                non_standard_row_heights.append(__row_heights[(__row, __tab)])

        rows_height = sum(non_standard_row_heights)
        rows_height += \
            (no_rows - len(non_standard_row_heights)) * default_row_height

        return rows_height
270457
def _calc_min_width(self, table):
        
        width = len(table.name)
        cap = table.consumed_capacity["__table__"]
        width = max(width, 4 + len("%.1f/%d" % (cap["read"], table.read_throughput)))
        width = max(width, 4 + len("%.1f/%d" % (cap["write"], table.write_throughput)))
        for index_name, cap in iteritems(table.consumed_capacity):
            if index_name == "__table__":
                continue
            index = table.global_indexes[index_name]
            width = max(
                width,
                4 + len(index_name + "%.1f/%d" % (cap["read"], index.read_throughput)),
            )
            width = max(
                width,
                4
                + len(index_name + "%.1f/%d" % (cap["write"], index.write_throughput)),
            )
        return width
34653
private ArrayList<Segment10> tableSegments(TableEntry10 table)
  {
    ArrayList<Segment10> tableSegments = new ArrayList<>();
    
    for (Segment10 segment : _segments) {
      if (Arrays.equals(segment.key(), table.key())) {
        tableSegments.add(segment);
      }
    }
    
    Collections.sort(tableSegments,
                     (x,y)->Long.signum(y.sequence() - x.sequence()));
    
    return tableSegments;
  }