propelorm/Propel2

View on GitHub
src/Propel/Generator/Model/Column.php

Summary

Maintainability
F
4 days
Test Coverage
<?php

/**
 * MIT License. This file is part of the Propel package.
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Propel\Generator\Model;

use Exception;
use Propel\Generator\Exception\EngineException;
use Propel\Generator\Platform\PlatformInterface;

/**
 * A class for holding data about a column used in an application.
 *
 * @author Hans Lellelid <hans@xmpl.org> (Propel)
 * @author Leon Messerschmidt <leon@opticode.co.za> (Torque)
 * @author Jason van Zyl <jvanzyl@apache.org> (Torque)
 * @author Jon S. Stevens <jon@latchkey.com> (Torque)
 * @author Daniel Rall <dlr@finemaltcoding.com> (Torque)
 * @author Byron Foster <byron_foster@yahoo.com> (Torque)
 * @author Bernd Goldschmidt <bgoldschmidt@rapidsoft.de>
 * @author Hugo Hamon <webmaster@apprendre-php.com> (Propel)
 */
class Column extends MappingModel
{
    /**
     * @var string
     */
    public const DEFAULT_TYPE = 'VARCHAR';

    /**
     * @var string
     */
    public const DEFAULT_VISIBILITY = 'public';

    /**
     * @var string
     */
    public const CONSTANT_PREFIX = 'COL_';

    /**
     * @var array<string>
     */
    public static $validVisibilities = [
        'public',
        'protected',
        'private',
    ];

    /**
     * @var string
     */
    private $name;

    /**
     * @var string|null
     */
    private $description;

    /**
     * @var string|null
     */
    private $phpName;

    /**
     * @var string|null
     */
    private $phpSingularName;

    /**
     * @var string|null
     */
    private $phpNamingMethod;

    /**
     * @var bool
     */
    private $isNotNull = false;

    /**
     * @var string|null
     */
    private $namePrefix;

    /**
     * @var string|null
     */
    private $accessorVisibility;

    /**
     * @var string|null
     */
    private $mutatorVisibility;

    /**
     * @var string|null
     */
    private $typeHint;

    /**
     * The name to use for the tableMap constant that identifies this column.
     * (Will be converted to all-uppercase in the templates.)
     *
     * @var string
     */
    private $tableMapName;

    /**
     * Native PHP type (scalar or class name)
     *
     * @var string "string", "boolean", "int", "double"
     */
    private $phpType;

    /**
     * @var \Propel\Generator\Model\Domain|null
     */
    private $domain;

    /**
     * @var \Propel\Generator\Model\Table
     */
    private $parentTable;

    /**
     * @var int|null
     */
    private $position;

    /**
     * @var bool
     */
    private $isPrimaryKey = false;

    /**
     * @var bool
     */
    private $isNodeKey = false;

    /**
     * @var string
     */
    private $nodeKeySep;

    /**
     * @var bool
     */
    private $isNestedSetLeftKey = false;

    /**
     * @var bool
     */
    private $isNestedSetRightKey = false;

    /**
     * @var bool
     */
    private $isTreeScopeKey = false;

    /**
     * @var bool
     */
    private $isUnique = false;

    /**
     * @var bool
     */
    private $isAutoIncrement = false;

    /**
     * @var bool
     */
    private $isLazyLoad = false;

    /**
     * @var array
     */
    private $referrers = [];

    /**
     * @var bool
     */
    private $isPrimaryString = false;

    // only one type is supported currently, which assumes the
    // column either contains the classnames or a key to
    // classnames specified in the schema.    Others may be
    // supported later.

    /**
     * @var string|null
     */
    private $inheritanceType;

    /**
     * @var bool
     */
    private $isInheritance = false;

    /**
     * @var bool
     */
    private $isEnumeratedClasses = false;

    /**
     * @var array|null
     */
    private $inheritanceList;

    /**
     * maybe this can be retrieved from vendor specific information
     *
     * @var bool
     */
    private $needsTransactionInPostgres = false;

    /**
     * @var array<string>
     */
    protected $valueSet = [];

    /**
     * Creates a new column and set the name.
     *
     * @param string $name The column's name
     * @param string|null $type The column's type
     * @param string|int|null $size The column's size
     */
    public function __construct(string $name, ?string $type = null, $size = null)
    {
        $this->setName($name);

        if ($type !== null) {
            $this->setType($type);
        }

        if ($size !== null) {
            $this->setSize((int)$size);
        }
    }

    /**
     * @return string|null
     */
    public function getTypeHint(): ?string
    {
        return $this->typeHint;
    }

