Returns or initializes the symfony/console Table

@return Table
355545
protected function getTable(): Table
    {
        if ($this->table === null) {
            $this->table = new Table($this->output);
        }
        return $this->table;
    }
336124
public function getTableName()
    {
        if (is_null($this->_tableName)) {
            $this->_tableName = $this->getDescriptor()->getEntity()
                ->getTableName();
        }
        return $this->_tableName;
    }
1219601
public function create()
    {
        $sm = $this->em->getConnection()->getSchemaManager();
        $table = $this->em->getClassMetadata(self::$entityName)->getTableName();

        return $sm->tablesExist(array($table));
    }
1364804
public function table($table = null)
    {
        if ($table !== null) {
            $this->table = $table;
        }

        return $this->table;
    }
998145
public function getTable()
    {
        // If the table is set manually, return it.
        if(isset($this->table))
        {
            return $this->table;
        }

        // Return only the class name in snake case.
        return snake_case(array_pop( explode('\\', get_class($this))));
    }
358289
public function getTable()
    {
        if (!($this->_table instanceof KDatabaseTableInterface))
        {
            //Make sure we have a table identifier
            if (!($this->_table instanceof KObjectIdentifier)) {
                $this->setTable($this->_table);
            }

            $this->_table = $this->getObject($this->_table);

            if (!($this->_table instanceof KDatabaseTableInterface))
            {
                throw new UnexpectedValueException(
                    'Table: ' . get_class($this->_table) . ' does not implement KDatabaseTableInterface'
                );
            }
        }

        return $this->_table;
    }
74595
public function getOldTable(): TableStructure
    {
        if ($this->_oldTable === null) {
            $this->_oldTable = new TableStructure([
                'schema' => get_class($this->db->schema),
                'generalSchema' => $this->generalSchema,
                'usePrefix' => $this->useTablePrefix,
                'dbPrefix' => $this->db->tablePrefix,
            ]);

            $this->_oldTable->applyChanges(array_reverse($this->_appliedChanges));
        }

        return $this->_oldTable;
    }
605329
public function getTable(): ?string
    {
        if (isset($this->statements['tables']) === true) {
            $table = array_values($this->statements['tables'])[0];
            if ($table instanceof Raw === false) {
                return $table;
            }
        }

        return null;
    }
1221834
public function getTableDumper()
    {
        if ($this->migrated) {
            return new TableDumper($this->getEntities());
        }

        if ($this->existing()) {
            return TableDumper::make($this->getEntities())
                ->except(['id', 'created_at', 'updated_at', 'deleted_at']);
        }

        return new FieldsDumper($fields);
    }
445198
public static function _init() 
	{	
		if ( \ClanCats::in_development() ) 
		{ 
			// add a hook to the main resposne
			\CCEvent::mind( 'response.output', function( $output ) {
				
				if ( strpos( $output, '</body>' ) === false ) 
				{
					return $output;
				}
				
				$table = \UI\Table::create( array(
					 'style'		=> array(
					 	'width'	=> '100%',
					 ),
					 'cellpadding' 	=> '5',
					 'class'			=> 'table debug-table debug-table-db',
				));
				
				$table->header( array( '#', 'query' ) );
				
				foreach( static::log() as $key => $item )
				{
					$table->row( array( 
						$key+1,
						$item
					));
				}
			
				return str_replace( '</body>', $table."\n</body>", $output );
			});
		}
	}
1156501
public function getTable()
    {
        if ($this->_table === null) {
            $this->setTable($this->getConfig('table'));
        }

        return $this->_table;
    }
293986
public function getTable() : string
    {
        if(!empty($this->_table)) {
            return $this->_table;
        }

        $class = explode("\\", str_replace(self::$_baseNamespace, "", "\\".get_called_class()));
        $table = Str::snake(Str::plural($class));

        $this->_table = $table;

        return $this->_table;
    }
152630
public function getTableSchema(): ?TableSchema
    {
        if ($this->_tableSchema === null) {
            $this->_tableSchema = $this->db->getTableSchema($this->tableName);
        }

        return $this->_tableSchema;
    }
295560
public function getTable()
    {
        if ($this->_table !== false)
        {
            if (!($this->_table instanceof KDatabaseTableInterface))
            {
                //Make sure we have a table identifier
                if (!($this->_table instanceof KObjectIdentifier)) {
                    $this->setTable($this->_table);
                }

                try {
                    $this->_table = $this->getObject($this->_table);
                } catch (RuntimeException $e) {
                    $this->_table = false;
                }
            }
        }

        return $this->_table;
    }
1071402
public function getTable() {

		if(null === $this -> table) {

			$path  = $this -> getNamespace($this, ['directory', 'entity'], ['directory', 'entity']) . Application :: get(['prefix', 'entity']);
			$path  = str_replace(DIRECTORY_SEPARATOR, '\\', $path);
			$class = new \ReflectionClass(get_class($this));
			
			$this -> table = NameConvert :: toSnakecase(str_replace($path, '', $class -> name));
		}

		return $this -> table;
	}
1254796
private function getTableCache()
	{
		return $this->getCache()->load($this->getTableName(), function (&$dependencies) {
			return parent::getAllItems($this->assocBy);
		});
	}
416051
public function getRoutingTable()
    {
        if ($this->enableCache && !empty($this->cacheInterface))
        {
            return $this->fetchRoutingTableFromCache();
        }

        return $this->fetchRoutingTable();
    }