Start the first inner table of a class.
548006
private void firstInnerTableStart(Options opt) {
	w.print(linePrefix + linePrefix + "<tr>" + opt.shape.extraColumn() +
		"<td><table border=\"0\" cellspacing=\"0\" " +
		"cellpadding=\"1\">" + linePostfix);
    }
910983
protected void writeTableInit(Table t) throws IOException {

        tableRowCount = 0;

        rowOut.reset();
        rowOut.writeSize(0);
        rowOut.writeString(t.getName().name);
        rowOut.writeInt(INSERT_WITH_SCHEMA);
        rowOut.writeString(t.getSchemaName().name);
        rowOut.writeIntData(rowOut.size(), 0);
        fileStreamOut.write(rowOut.getOutputStream().getBuffer(), 0,
                            rowOut.size());
    }
785608
def move_to_start(self, column_label):
        """"""
        self._columns.move_to_end(column_label, last=False)
        return self
917962
def begin_table(self, column_count):
        """"""
        self.table_columns = column_count
        self.table_columns_left = 0
        self.write('<table>')
838395
function startClassInit(noDelay) {

			var script = scriptArr.pop(), data;

			var temp = getBaseDir(script.packageName);

			if (typeof loadedScript[temp  + script.Class] == 'object') {
				data = loadedScript[temp  + script.Class];
			}
			loadedScript[temp  + script.Class] = true;
			var temp;
			if(noDelay) {
				compiling_classes = compiling_classes || [];
				compiling_classes.push({script:script, data:data});
			}
			while(temp = compiling_classes.shift()){
				(function(temp){
					fileLoadeManager.onAllFileLoad(temp.script.includes, function(){
						classManager.init(temp.script, temp.data);
					});
				})(temp)
			}
			if(noDelay) {
				return;
			}
			compiling_classes = [];
			compiling_classes.push({script:script, data:data});
			setTimeout(function( ) {
				// Calling classManager after a short delay so that file get
				// completely ready.
				var temp;
				while(temp = compiling_classes.shift()){
					(function(temp){
						fileLoadeManager.onAllFileLoad(temp.script.includes, function(){
							classManager.init(temp.script, temp.data);
						});
					})(temp)
				}
				// fm.holdReady(false);
			}, 0);

		}
1014277
public function startBar($originalTable, $newTable, $collection, $new = false)
    {
        static $even = false;

        $this->bar = $this->output->createProgressBar(count($collection));

        // Set up the label.
        $this->setUpLabel($originalTable, $newTable, $new, $even);

        $even = ! $even;
    }
989795
def get_first(self, table=None):
        """"""
        if table is None: table = self.main_table
        query = 'SELECT * FROM "%s" LIMIT 1;' % table
        return self.own_cursor.execute(query).fetchone()
282458
protected function initTable(): void
    {
        $tableClass = class_namespace(static::class) . '\\Table';

        // check class initialization
        if (!class_exists($tableClass) || !is_subclass_of($tableClass, TableInterface::class)) {
            throw new TableNotFoundException('`Table` class is not exists or not initialized');
        }

        /**
         * @var TableInterface $tableClass
         */
        $this->setTable($tableClass::getInstance());
    }
371756
def init(cls, name):
        """"""
        clsdict = {subcls.name: subcls for subcls in cls.__subclasses__()
                   if hasattr(subcls, 'name')}
        return clsdict.get(name, cls)(name)
726361
def initiate(self, database=None, journaler=None, *backends):
        '''
        
        '''
        return self._initiate(database=database, journaler=journaler,
                              backends=backends)
656711
public void openTable(TableTag.State state, AbstractRenderAppender appender) {
        if(state == null)
            state = TABLE_STATE;

        appender.append(LINE_BREAK);
        _tableRenderer.doStartTag(appender, state);
        appender.append(LINE_BREAK);
    }
694902
private synchronized void startCache()
    {
        for (PDatabase pDatabase : m_htDBList.values())
        {
            for (PTable pTable : pDatabase.getTableList().values())
            {
                this.addTableToCache(pTable);
            }
        }
    }
755680
public void start() {
                // Log.d("EglHelper" + instanceId, "start()");
                if (mEgl == null) {
                        // Log.d("EglHelper" + instanceId, "getting new EGL");
                        /*
                         * Get an EGL instance
                         */
                        mEgl = (EGL10) EGLContext.getEGL();
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing EGL");
                }

                if (mEglDisplay == null) {
                        // Log.d("EglHelper" + instanceId, "getting new display");
                        /*
                         * Get to the default display.
                         */
                        mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing display");
                }

                if (mEglConfig == null) {
                        // Log.d("EglHelper" + instanceId, "getting new config");
                        /*
                         * We can now initialize EGL for that display
                         */
                        int[] version = new int[2];
                        mEgl.eglInitialize(mEglDisplay, version);
                        mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing config");
                }

                if (mEglContext == null) {
                        // Log.d("EglHelper" + instanceId, "creating new context");
                        /*
                         * Create an OpenGL ES context. This must be done only once, an OpenGL context is a somewhat heavy object.
                         */
                        mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
                        if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
                                throw new RuntimeException("createContext failed");
                        }
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing context");
                }

                mEglSurface = null;
        }
1254466
def ensure_table(self, cls):
        """"""
        cur = self._conn().cursor()

        table_name = cls.get_table_name()
        index_names = cls.index_names() or []

        cols = ['id text primary key', 'value text']
        for name in index_names:
            cols.append(name + ' text')

        cur.execute('create table if not exists %s (%s)' % (
            table_name,
            ','.join(cols)
        ))

        for name in index_names:
            cur.execute('create index if not exists %s on %s(%s)' % (
                table_name + '_' + name + '_idx',
                table_name,
                name
            ))

        self._conn().commit()
        cur.close()
1278682
def init(context, reset, force):
    """"""
    store = Store(context.obj['database'], context.obj['root'])
    existing_tables = store.engine.table_names()
    if force or reset:
        if existing_tables and not force:
            message = f"Delete existing tables? [{', '.join(existing_tables)}]"
            click.confirm(click.style(message, fg='yellow'), abort=True)
        store.drop_all()
    elif existing_tables:
        click.echo(click.style("Database already exists, use '--reset'", fg='red'))
        context.abort()

    store.create_all()
    message = f"Success! New tables: {', '.join(store.engine.table_names())}"
    click.echo(click.style(message, fg='green'))
541759
def earliest_class
      earliest = self.first
      self.each { |c| earliest = c if c.time < earliest.time }
      earliest
    end
98849
@Synchronized
  final void start(Optional<String> name) {
    if (!this.isStarted) {
      this.startImpl(name);
      this.isStarted = true;
    }
  }