    /**
     * @param string|null $typeHint
     *
     * @return void
     */
    public function setTypeHint(?string $typeHint): void
    {
        $this->typeHint = $typeHint;
    }

    /**
     * @throws \Propel\Generator\Exception\EngineException
     *
     * @return void
     */
    protected function setupObject(): void
    {
        try {
            $database = $this->getDatabase();
            $domain = $this->getDomain();

            $platform = null;
            if ($this->hasPlatform()) {
                $platform = $this->getPlatform();
            }

            $dom = $this->getAttribute('domain');
            if ($dom) {
                $domain->copy($database->getDomain($dom));
            } else {
                if ($this->getAttribute('type')) {
                    $type = strtoupper($this->getAttribute('type'));
                    if ($platform) {
                        $domain->copy($platform->getDomainForType($type));
                    } else {
                        // no platform - probably during tests
                        $this->setDomain(new Domain($type));
                    }
                } else {
                    if ($platform) {
                        $domain->copy($platform->getDomainForType(self::DEFAULT_TYPE));
                    } else {
                        // no platform - probably during tests
                        $this->setDomain(new Domain(self::DEFAULT_TYPE));
                    }
                }
            }

            $this->name = $this->getAttribute('name');
            $this->phpName = $this->getAttribute('phpName');
            $this->phpSingularName = $this->getAttribute('phpSingularName');
            $this->phpType = $this->getAttribute('phpType');
            $this->typeHint = $this->getAttribute('typeHint');
            $this->tableMapName = $this->getAttribute('tableMapName');
            $this->description = $this->getAttribute('description');

            /*
                Retrieves the method for converting from specified name
                to a PHP name, defaulting to parent tables default method.
            */
            $this->phpNamingMethod = $this->getAttribute('phpNamingMethod', $database->getDefaultPhpNamingMethod());

            $this->namePrefix = $this->getAttribute(
                'prefix',
                $this->parentTable->getAttribute('columnPrefix'),
            );

            // Accessor visibility - no idea why this returns null, or the use case for that
            $visibility = $this->getMethodVisibility('accessorVisibility', 'defaultAccessorVisibility') ?: '';
            $this->setAccessorVisibility($visibility);

            // Mutator visibility
            $visibility = $this->getMethodVisibility('mutatorVisibility', 'defaultMutatorVisibility') ?: '';
            $this->setMutatorVisibility($visibility);

            $this->isPrimaryString = $this->booleanValue($this->getAttribute('primaryString'));

            $this->isPrimaryKey = $this->booleanValue($this->getAttribute('primaryKey'));

            $this->isNodeKey = $this->booleanValue($this->getAttribute('nodeKey'));
            $this->nodeKeySep = $this->getAttribute('nodeKeySep', '.');

            $this->isNestedSetLeftKey = $this->booleanValue($this->getAttribute('nestedSetLeftKey'));
            $this->isNestedSetRightKey = $this->booleanValue($this->getAttribute('nestedSetRightKey'));
            $this->isTreeScopeKey = $this->booleanValue($this->getAttribute('treeScopeKey'));

            $this->isNotNull = ($this->booleanValue($this->getAttribute('required')) || $this->isPrimaryKey); // primary keys are required

            // AutoIncrement/Sequences
            $this->isAutoIncrement = $this->booleanValue($this->getAttribute('autoIncrement'));
            $this->isLazyLoad = $this->booleanValue($this->getAttribute('lazyLoad'));

            // Add type, size information to associated Domain object
            $domain->replaceSqlType($this->getAttribute('sqlType'));

            if (
                !$this->getAttribute('size')
                && $domain->getType() === 'VARCHAR'
                && !$this->getAttribute('sqlType')
                && $platform
                && !$platform->supportsVarcharWithoutSize()
            ) {
                $size = 255;
            } else {
                $size = $this->getAttribute('size') ? (int)$this->getAttribute('size') : null;
            }
            $domain->replaceSize($size);

            $scale = $this->getAttribute('scale') ? (int)$this->getAttribute('scale') : null;
            $domain->replaceScale($scale);

            $defval = $this->getAttribute('defaultValue', $this->getAttribute('default'));
            if ($defval !== null && strtolower($defval) !== 'null') {
                $domain->setDefaultValue(new ColumnDefaultValue($defval, ColumnDefaultValue::TYPE_VALUE));
            } elseif ($this->getAttribute('defaultExpr') !== null) {
                $domain->setDefaultValue(new ColumnDefaultValue($this->getAttribute('defaultExpr'), ColumnDefaultValue::TYPE_EXPR));
            }

            if ($this->getAttribute('valueSet')) {
                $this->setValueSet($this->getAttribute('valueSet'));
            }

            $this->inheritanceType = $this->getAttribute('inheritance');

            /*
                here we are only checking for 'false', so don't
                use booleanValue()
            */
            $this->isInheritance = ($this->inheritanceType !== null && $this->inheritanceType !== 'false');
        } catch (Exception $e) {
            throw new EngineException(sprintf(
                'Error setting up column %s: %s',
                $this->getAttribute('name'),
                $e->getMessage(),
            ));
        }
    }

