Supplies properties for objects in table template specific to object configuration.

@return array This metod is a generator.
495454
public function objectRows()
    {
        // Get properties as defined in object's list metadata
        $properties  = $this->sortProperties();
        $propOptions = $this->propertiesOptions();

        // Collection objects
        $objects = $this->sortObjects();

        // Go through each object to generate an array of properties listed in object's list metadata
        foreach ($objects as $object) {
            if (isset($object['requiredAclPermissions']) && !empty($object['requiredAclPermissions'])) {
                if ($this->hasPermissions($object['requiredAclPermissions']) === false) {
                    continue;
                }
            }

            $objectProperties = [];
            foreach ($properties as $propertyIdent => $propertyData) {
                $property = $object->property($propertyIdent);

                if (isset($propOptions[$propertyIdent]) && is_array($propOptions[$propertyIdent])) {
                    $property->setData($propOptions[$propertyIdent]);
                }

                $this->setupDisplayPropertyValue($object, $property);

                $displayType = $this->display->displayType();
                $this->display->setPropertyVal($object->propertyValue($propertyIdent));

                $propertyValue = $this->view()->renderTemplate($displayType, $this->display);

                $cell = $this->parsePropertyCell($object, $property, $propertyValue);
                $objectProperties[] = $cell;
            };

            $this->currentObj = $object;
            $this->currentObjId = $object->id();

            $row = $this->parseObjectRow($object, $objectProperties);

            yield $row;
        }

        $this->currentObj = null;
        $this->currentObjId = null;
    }
581140
public function getTables()
    {
        if ($this->_tables == self::AUTO_DETECT_TABLES) {
            $tables = $this->_db->show('SHOW TABLES', AnDatabase::FETCH_FIELD_LIST);
            $prefix = $this->_db->getTablePrefix().$this->getIdentifier()->package.'_';
            $schemas = array();
            foreach ($tables as $table) {
                if (strpos($table, $prefix) === 0) {
                    $schemas[] = $table;
                }
            }
        } else {
            $schemas = $this->_tables;
            settype($schemas, 'array');
            $prefix = $this->_db->getTablePrefix();
            $schemas = array_map(function ($table) use ($prefix) {
                return $prefix.$table;
            }, $schemas);
        }

        return $schemas;
    }
1045208
private function getAttributeKeys(): \Generator
    {
        foreach ($this->handlers as $attributeHandler) {
            /** @var MetaModelAttributeHandlerInterface $attributeHandler */
            $prefix = $attributeHandler->getPrefix();
            foreach ($this->idListGenerator() as $id) {
                yield $id . '.' . $prefix;
            }
        }
    }
280715
protected function getAssignedValues()
    {
        $tableFields = $this->getTableFields();
        $newPropertiesArray = get_object_vars($this);

        $columns = $values = $tableData = [];

        foreach ($newPropertiesArray as $index => $value) {
            if (in_array($index, $tableFields)) {
                array_push($columns, $index);
                array_push( $values, $value);
            }
        }

        $tableData['columns'] = $columns;
        $tableData['values'] = $values; 

        return $tableData;
    }
291827
private function getGeneratorTablesFor(ClassMetadata $class)
    {
        $tables = [];

        foreach ($class->getGeneratedProperties() as $mapping) {
            if ($mapping->generator instanceof IncrementGenerator) {
                $table = $mapping->generator->getTable();

                if (!isset($tables[$table])) {
                    $tables[$table] = $mapping->generator->getTableDefinition();
                }
            }
        }

        return $tables;
    }
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];
	}
263590
protected function getGeneratedProperties(): array
    {
        $reflectionObject = new \ReflectionObject($this);
        $properties = $reflectionObject->getProperties(\ReflectionProperty::IS_PUBLIC);
        $result = [];
        foreach ($properties as $property) {
            if (!$property->isPublic() || @$property->isDefault()) {
                continue;
            }

            $result[] = $property;
        }

        return $result;
    }
1268368
public static function getTable()
    {
        $attribute = 'table';

        if (!static::hasClassAttribute($attribute)) {
            $name = !isset(static::$table)
                ? static::getClassName()
                : static::$table;

            $conventionName = Functions::applyConventions(
                static::getClassConfig('table-name-conventions'),
                $name
            );

            $tableName = static::getDatabase()->getPrefix($conventionName);

            static::setClassAttribute($attribute, $tableName);
        }

        return static::getClassAttribute($attribute);
    }
