Returns the table heading. If the table is not declared, attempts to declare it and return heading.
        :return: table heading
769376
def heading(self):
        
        if self._heading is None:
            self._heading = Heading()  # instance-level heading
        if not self._heading:  # lazy loading of heading
            if self.connection is None:
                raise DataJointError(
                    'DataJoint class is missing a database connection. '
                    'Missing schema decorator on the class? (e.g. @schema)')
            else:
                self._heading.init_from_database(self.connection, self.database, self.table_name)
        return self._heading
1279116
def to_dict(self):
        
        obj_dict = super(Table, self).to_dict()
        rows_dict = [r.to_dict() for r in self.rows]
        child_dict = {
            'type': self.__class__.__name__,
            'caption': self.caption,
            'rows': rows_dict
        }
        obj_dict.update(child_dict)
        return obj_dict
850483
def structure(table_toplevels):
    

    table_toplevels = tuple(table_toplevels)
    obj = NamedDict()

    last_array_of_tables = None         # The Name of the last array-of-tables header

    for toplevel in table_toplevels:

        if isinstance(toplevel, toplevels.AnonymousTable):
            obj[''] = toplevel.table_element

        elif isinstance(toplevel, toplevels.Table):
            if last_array_of_tables and toplevel.name.is_prefixed_with(last_array_of_tables):
                seq = obj[last_array_of_tables]
                unprefixed_name = toplevel.name.without_prefix(last_array_of_tables)

                seq[-1] = CascadeDict(seq[-1], NamedDict({unprefixed_name: toplevel.table_element}))
            else:
                obj[toplevel.name] = toplevel.table_element
        else:    # It's an ArrayOfTables

            if last_array_of_tables and toplevel.name != last_array_of_tables and \
                    toplevel.name.is_prefixed_with(last_array_of_tables):

                seq = obj[last_array_of_tables]
                unprefixed_name = toplevel.name.without_prefix(last_array_of_tables)

                if unprefixed_name in seq[-1]:
                    seq[-1][unprefixed_name].append(toplevel.table_element)
                else:
                    cascaded_with = NamedDict({unprefixed_name: [toplevel.table_element]})
                    seq[-1] = CascadeDict(seq[-1], cascaded_with)

            else:
                obj.append(toplevel.name, toplevel.table_element)
                last_array_of_tables = toplevel.name

    return obj
251926
def _tables(self):
        
        return dict(
            (tag, _TableFactory(tag, self._stream, off, len_))
            for tag, off, len_ in self._iter_table_records()
        )
878841
def _get_mapping_for_table(self, table):
        
        for mapping in self.mappings.values():
            if mapping["table"] == table:
                return mapping
676551
public function get_table() {
        $table = new html_table();
        $table->tablealign = 'center';
        $table->cellpadding = 5;
        $table->cellspacing = 0;
        $table->width = '90%';
        $table->align = array('left');
        $table->rotateheaders = true;
        $table->head = array('&#xa0;');
        $table->colclasses = array('');

        // Add role name headers.
        foreach ($this->roles as $targetrole) {
            $table->head[] = $targetrole->localname;
            $table->align[] = 'left';
            if ($this->is_allowed_target($targetrole->id)) {
                $table->colclasses[] = '';
            } else {
                $table->colclasses[] = 'dimmed_text';
            }
        }

        // Now the rest of the table.
        foreach ($this->roles as $fromrole) {
            $row = array($fromrole->localname);
            foreach ($this->roles as $targetrole) {
                $checked = '';
                $disabled = '';
                if ($this->allowed[$fromrole->id][$targetrole->id]) {
                    $checked = 'checked="checked" ';
                }
                if (!$this->is_allowed_target($targetrole->id)) {
                    $disabled = 'disabled="disabled" ';
                }
                $name = 's_' . $fromrole->id . '_' . $targetrole->id;
                $tooltip = $this->get_cell_tooltip($fromrole, $targetrole);
                $row[] = '<input type="checkbox" name="' . $name . '" id="' . $name .
                    '" title="' . $tooltip . '" value="1" ' . $checked . $disabled . '/>' .
                    '<label for="' . $name . '" class="accesshide">' . $tooltip . '</label>';
            }
            $table->data[] = $row;
        }

        return $table;
    }
880942
def _get_pretty_table(self, fields):
        """"""
        pt = prettytable.PrettyTable(fields)
        pt.align = 'l'
        pt.border = False
        pt.header_style = "upper"
        return pt
150777
def help_heading(self):
        
        message = m.Heading(
            tr('Help for {step_name}').format(step_name=self.step_name),
            **SUBSECTION_STYLE)
        return message
55185
def getHeaders(self):
        
        headers = self._impl.getHeaders()
        return tuple(
            headers.getIndex(i) for i in range(self._impl.getNumCols())
        )
355545
protected function getTable(): Table
    {
        if ($this->table === null) {
            $this->table = new Table($this->output);
        }
        return $this->table;
    }
347245
def header(self):
        
        if self._block_header is None:
            self._block_header = BlockHeader()
            self._block_header.ParseFromString(self.block.header)
        return self._block_header
438381
def get_table():
    """"""
    response = dict(blocks=[])
    block_ids = DB.get_sched_block_instance_ids()
    for index, block_id in enumerate(block_ids):
        block = DB.get_block_details([block_id]).__next__()
        info = [
            index,
            block['id'],
            block['sub_array_id'],
            len(block['processing_blocks'])
        ]
        response['blocks'].append(info)
    return response, HTTPStatus.OK
72464
def get_table(self, name):
        
        if name is None:
            assert self.active_table, "Can't get table without name unless an active table is set"
            name = self.active_table.name

            if self.active_worksheet:
                table = self.active_worksheet.get_table(name)
                assert table is self.active_table, "Active table is not from the active sheet"
                return table, self.active_worksheet

            for ws in self.worksheets:
                try:
                    table = ws.get_table(name)
                    if table is self.active_table:
                        return table, ws
                except KeyError:
                    pass

            raise RuntimeError("Active table not found in any sheet")

        # if the tablename explicitly uses the sheetname find the right sheet
        if "!" in name:
            ws_name, table_name = map(lambda x: x.strip("'"), name.split("!", 1))
            for ws in self.worksheets:
                if ws.name == ws_name:
                    table = ws.get_table(table_name)
                    return table, ws
            raise KeyError(name)

        # otherwise look in the current table
        if self.active_worksheet:
            table = self.active_worksheet.get_table(name)
            return table, self.active_worksheet

        # or fallback to the first matching name in any table
        for ws in self.worksheets:
            try:
                table = ws.get_table(name)
                return table, ws
            except KeyError:
                pass

        raise KeyError(name)
650466
def get(self, table_name):
        """"""
        assert table_name in self.tabs, \
            "Table not avaiable. Avaiable tables: {}".format(
                ", ".join(self.tabs.keys())
            )
        return self.tabs[table_name]
1362155
def get_table(self, tablename):
        
        table, (_row, _col) = self.__tables[tablename]
        return table
372022
def table table_name
    table = JDBCHelper::TableWrapper.new(self, table_name)
    table = table.fetch_size(@fetch_size) if @fetch_size
    @table_wrappers[table_name] ||= table
  end
590914
def _get_table(self):
        
        data = get_inner_data(self.report)
        labels = data.keys()
        row = [
            data[key]
            for key in labels
        ]
        return list(labels), [row]