    /**
     * Returns the generated methods visibility by looking for the
     * attribute value in the column, parent table or parent database.
     * Finally, it defaults to the default visibility (public).
     *
     * @param string $attribute Local column attribute
     * @param string $parentAttribute Parent (table or database) attribute
     *
     * @return string|null
     */
    private function getMethodVisibility(string $attribute, string $parentAttribute): ?string
    {
        $database = $this->getDatabase();

        $visibility = $this->getAttribute(
            $attribute,
            $this->parentTable->getAttribute(
                $parentAttribute,
                $database->getAttribute(
                    $parentAttribute,
                    self::DEFAULT_VISIBILITY,
                ),
            ),
        );

        return $visibility;
    }

    /**
     * Returns the database object the current column is in.
     *
     * @return \Propel\Generator\Model\Database|null
     */
    private function getDatabase(): ?Database
    {
        return $this->parentTable->getDatabase();
    }

    /**
     * Gets domain for this column, creating a new empty domain object if none is set.
     *
     * @return \Propel\Generator\Model\Domain
     */
    public function getDomain(): Domain
    {
        $domain = $this->domain;
        if ($domain === null) {
            $domain = new Domain();
            $this->domain = $domain;
        }

        return $domain;
    }

    /**
     * Sets the domain for this column.
     *
     * @param \Propel\Generator\Model\Domain $domain
     *
     * @return void
     */
    public function setDomain(Domain $domain): void
    {
        $this->domain = $domain;
    }

    /**
     * Returns the fully qualified column name (table.column).
     *
     * @return string
     */
    public function getFullyQualifiedName(): string
    {
        return $this->parentTable->getName() . '.' . strtoupper($this->getName());
    }

    /**
     * Returns the column name.
     *
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Returns the lowercased column name.
     *
     * @return string
     */
    public function getLowercasedName(): string
    {
        return strtolower($this->name);
    }

    /**
     * Returns the uppercased column name.
     *
     * @return string
     */
    public function getUppercasedName(): string
    {
        return strtoupper($this->name);
    }

    /**
     * Sets the column name.
     *
     * @param string $name
     *
     * @return void
     */
    public function setName(string $name): void
    {
        $this->name = $name;
    }

    /**
     * Returns whether the column name is plural.
     *
     * @return bool
     */
    public function isNamePlural(): bool
    {
        return $this->getSingularName() !== $this->name;
    }

    /**
     * Returns the column singular name.
     *
     * @return string
     */
    public function getSingularName(): string
    {
        if ($this->getAttribute('phpSingularName')) {
            return $this->getAttribute('phpSingularName');
        }

        return rtrim($this->name, 's');
    }

    /**
     * Returns the column description.
     *
     * @return string|null
     */
    public function getDescription(): ?string
    {
        return $this->description;
    }

    /**
     * Sets the column description.
     *
     * @param string $description
     *
     * @return void
     */
    public function setDescription(string $description): void
    {
        $this->description = $description;
    }

    /**
     * Returns the name to use in PHP sources. It will set & return
     * a self-generated phpName from its name if its not already set.
     *
     * @return string
     */
    public function getPhpName(): string
    {
        if ($this->phpName === null) {
            $this->setPhpName();
        }

        return $this->phpName;
    }

    /**
     * Returns the singular form of the name to use in PHP sources.
     * It will set & return a self-generated phpName from its name
     * if its not already set.
     *
     * @return string|null
     */
    public function getPhpSingularName(): ?string
    {
        if ($this->phpSingularName === null) {
            $this->setPhpSingularName();
        }

        return $this->phpSingularName;
    }

    /**
     * Sets the name to use in PHP sources.
     *
     * It will generate a phpName from its name if no
     * $phpName is passed.
     *
     * @param string|null $phpName
     *
     * @return void
     */
    public function setPhpName(?string $phpName = null): void
    {
        if ($phpName === null) {
            $this->phpName = self::generatePhpName($this->name, $this->phpNamingMethod, $this->namePrefix);
        } else {
            $this->phpName = $phpName;
        }
    }

