Generate a table that contains the dependencies information with the column that match the configured filters

@return Table
480040
public Table getTable(){
        final Table table = new Table(getHeaders());

        // Create row(s) per dependency
        for(final Dependency dependency: dependencies){
            final List<String> licenseIds = dependency.getTarget().getLicenses();

            // A dependency can have many rows if it has many licenses
            if(licenseIds.isEmpty()){
                table.addRow(getDependencyCells(dependency, DataModelFactory.createLicense("","","","","")));
            }
            else{
                for(final String licenseId: dependency.getTarget().getLicenses()){
                    final License license = getLicense(licenseId);
                    table.addRow(getDependencyCells(dependency, license));
                }
            }
        }

        return table;
    }
192317
private function getColumns()
    {
        $table = $this->table->connect($this->database, Inflector::tabilize($this->tableName));

        return $table->getColumns();
    }
77311
protected function getSluggableConfigReplace()
    {
        $setup = $this->data->sluggable_setup;

        if ( ! $this->context->modelIsSluggable || ! $this->data->sluggable || empty($setup)) return '';


        $replace = $this->tab() . "protected \$sluggable = [\n";

        $rows = [];

        if (array_get($setup, 'source')) {
            $rows['build_from'] = "'" . $setup['source'] . "'";
        }

        if (array_get($setup, 'target')) {
            $rows['save_to'] = "'" . $setup['target'] . "'";
        }

        if (config('pxlcms.generator.models.slugs.resluggify_on_update')) {
            $rows['on_update'] = 'true';
        }

        // for now we don't support the locale key, all translated
        // tables will have a language_id column in the old CMS.
        if (array_get($setup, 'translated') === true) {
            $rows['language_key'] = "'" . config('pxlcms.slugs.keys.language', 'language_id') . "'";
            $rows['locale_key']   = 'null';
        }

        $longestPropertyLength = $this->getLongestKey($rows);

        foreach ($rows as $property => $value) {

            $replace .= $this->tab(2) . "'"
                . str_pad($property . "'", $longestPropertyLength + 1)
                . " => {$value},\n";
        }

        $replace .= $this->tab() . "];\n\n";

        return $replace;
    }
828413
protected function getInsertColumnList()
    {
        $columns             = [];
        $versionPropertyName = $this->class->isVersioned()
            ? $this->class->versionProperty->getName()
            : null;

        foreach ($this->class->getDeclaredPropertiesIterator() as $name => $property) {
            /*if (isset($this->class->embeddedClasses[$name])) {
                continue;
            }*/

            switch (true) {
                case $property instanceof VersionFieldMetadata:
                    // Do nothing
                    break;

                case $property instanceof LocalColumnMetadata:
                    if (($property instanceof FieldMetadata
                            && (
                                ! $property->hasValueGenerator()
                                || $property->getValueGenerator()->getType() !== GeneratorType::IDENTITY
                            )
                        )
                        || $this->class->identifier[0] !== $name
                    ) {
                        $columnName = $property->getColumnName();

                        $columns[] = $columnName;

                        $this->columns[$columnName] = $property;
                    }

                    break;

                case $property instanceof AssociationMetadata:
                    if ($property->isOwningSide() && $property instanceof ToOneAssociationMetadata) {
                        $targetClass = $this->em->getClassMetadata($property->getTargetEntity());

                        foreach ($property->getJoinColumns() as $joinColumn) {
                            /** @var JoinColumnMetadata $joinColumn */
                            $columnName           = $joinColumn->getColumnName();
                            $referencedColumnName = $joinColumn->getReferencedColumnName();

                            if (! $joinColumn->getType()) {
                                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $targetClass, $this->em));
                            }

                            $columns[] = $columnName;

                            $this->columns[$columnName] = $joinColumn;
                        }
                    }

                    break;
            }
        }

        return $columns;
    }
301695
protected function getJunctionTable()
	{
		if($this->junctionTable === null)
		{
			$tables = [$this->parent->getTable(), $this->model->getTable()];

			sort($tables);

			$this->junctionTable = implode('_', $tables);
		}

		return $this->junctionTable;
	}
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;
    }
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;
	}