662521
public function getNestedSetBuilder()
    {
        if (!isset($this->nestedSetBuilder)) {
            $this->nestedSetBuilder = $this->getGeneratorConfig()->getConfiguredBuilder($this->getTable(), 'nestedset');
        }

        return $this->nestedSetBuilder;
    }
66840
public function formProperties()
    {
        $sidebars = $this->sidebars;
        if (!is_array($sidebars)) {
            yield null;
        } else {
            foreach ($this->formProperties as $formProperty) {
                if ($formProperty->active() === false) {
                    continue;
                }

                $GLOBALS['widget_template'] = $formProperty->inputType();

                yield $formProperty->propertyIdent() => $formProperty;

                $GLOBALS['widget_template'] = '';
            }
        }
    }
481259
protected function generateProperties($table)
    {
        $properties = [];
        foreach ($table->columns as $column) {
            $columnPhpType = $column->phpType;
            if ($columnPhpType === 'integer') {
                $type = 'int';
            } elseif ($columnPhpType === 'boolean') {
                $type = 'bool';
            } else {
                $type = $columnPhpType;
            }
            $properties[$column->name] = [
                'type' => $type,
                'name' => $column->name,
                'comment' => $column->comment,
            ];
        }

        return $properties;
    }
79493
public function getProperties()
    {
        $properties = new BeanPropertyCollection();

        // Properties already taken into account accross the hierarchy.
        $registeredProperties = array();
        $target = $this->getClass();

        while ($target) {

            foreach ($target->getProperties() as $prop) {

                $propName = $prop->getName();

                if ($this->isPropertyAnnotated($propName) === true && in_array($propName, $registeredProperties) === false) {
                    $properties[] = new BeanProperty($target->getName(), $propName);
                    $registeredProperties[] = $propName;
                }
            }

            $target = $target->getParentClass();
        }

        return $properties;
    }
168691
protected function buildAccessibleProperties()
    {
        $body = '';

        foreach ($this->accessibleProperties as $accessibleProperty) {
            $propertyName = $accessibleProperty->getName();
            $exportedPropertyName = var_export($propertyName, true);

            if (empty($this->propertyWriters) || ! $accessibleProperty->isProtected()) {
                $body .= $this->buildExtractProperty('%s => $object->%s,', [$exportedPropertyName, $propertyName]);
            } else {
                $body .= $this->buildExtractProperty('%s => $data["\\0*\\0%s"],', [$exportedPropertyName, $propertyName]);
            }
        }

        return $body;
    }
890847
protected function _table()
    {
        return $this->_controller()
            ->loadModel(
                null,
                $this->getConfig('modelFactory') ?: $this->_controller()->getModelType()
            );
    }
637728
public function getArrguments()
    {
        return [
            'model-name' => $this->modelName,
            '--table-name' => $this->tableName,
            '--connection-name' => $this->connectionName,
            '--engine-name' => $this->engineName,
            '--resource-file' => $this->resourceFile,
            '--template-name' => $this->template,
            '--without-timestamps' => $this->withoutTimestamps,
            '--with-soft-delete' => $this->withSoftDelete,
        ];
    }
93707
public function generateProperties ()
	{
		
		$attributes	= $this->getAttributes ();
		
		$properties	= 'Class Properties:' . "\n";
		
		foreach ($attributes as $name => $attribute)
		{
			
			$properties	.= '@property ';
			
			switch ($attribute['type'])
			{
				
				case 'self::TYPE_INT':
					$properties	.= 'integer'; break;
				
				case 'self::TYPE_STRING':
					$properties	.= 'string'; break;
				
				case 'self::TYPE_BOOL':
					$properties	.= 'boolean'; break;
				
				case 'self::TYPE_DATE':
					$properties	.= 'date'; break;
				
				case 'self::TYPE_DATETIME':
					$properties	.= 'datetime'; break;
				
				case 'self::TYPE_DECIMAL':
					$properties	.= 'float'; break;
				
				case 'self::TYPE_ENUM':
					$properties	.= 'enum'; break;
				
				case 'self::TYPE_BINARY':
					$properties	.= 'binary'; break;
				
			}
			
			$properties	.= ' $' . $name . "\n";
			
		}
		
		// Remove last ,

		if (substr ($properties, -1) == "\n")
		{
			$properties	= substr ($properties, 0, -1);
		}
		
		return $properties;
		
	}
31238
protected function getGeneratorConfig()
    {
        if ($this->generatorConfig === null) {
            $this->generatorConfig = new GeneratorConfig();
            $this->generatorConfig->setBuildProperties($this->getProject()->getProperties());
        }

        return $this->generatorConfig;
    }