    /**
     * Sets the singular forn of the name to use in PHP
     * sources.
     *
     * It will generate a phpName from its name if no
     * $phpSingularName is passed.
     *
     * @param string|null $phpSingularName
     *
     * @return void
     */
    public function setPhpSingularName(?string $phpSingularName = null): void
    {
        if ($phpSingularName === null) {
            $this->phpSingularName = self::generatePhpSingularName($this->getPhpName());
        } else {
            $this->phpSingularName = $phpSingularName;
        }
    }

    /**
     * Returns the camelCase version of the PHP name.
     *
     * The studly name is the PHP name with the first character lowercase.
     *
     * @return string
     */
    public function getCamelCaseName(): string
    {
        return lcfirst($this->getPhpName());
    }

    /**
     * Returns the accessor methods visibility of this column / attribute.
     *
     * @return string
     */
    public function getAccessorVisibility(): string
    {
        if ($this->accessorVisibility !== null) {
            return $this->accessorVisibility;
        }

        return self::DEFAULT_VISIBILITY;
    }

    /**
     * Sets the accessor methods visibility for this column / attribute.
     *
     * @param string $visibility
     *
     * @return void
     */
    public function setAccessorVisibility(string $visibility): void
    {
        $visibility = strtolower($visibility);
        if (!in_array($visibility, self::$validVisibilities)) {
            $visibility = self::DEFAULT_VISIBILITY;
        }

        $this->accessorVisibility = $visibility;
    }

    /**
     * Returns the mutator methods visibility for this current column.
     *
     * @return string
     */
    public function getMutatorVisibility(): string
    {
        if ($this->mutatorVisibility !== null) {
            return $this->mutatorVisibility;
        }

        return self::DEFAULT_VISIBILITY;
    }

    /**
     * Sets the mutator methods visibility for this column / attribute.
     *
     * @param string $visibility
     *
     * @return void
     */
    public function setMutatorVisibility(string $visibility): void
    {
        $visibility = strtolower($visibility);
        if (!in_array($visibility, self::$validVisibilities)) {
            $visibility = self::DEFAULT_VISIBILITY;
        }

        $this->mutatorVisibility = $visibility;
    }

    /**
     * Returns the full column constant name (e.g. TableMapName::COL_COLUMN_NAME).
     *
     * @return string A column constant name for insertion into PHP code
     */
    public function getFQConstantName(): string
    {
        $classname = $this->parentTable->getPhpName() . 'TableMap';
        $const = $this->getConstantName();

        return $classname . '::' . $const;
    }

    /**
     * Returns the column constant name.
     *
     * @return string
     */
    public function getConstantName(): string
    {
        // was it overridden in schema.xml ?
        if ($this->getTableMapName()) {
            return self::CONSTANT_PREFIX . strtoupper($this->getTableMapName());
        }

        return self::CONSTANT_PREFIX . strtoupper($this->getName());
    }

    /**
     * Returns the TableMap constant name that will identify this column.
     *
     * @return string|null
     */
    public function getTableMapName(): ?string
    {
        return $this->tableMapName;
    }

    /**
     * Sets the TableMap constant name that will identify this column.
     *
     * @param string $name
     *
     * @return void
     */
    public function setTableMapName(string $name): void
    {
        $this->tableMapName = $name;
    }

    /**
     * Returns the type to use in PHP sources.
     *
     * If no types has been specified, then use result of getPhpNative().
     *
     * @return string
     */
    public function getPhpType(): string
    {
        return $this->phpType ?: $this->getPhpNative();
    }

    /**
     * Returns the location of this column within the table (one-based).
     *
     * @return int|null
     */
    public function getPosition(): ?int
    {
        return $this->position;
    }

    /**
     * Returns the location of this column within the table (one-based).
     *
     * @param int $position
     *
     * @return void
     */
    public function setPosition(int $position): void
    {
        $this->position = $position;
    }

    /**
     * Sets the parent table.
     *
     * @param \Propel\Generator\Model\Table $table
     *
     * @return void
     */
    public function setTable(Table $table): void
    {
        $this->parentTable = $table;
    }

    /**
     * Returns the parent table.
     *
     * @return \Propel\Generator\Model\Table|null
     */
    public function getTable(): ?Table
    {
        return $this->parentTable;
    }

    /**
     * Returns the parent table name.
     *
     * @return string
     */
    public function getTableName(): string
    {
        return $this->parentTable->getName();
    }

    /**
     * Adds a new inheritance definition to the inheritance list and sets the
     * parent column of the inheritance to the current column.
     *
     * @param \Propel\Generator\Model\Inheritance|array $inheritance
     *
     * @return \Propel\Generator\Model\Inheritance
     */
    public function addInheritance($inheritance): Inheritance
    {
        if ($inheritance instanceof Inheritance) {
            $inheritance->setColumn($this);
            if ($this->inheritanceList === null) {
                $this->inheritanceList = [];
                $this->isEnumeratedClasses = true;
            }
            $this->inheritanceList[] = $inheritance;

            return $inheritance;
        }

        $inh = new Inheritance();
        $inh->loadMapping($inheritance);

        return $this->addInheritance($inh);
    }