1346670
protected function initColumns()
    {
        $returnValue = (bool) false;

		$excludedProperties = (is_array($this->options) && isset($this->options['excludedProperties']))?$this->options['excludedProperties']:array();
		$columnNames = (is_array($this->options) && isset($this->options['columnNames']))?$this->options['columnNames']:array();
		
		
		$processProperties = array(
            OntologyRdfs::RDFS_LABEL					=> __('Label'),
            ResultService::DELIVERY_CLASS_URI	=> __('Delivery'),
            ResultService::SUBJECT_CLASS_URI	=> __('Test taker'),
			OntologyRdf::RDF_TYPE                	=> __('Class')
		);
		
		foreach($processProperties as $processPropertyUri => $label){
			if(!isset($excludedProperties[$processPropertyUri])){
				$column = $this->grid->addColumn($processPropertyUri, $label);
               
			}
		}

		$this->grid->setColumnsAdapter(
			array_keys($processProperties),
			new tao_helpers_grid_Cell_ResourceLabelAdapter()
		);

        return (bool) $returnValue;
    }
855503
public function getDependencyConfig(): array
    {
        return [
            'aliases' => [
                'TableManager' => Db\TableManager::class
            ],
            'factories' => [
                GulpRev::class                => Factory\GulpRevFactory::class,
                TransportInterface::class     => Mail\Transport\TransportServiceFactory::class,
                Db\TableManager::class        => Db\TableManagerFactory::class,
                \Rollbar\RollbarLogger::class => Rollbar\LoggerFactory::class,
            ]
        ];
    }
1320696
public function getDependsInfo()
    {
        $dependsInfo = $this->getCachedValue('dependsInfo');
        if ($dependsInfo === false) {

            $data = $this->dataProvider->getData();

            $dependsInfo = array();

            foreach ($this->getPackageSortOrder() as $packageId => $order) {
                if (!isset($data[$packageId])) {
                    continue;
                }

                $provides = $this->getProvidesForPackage($packageId);
                foreach ($provides as $file => $fileInfo) {
                    if (!isset($dependsInfo[$file])) {
                        $dependsInfo[$file] = array();
                    }
                    if (isset($fileInfo['Depends'])) {
                        $dependsInfo[$file] = array_merge(
                            $dependsInfo[$file],
                            $fileInfo['Depends']
                        );
                    }
                    // TODO: some day we could treat optional-depends
                    // differently
                    if (isset($fileInfo['OptionalDepends'])) {
                        $dependsInfo[$file] = array_merge(
                            $dependsInfo[$file],
                            $fileInfo['OptionalDepends']
                        );
                    }
                }
            }

            $this->setCachedValue('dependsInfo', $dependsInfo);
        }

        return $dependsInfo;
    }
266504
public function getColumns()
    {
        $table = $this->table()->connect($this->database, Inflector::tabilize($this->model));

        return $table->{__FUNCTION__}();
    }
161195
public function searchableColumnIndex()
    {
        $searchable = [];
        for ($i = 0, $c = count($this->get('columns')); $i < $c; $i++) {
            if ($this->isColumnSearchable($i, false)) {
                $searchable[] = $i;
            }
        }

        return $searchable;
    }
1192872
public String prettyDependencies() {
        StringBuilder b = new StringBuilder();
        b.append(id()).append('\n');
        for (Iterator<Script> ite = dependencies.iterator(); ite.hasNext(); ) {
            Script n = ite.next();
            prettyDependencies(b, !ite.hasNext(), 0, n);
        }
        return b.toString();
    }
187704
public function table()
    {
        if (!$this->_properties['table_name']) {
            $class = explode('\\', get_called_class());
            $this->_properties['table_name'] = Instance::snakecase(lcfirst(end($class)));
        }

        return $this->_properties['table_name'];
    }
175062
public function getTable(){
		$table = str_replace(':', '', $this->source);
		$prefix = $this->connection->getPrefix();
		return $prefix . $table;
	}
673044
public function getColumns()
    {
        $query = Schema::make(trim($this->tableName), function ($table) {
            $table->on($this->database);
            $this->setSchemaInstance($table);

            return $table->setTableSchema()->getSchemaPreparedQuery();
        });

        return $this->query($query)->getAll();
    }
497291
public static function table()
	{
		$class = get_called_class();

		// Table name unknown
		if ( ! array_key_exists($class, static::$_table_names_cached))
		{
			// Table name set in Model
			if (property_exists($class, '_table_name'))
			{
				static::$_table_names_cached[$class] = static::$_table_name;
			}
			else
			{
				static::$_table_names_cached[$class] = \Inflector::tableize($class);
			}
		}

		return static::$_table_names_cached[$class];
	}