    /**
     * Returns the inheritance type.
     *
     * @return string|null
     */
    public function getInheritanceType(): ?string
    {
        return $this->inheritanceType;
    }

    /**
     * Returns the inheritance list.
     *
     * @return array|null
     */
    public function getInheritanceList(): ?array
    {
        return $this->inheritanceList;
    }

    /**
     * Returns the inheritance definitions.
     *
     * @return array|null
     */
    public function getChildren(): ?array
    {
        return $this->inheritanceList;
    }

    /**
     * Returns whether this column is a normal property or specifies a
     * the classes that are represented in the table containing this column.
     *
     * @return bool
     */
    public function isInheritance(): bool
    {
        return $this->isInheritance;
    }

    /**
     * Returns whether possible classes have been enumerated in the
     * schema file.
     *
     * @return bool
     */
    public function isEnumeratedClasses(): bool
    {
        return $this->isEnumeratedClasses;
    }

    /**
     * Returns whether the column is not null.
     *
     * @return bool
     */
    public function isNotNull(): bool
    {
        return $this->isNotNull;
    }

    /**
     * Sets whether the column is not null.
     *
     * @param bool $flag
     *
     * @return void
     */
    public function setNotNull(bool $flag): void
    {
        $this->isNotNull = $flag;
    }

    /**
     * Returns NOT NULL string for this column.
     *
     * @return string
     */
    public function getNotNullString(): string
    {
        return $this->parentTable->getPlatform()->getNullString($this->isNotNull);
    }

    /**
     * Sets whether the column is used as the primary string.
     *
     * The primary string is the value used by default in the magic
     * __toString method of an active record object.
     *
     * @param bool $isPrimaryString
     *
     * @return void
     */
    public function setPrimaryString(bool $isPrimaryString): void
    {
        $this->isPrimaryString = (bool)$isPrimaryString;
    }

    /**
     * Returns true if the column is the primary string (used for the magic
     * __toString() method).
     *
     * @return bool
     */
    public function isPrimaryString(): bool
    {
        return $this->isPrimaryString;
    }

    /**
     * Sets whether the column is a primary key.
     *
     * @param bool $flag
     *
     * @return void
     */
    public function setPrimaryKey(bool $flag): void
    {
        $this->isPrimaryKey = $flag;
    }

    /**
     * Returns whether the column is the primary key.
     *
     * @return bool
     */
    public function isPrimaryKey(): bool
    {
        return $this->isPrimaryKey;
    }

    /**
     * Sets whether the column is a node key of a tree.
     *
     * @param bool $isNodeKey
     *
     * @return void
     */
    public function setNodeKey(bool $isNodeKey): void
    {
        $this->isNodeKey = (bool)$isNodeKey;
    }

    /**
     * Returns whether the column is a node key of a tree.
     *
     * @return bool
     */
    public function isNodeKey(): bool
    {
        return $this->isNodeKey;
    }

    /**
     * Sets the separator for the node key column in a tree.
     *
     * @param string $sep
     *
     * @return void
     */
    public function setNodeKeySep(string $sep): void
    {
        $this->nodeKeySep = (string)$sep;
    }

    /**
     * Returns the node key column separator for a tree.
     *
     * @return string
     */
    public function getNodeKeySep(): string
    {
        return $this->nodeKeySep;
    }

    /**
     * Sets whether the column is the nested set left key of a tree.
     *
     * @param bool $isNestedSetLeftKey
     *
     * @return void
     */
    public function setNestedSetLeftKey(bool $isNestedSetLeftKey): void
    {
        $this->isNestedSetLeftKey = (bool)$isNestedSetLeftKey;
    }

    /**
     * Returns whether the column is a nested set key of a tree.
     *
     * @return bool
     */
    public function isNestedSetLeftKey(): bool
    {
        return $this->isNestedSetLeftKey;
    }

    /**
     * Set if the column is the nested set right key of a tree.
     *
     * @param bool $isNestedSetRightKey
     *
     * @return void
     */
    public function setNestedSetRightKey(bool $isNestedSetRightKey): void
    {
        $this->isNestedSetRightKey = (bool)$isNestedSetRightKey;
    }

    /**
     * Return whether the column is a nested set right key of a tree.
     *
     * @return bool
     */
    public function isNestedSetRightKey(): bool
    {
        return $this->isNestedSetRightKey;
    }

    /**
     * Sets whether the column is the scope key of a tree.
     *
     * @param bool $isTreeScopeKey
     *
     * @return void
     */
    public function setTreeScopeKey(bool $isTreeScopeKey): void
    {
        $this->isTreeScopeKey = (bool)$isTreeScopeKey;
    }

    /**
     * Returns whether the column is a scope key of a tree.
     *
     * @return bool
     */
    public function isTreeScopeKey(): bool
    {
        return $this->isTreeScopeKey;
    }

    /**
     * Returns whether the column must have a unique index.
     *
     * @return bool
     */
    public function isUnique(): bool
    {
        return $this->isUnique;
    }

    /**
     * Returns true if the column requires a transaction in PostGreSQL.
     *
     * @return bool
     */
    public function requiresTransactionInPostgres(): bool
    {
        return $this->needsTransactionInPostgres;
    }

    /**
     * Returns whether this column is a foreign key.
     *
     * @return bool
     */
    public function isForeignKey(): bool
    {
        return count($this->getForeignKeys()) > 0;
    }

    /**
     * Returns whether this column is part of more than one foreign key.
     *
     * @return bool
     */
    public function hasMultipleFK(): bool
    {
        return count($this->getForeignKeys()) > 1;
    }

    /**
     * Returns the foreign key objects for this column.
     *
     * Only if it is a foreign key or part of a foreign key.
     *
     * @return array<\Propel\Generator\Model\ForeignKey>
     */
    public function getForeignKeys(): array
    {
        return $this->parentTable->getColumnForeignKeys($this->name);
    }

    /**
     * Adds the foreign key from another table that refers to this column.
     *
     * @param \Propel\Generator\Model\ForeignKey $fk
     *
     * @return void
     */
    public function addReferrer(ForeignKey $fk): void
    {
        $this->referrers[] = $fk;
    }

    /**
     * Returns the list of references to this column.
     *
     * @return array<\Propel\Generator\Model\ForeignKey>
     */
    public function getReferrers(): array
    {
        return $this->referrers;
    }

    /**
     * Returns whether this column has referers.
     *
     * @return bool
     */
    public function hasReferrers(): bool
    {
        return count($this->referrers) > 0;
    }

    /**
     * Returns whether this column has a specific referrer for a
     * specific foreign key object.
     *
     * @param \Propel\Generator\Model\ForeignKey $fk
     *
     * @return bool
     */
    public function hasReferrer(ForeignKey $fk): bool
    {
        return $this->referrers && in_array($fk, $this->referrers, true);
    }

    /**
     * Clears all referrers.
     *
     * @return void
     */
    public function clearReferrers(): void
    {
        $this->referrers = [];
    }

    /**
     * Clears all inheritance children.
     *
     * @return void
     */
    public function clearInheritanceList(): void
    {
        $this->inheritanceList = [];
    }

    /**
     * Sets the domain up for specified mapping type.
     *
     * Calling this method will implicitly overwrite any previously set type,
     * size, scale (or other domain attributes).
     *
     * @param string $mappingType
     *
     * @return void
     */
    public function setDomainForType(string $mappingType): void
    {
        $this->getDomain()->copy($this->getPlatform()->getDomainForType($mappingType));
    }

    /**
     * Sets the mapping column type.
     *
     * @see Domain::setType()
     *
     * @param string $mappingType
     *
     * @return void
     */
    public function setType(string $mappingType): void
    {
        $this->getDomain()->setType($mappingType);

        if (in_array($mappingType, [PropelTypes::VARBINARY, PropelTypes::LONGVARBINARY, PropelTypes::BLOB], true)) {
            $this->needsTransactionInPostgres = true;
        }
    }

    /**
     * Returns the Propel column type as a string.
     *
     * @see Domain::getType()
     *
     * @return string
     */
    public function getType(): string
    {
        return $this->getDomain()->getType();
    }

    /**
     * Returns the column PDO type integer for this column's mapping type.
     *
     * @return int
     */
    public function getPDOType(): int
    {
        return PropelTypes::getPDOType($this->getType());
    }

    /**
     * @param \Propel\Generator\Platform\PlatformInterface|null $platform
     *
     * @return bool
     */
    public function isDefaultSqlType(?PlatformInterface $platform = null): bool
    {
        if (
            $this->domain === null
            || $this->domain->getSqlType() === null
            || $platform === null
        ) {
            return true;
        }

        $defaultSqlType = $platform->getDomainForType($this->getType())->getSqlType();

        return $defaultSqlType === $this->getDomain()->getSqlType();
    }

    /**
     * Returns whether this column is a blob/lob type.
     *
     * @return bool
     */
    public function isLobType(): bool
    {
        return PropelTypes::isLobType($this->getType());
    }

    /**
     * Returns whether this column is a text type.
     *
     * @return bool
     */
    public function isTextType(): bool
    {
        return PropelTypes::isTextType($this->getType());
    }

    /**
     * Returns whether this column is a numeric type.
     *
     * @return bool
     */
    public function isNumericType(): bool
    {
        return PropelTypes::isNumericType($this->getType());
    }

    /**
     * Returns whether this column is a boolean type.
     *
     * @return bool
     */
    public function isBooleanType(): bool
    {
        return PropelTypes::isBooleanType($this->getType());
    }

    /**
     * Returns whether this column is a temporal type.
     *
     * @return bool
     */
    public function isTemporalType(): bool
    {
        return PropelTypes::isTemporalType($this->getType());
    }

    /**
     * Returns whether the column is an array column.
     *
     * @return bool
     */
    public function isPhpArrayType(): bool
    {
        return PropelTypes::isPhpArrayType($this->getType());
    }

    /**
     * Returns whether this column is an ENUM or SET column.
     *
     * @return bool
     */
    public function isValueSetType(): bool
    {
        return ($this->isEnumType() || $this->isSetType());
    }

    /**
     * Returns whether this column is an ENUM column.
     *
     * @return bool
     */
    public function isEnumType(): bool
    {
        return $this->getType() === PropelTypes::ENUM;
    }

    /**
     * Returns whether this column is a SET column.
     *
     * @return bool
     */
    public function isSetType(): bool
    {
        return $this->getType() === PropelTypes::SET;
    }

    /**
     * Sets the list of possible values for an ENUM or SET column.
     *
     * @param array<string>|string $valueSet
     *
     * @return void
     */
    public function setValueSet($valueSet): void
    {
        if (is_string($valueSet)) {
            $valueSet = explode(',', $valueSet);
            $valueSet = array_map('trim', $valueSet);
        }

        $this->valueSet = $valueSet;
    }

    /**
     * Returns the list of possible values for an ENUM or SET column.
     *
     * @return array<string>
     */
    public function getValueSet(): array
    {
        return $this->valueSet;
    }

    /**
     * Returns the column size.
     *
     * @return int|null
     */
    public function getSize(): ?int
    {
        return $this->domain ? $this->domain->getSize() : null;
    }

    /**
     * Sets the column size.
     *
     * @param int|null $size
     *
     * @return void
     */
    public function setSize(?int $size): void
    {
        $this->domain->setSize($size);
    }

    /**
     * Returns the column scale.
     *
     * @return int|null
     */
    public function getScale(): ?int
    {
        return $this->domain->getScale();
    }

    /**
     * Sets the column scale.
     *
     * @param int $scale
     *
     * @return void
     */
    public function setScale(int $scale): void
    {
        $this->domain->setScale($scale);
    }

    /**
     * Returns the size and precision in brackets for use in an SQL DLL.
     *
     * Example: (size[,scale]) <-> (10) or (10,2)
     *
     * @return string
     */
    public function getSizeDefinition(): string
    {
        return $this->domain->getSizeDefinition();
    }

    /**
     * Returns true if this table has a default value (and which is not NULL).
     *
     * @return bool
     */
    public function hasDefaultValue(): bool
    {
        return $this->getDefaultValue() !== null;
    }

    /**
     * Returns a string that will give this column a default value in PHP.
     *
     * @return string
     */
    public function getDefaultValueString(): string
    {
        $defaultValue = $this->getDefaultValue();

        if ($defaultValue === null) {
            return 'null';
        }

        if ($this->isNumericType()) {
            return (string)$defaultValue->getValue();
        }

        if ($this->isTextType() || $this->getDefaultValue()->isExpression()) {
            return sprintf("'%s'", str_replace("'", "\'", $defaultValue->getValue()));
        }

        if ($this->getType() === PropelTypes::BOOLEAN) {
            return $this->booleanValue($defaultValue->getValue()) ? 'true' : 'false';
        }

        return sprintf("'%s'", $defaultValue->getValue());
    }

    /**
     * Sets a string that will give this column a default value.
     *
     * @param \Propel\Generator\Model\ColumnDefaultValue|string|null $defaultValue The column's default value
     *
     * @return void
     */
    public function setDefaultValue($defaultValue): void
    {
        if (!$defaultValue instanceof ColumnDefaultValue) {
            $defaultValue = new ColumnDefaultValue($defaultValue, ColumnDefaultValue::TYPE_VALUE);
        }

        $this->domain->setDefaultValue($defaultValue);
    }

    /**
     * Returns the default value object for this column.
     *
     * @see Domain::getDefaultValue()
     *
     * @return \Propel\Generator\Model\ColumnDefaultValue|null
     */
    public function getDefaultValue(): ?ColumnDefaultValue
    {
        return $this->domain->getDefaultValue();
    }

    /**
     * Returns the default value suitable for use in PHP.
     *
     * @see Domain::getPhpDefaultValue()
     *
     * @return mixed|null
     */
    public function getPhpDefaultValue()
    {
        return $this->domain->getPhpDefaultValue();
    }

    /**
     * Returns whether or the column is an auto increment/sequence value for
     * the target database. We need to pass in the properties for the target
     * database!
     *
     * @return bool
     */
    public function isAutoIncrement(): bool
    {
        return $this->isAutoIncrement;
    }

    /**
     * Return whether the column has to be lazy loaded.
     *
     * For example, if a runtime query on the table doesn't hydrate this column
     * but a getter does.
     *
     * @return bool
     */
    public function isLazyLoad(): bool
    {
        return $this->isLazyLoad;
    }

    /**
     * Returns the auto-increment string.
     *
     * @throws \Propel\Generator\Exception\EngineException
     *
     * @return string
     */
    public function getAutoIncrementString(): string
    {
        if ($this->isAutoIncrement() && $this->parentTable->getIdMethod() === IdMethod::NATIVE) {
            return $this->getPlatform()->getAutoIncrement();
        }

        if ($this->isAutoIncrement()) {
            throw new EngineException(sprintf(
                'You have specified autoIncrement for column "%s", but you have not specified idMethod="native" for table "%s".',
                $this->name,
                $this->parentTable->getName(),
            ));
        }

        return '';
    }

    /**
     * Sets whether this column is an auto incremented value.
     *
     * Use isAutoIncrement() to find out if it is set or not.
     *
     * @param bool $flag
     *
     * @return void
     */
    public function setAutoIncrement(bool $flag): void
    {
        $this->isAutoIncrement = $flag;
    }

    /**
     * Returns a string representation of the native PHP type which corresponds
     * to the Propel type of this column. Used in the generation of Base
     * objects.
     *
     * @return string
     */
    public function getPhpNative(): string
    {
        return PropelTypes::getPhpNative($this->getType());
    }

    /**
     * Returns whether the column PHP native type is primitive type (aka
     * a boolean, an integer, a long, a float, a double or a string).
     *
     * @see PropelTypes::isPhpPrimitiveType()
     *
     * @return bool
     */
    public function isPhpPrimitiveType(): bool
    {
        return PropelTypes::isPhpPrimitiveType($this->getPhpType());
    }

    /**
     * Returns whether the column PHP native type is a primitive numeric
     * type (aka an integer, a long, a float or a double).
     *
     * @see PropelTypes::isPhpPrimitiveNumericType()
     *
     * @return bool
     */
    public function isPhpPrimitiveNumericType(): bool
    {
        return PropelTypes::isPhpPrimitiveNumericType($this->getPhpType());
    }

    /**
     * Returns whether the column PHP native type is an object.
     *
     * @see PropelTypes::isPhpObjectType()
     *
     * @return bool
     */
    public function isPhpObjectType(): bool
    {
        return PropelTypes::isPhpObjectType($this->getPhpType());
    }

    /**
     * Returns an instance of PlatformInterface interface.
     *
     * @return \Propel\Generator\Platform\PlatformInterface|null
     */
    public function getPlatform(): ?PlatformInterface
    {
        return $this->parentTable->getPlatform();
    }

    /**
     * Returns whether this column has a platform adapter.
     *
     * @return bool
     */
    public function hasPlatform(): bool
    {
        if ($this->parentTable === null) {
            return false;
        }

        return $this->parentTable->getPlatform() ? true : false;
    }

    /**
     * Clones the current object.
     *
     * @return void
     */
    public function __clone()
    {
        $this->referrers = [];
        if ($this->domain) {
            $this->domain = clone $this->domain;
        }
    }

    /**
     * Returns a generated PHP name.
     *
     * @param string $name
     * @param string|null $phpNamingMethod
     * @param string|null $namePrefix
     *
     * @return string
     */
    public static function generatePhpName(string $name, ?string $phpNamingMethod = null, ?string $namePrefix = null): string
    {
        if ($phpNamingMethod === null) {
            $phpNamingMethod = PhpNameGenerator::CONV_METHOD_CLEAN;
        }

        return NameFactory::generateName(NameFactory::PHP_GENERATOR, [$name, $phpNamingMethod, (string)$namePrefix]);
    }

    /**
     * Generates the singular form of a PHP name.
     *
     * @param string $phpName
     *
     * @return string
     */
    public static function generatePhpSingularName(string $phpName): string
    {
        return rtrim($phpName, 's');
    }
}