ral()
 {
 return $this->generatorType === self::GENERATOR_TYPE_NONE;
 }
 public function isIdentifierUuid()
 {
 Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9046', '%s is deprecated', __METHOD__);
 return $this->generatorType === self::GENERATOR_TYPE_UUID;
 }
 public function getTypeOfField($fieldName)
 {
 return isset($this->fieldMappings[$fieldName]) ? $this->fieldMappings[$fieldName]['type'] : null;
 }
 public function getTypeOfColumn($columnName)
 {
 return $this->getTypeOfField($this->getFieldName($columnName));
 }
 public function getTableName()
 {
 return $this->table['name'];
 }
 public function getSchemaName()
 {
 return $this->table['schema'] ?? null;
 }
 public function getTemporaryIdTableName()
 {
 // replace dots with underscores because PostgreSQL creates temporary tables in a special schema
 return str_replace('.', '_', $this->getTableName() . '_id_tmp');
 }
 public function setSubclasses(array $subclasses)
 {
 foreach ($subclasses as $subclass) {
 $this->subClasses[] = $this->fullyQualifiedClassName($subclass);
 }
 }
 public function setParentClasses(array $classNames)
 {
 $this->parentClasses = $classNames;
 if (count($classNames) > 0) {
 $this->rootEntityName = array_pop($classNames);
 }
 }
 public function setInheritanceType($type)
 {
 if (!$this->isInheritanceType($type)) {
 throw MappingException::invalidInheritanceType($this->name, $type);
 }
 $this->inheritanceType = $type;
 }
 public function setAssociationOverride($fieldName, array $overrideMapping)
 {
 if (!isset($this->associationMappings[$fieldName])) {
 throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
 }
 $mapping = $this->associationMappings[$fieldName];
 //if (isset($mapping['inherited']) && (count($overrideMapping) !== 1 || ! isset($overrideMapping['fetch']))) {
 // TODO: Deprecate overriding the fetch mode via association override for 3.0,
 // users should do this with a listener and a custom attribute/annotation
 // TODO: Enable this exception in 2.8
 //throw MappingException::illegalOverrideOfInheritedProperty($this->name, $fieldName);
 //}
 if (isset($overrideMapping['joinColumns'])) {
 $mapping['joinColumns'] = $overrideMapping['joinColumns'];
 }
 if (isset($overrideMapping['inversedBy'])) {
 $mapping['inversedBy'] = $overrideMapping['inversedBy'];
 }
 if (isset($overrideMapping['joinTable'])) {
 $mapping['joinTable'] = $overrideMapping['joinTable'];
 }
 if (isset($overrideMapping['fetch'])) {
 $mapping['fetch'] = $overrideMapping['fetch'];
 }
 $mapping['joinColumnFieldNames'] = null;
 $mapping['joinTableColumns'] = null;
 $mapping['sourceToTargetKeyColumns'] = null;
 $mapping['relationToSourceKeyColumns'] = null;
 $mapping['relationToTargetKeyColumns'] = null;
 switch ($mapping['type']) {
 case self::ONE_TO_ONE:
 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
 break;
 case self::ONE_TO_MANY:
 $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
 break;
 case self::MANY_TO_ONE:
 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
 break;
 case self::MANY_TO_MANY:
 $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
 break;
 }
 $this->associationMappings[$fieldName] = $mapping;
 }
 public function setAttributeOverride($fieldName, array $overrideMapping)
 {
 if (!isset($this->fieldMappings[$fieldName])) {
 throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
 }
 $mapping = $this->fieldMappings[$fieldName];
 //if (isset($mapping['inherited'])) {
 // TODO: Enable this exception in 2.8
 //throw MappingException::illegalOverrideOfInheritedProperty($this->name, $fieldName);
 //}
 if (isset($mapping['id'])) {
 $overrideMapping['id'] = $mapping['id'];
 }
 if (!isset($overrideMapping['type'])) {
 $overrideMapping['type'] = $mapping['type'];
 }
 if (!isset($overrideMapping['fieldName'])) {
 $overrideMapping['fieldName'] = $mapping['fieldName'];
 }
 if ($overrideMapping['type'] !== $mapping['type']) {
 throw MappingException::invalidOverrideFieldType($this->name, $fieldName);
 }
 unset($this->fieldMappings[$fieldName]);
 unset($this->fieldNames[$mapping['columnName']]);
 unset($this->columnNames[$mapping['fieldName']]);
 $overrideMapping = $this->validateAndCompleteFieldMapping($overrideMapping);
 $this->fieldMappings[$fieldName] = $overrideMapping;
 }
 public function isInheritedField($fieldName)
 {
 return isset($this->fieldMappings[$fieldName]['inherited']);
 }
 public function isRootEntity()
 {
 return $this->name === $this->rootEntityName;
 }
 public function isInheritedAssociation($fieldName)
 {
 return isset($this->associationMappings[$fieldName]['inherited']);
 }
 public function isInheritedEmbeddedClass($fieldName)
 {
 return isset($this->embeddedClasses[$fieldName]['inherited']);
 }
 public function setTableName($tableName)
 {
 $this->table['name'] = $tableName;
 }
 public function setPrimaryTable(array $table)
 {
 if (isset($table['name'])) {
 // Split schema and table name from a table name like "myschema.mytable"
 if (strpos($table['name'], '.') !== \false) {
 [$this->table['schema'], $table['name']] = explode('.', $table['name'], 2);
 }
 if ($table['name'][0] === '`') {
 $table['name'] = trim($table['name'], '`');
 $this->table['quoted'] = \true;
 }
 $this->table['name'] = $table['name'];
 }
 if (isset($table['quoted'])) {
 $this->table['quoted'] = $table['quoted'];
 }
 if (isset($table['schema'])) {
 $this->table['schema'] = $table['schema'];
 }
 if (isset($table['indexes'])) {
 $this->table['indexes'] = $table['indexes'];
 }
 if (isset($table['uniqueConstraints'])) {
 $this->table['uniqueConstraints'] = $table['uniqueConstraints'];
 }
 if (isset($table['options'])) {
 $this->table['options'] = $table['options'];
 }
 }
 private function isInheritanceType(int $type) : bool
 {
 return $type === self::INHERITANCE_TYPE_NONE || $type === self::INHERITANCE_TYPE_SINGLE_TABLE || $type === self::INHERITANCE_TYPE_JOINED || $type === self::INHERITANCE_TYPE_TABLE_PER_CLASS;
 }
 public function mapField(array $mapping)
 {
 $mapping = $this->validateAndCompleteFieldMapping($mapping);
 $this->assertFieldNotMapped($mapping['fieldName']);
 if (isset($mapping['generated'])) {
 $this->requiresFetchAfterChange = \true;
 }
 $this->fieldMappings[$mapping['fieldName']] = $mapping;
 }
 public function addInheritedAssociationMapping(array $mapping)
 {
 if (isset($this->associationMappings[$mapping['fieldName']])) {
 throw MappingException::duplicateAssociationMapping($this->name, $mapping['fieldName']);
 }
 $this->associationMappings[$mapping['fieldName']] = $mapping;
 }
 public function addInheritedFieldMapping(array $fieldMapping)
 {
 $this->fieldMappings[$fieldMapping['fieldName']] = $fieldMapping;
 $this->columnNames[$fieldMapping['fieldName']] = $fieldMapping['columnName'];
 $this->fieldNames[$fieldMapping['columnName']] = $fieldMapping['fieldName'];
 }
 public function addNamedQuery(array $queryMapping)
 {
 if (!isset($queryMapping['name'])) {
 throw MappingException::nameIsMandatoryForQueryMapping($this->name);
 }
 Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8592', 'Named Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository', $queryMapping['name'], $this->name);
 if (isset($this->namedQueries[$queryMapping['name']])) {
 throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
 }
 if (!isset($queryMapping['query'])) {
 throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
 }
 $name = $queryMapping['name'];
 $query = $queryMapping['query'];
 $dql = str_replace('__CLASS__', $this->name, $query);
 $this->namedQueries[$name] = ['name' => $name, 'query' => $query, 'dql' => $dql];
 }
 public function addNamedNativeQuery(array $queryMapping)
 {
 if (!isset($queryMapping['name'])) {
 throw MappingException::nameIsMandatoryForQueryMapping($this->name);
 }
 Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8592', 'Named Native Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository', $queryMapping['name'], $this->name);
 if (isset($this->namedNativeQueries[$queryMapping['name']])) {
 throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
 }
 if (!isset($queryMapping['query'])) {
 throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
 }
 if (!isset($queryMapping['resultClass']) && !isset($queryMapping['resultSetMapping'])) {
 throw MappingException::missingQueryMapping($this->name, $queryMapping['name']);
 }
 $queryMapping['isSelfClass'] = \false;
 if (isset($queryMapping['resultClass'])) {
 if ($queryMapping['resultClass'] === '__CLASS__') {
 $queryMapping['isSelfClass'] = \true;
 $queryMapping['resultClass'] = $this->name;
 }
 $queryMapping['resultClass'] = $this->fullyQualifiedClassName($queryMapping['resultClass']);
 $queryMapping['resultClass'] = ltrim($queryMapping['resultClass'], '\\');
 }
 $this->namedNativeQueries[$queryMapping['name']] = $queryMapping;
 }
 public function addSqlResultSetMapping(array $resultMapping)
 {
 if (!isset($resultMapping['name'])) {
 throw MappingException::nameIsMandatoryForSqlResultSetMapping($this->name);
 }
 if (isset($this->sqlResultSetMappings[$resultMapping['name']])) {
 throw MappingException::duplicateResultSetMapping($this->name, $resultMapping['name']);
 }
 if (isset($resultMapping['entities'])) {
 foreach ($resultMapping['entities'] as $key => $entityResult) {
 if (!isset($entityResult['entityClass'])) {
 throw MappingException::missingResultSetMappingEntity($this->name, $resultMapping['name']);
 }
 $entityResult['isSelfClass'] = \false;
 if ($entityResult['entityClass'] === '__CLASS__') {
 $entityResult['isSelfClass'] = \true;
 $entityResult['entityClass'] = $this->name;
 }
 $entityResult['entityClass'] = $this->fullyQualifiedClassName($entityResult['entityClass']);
 $resultMapping['entities'][$key]['entityClass'] = ltrim($entityResult['entityClass'], '\\');
 $resultMapping['entities'][$key]['isSelfClass'] = $entityResult['isSelfClass'];
 if (isset($entityResult['fields'])) {
 foreach ($entityResult['fields'] as $k => $field) {
 if (!isset($field['name'])) {
 throw MappingException::missingResultSetMappingFieldName($this->name, $resultMapping['name']);
 }
 if (!isset($field['column'])) {
 $fieldName = $field['name'];
 if (strpos($fieldName, '.')) {
 [, $fieldName] = explode('.', $fieldName);
 }
 $resultMapping['entities'][$key]['fields'][$k]['column'] = $fieldName;
 }
 }
 }
 }
 }
 $this->sqlResultSetMappings[$resultMapping['name']] = $resultMapping;
 }
 public function mapOneToOne(array $mapping)
 {
 $mapping['type'] = self::ONE_TO_ONE;
 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
 $this->_storeAssociationMapping($mapping);
 }
 public function mapOneToMany(array $mapping)
 {
 $mapping['type'] = self::ONE_TO_MANY;
 $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
 $this->_storeAssociationMapping($mapping);
 }
 public function mapManyToOne(array $mapping)
 {
 $mapping['type'] = self::MANY_TO_ONE;
 // A many-to-one mapping is essentially a one-one backreference
 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
 $this->_storeAssociationMapping($mapping);
 }
 public function mapManyToMany(array $mapping)
 {
 $mapping['type'] = self::MANY_TO_MANY;
 $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
 $this->_storeAssociationMapping($mapping);
 }
 protected function _storeAssociationMapping(array $assocMapping)
 {
 $sourceFieldName = $assocMapping['fieldName'];
 $this->assertFieldNotMapped($sourceFieldName);
 $this->associationMappings[$sourceFieldName] = $assocMapping;
 }
 public function setCustomRepositoryClass($repositoryClassName)
 {
 $this->customRepositoryClassName = $this->fullyQualifiedClassName($repositoryClassName);
 }
 public function invokeLifecycleCallbacks($lifecycleEvent, $entity)
 {
 foreach ($this->lifecycleCallbacks[$lifecycleEvent] as $callback) {
 $entity->{$callback}();
 }
 }
 public function hasLifecycleCallbacks($lifecycleEvent)
 {
 return isset($this->lifecycleCallbacks[$lifecycleEvent]);
 }
 public function getLifecycleCallbacks($event)
 {
 return $this->lifecycleCallbacks[$event] ?? [];
 }
 public function addLifecycleCallback($callback, $event)
 {
 if ($this->isEmbeddedClass) {
 Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/8381', 'Registering lifecycle callback %s on Embedded class %s is not doing anything and will throw exception in 3.0', $event, $this->name);
 }
 if (isset($this->lifecycleCallbacks[$event]) && in_array($callback, $this->lifecycleCallbacks[$event], \true)) {
 return;
 }
 $this->lifecycleCallbacks[$event][] = $callback;
 }
 public function setLifecycleCallbacks(array $callbacks)
 {
 $this->lifecycleCallbacks = $callbacks;
 }
 public function addEntityListener($eventName, $class, $method)
 {
 $class = $this->fullyQualifiedClassName($class);
 $listener = ['class' => $class, 'method' => $method];
 if (!class_exists($class)) {
 throw MappingException::entityListenerClassNotFound($class, $this->name);
 }
 if (!method_exists($class, $method)) {
 throw MappingException::entityListenerMethodNotFound($class, $method, $this->name);
 }
 if (isset($this->entityListeners[$eventName]) && in_array($listener, $this->entityListeners[$eventName], \true)) {
 throw MappingException::duplicateEntityListener($class, $method, $this->name);
 }
 $this->entityListeners[$eventName][] = $listener;
 }
 public function setDiscriminatorColumn($columnDef)
 {
 if ($columnDef !== null) {
 if (!isset($columnDef['name'])) {
 throw MappingException::nameIsMandatoryForDiscriminatorColumns($this->name);
 }
 if (isset($this->fieldNames[$columnDef['name']])) {
 throw MappingException::duplicateColumnName($this->name, $columnDef['name']);
 }
 if (!isset($columnDef['fieldName'])) {
 $columnDef['fieldName'] = $columnDef['name'];
 }
 if (!isset($columnDef['type'])) {
 $columnDef['type'] = 'string';
 }
 if (in_array($columnDef['type'], ['boolean', 'array', 'object', 'datetime', 'time', 'date'], \true)) {
 throw MappingException::invalidDiscriminatorColumnType($this->name, $columnDef['type']);
 }
 $this->discriminatorColumn = $columnDef;
 }
 }
 public final function getDiscriminatorColumn() : array
 {
 if ($this->discriminatorColumn === null) {
 throw new LogicException('The discriminator column was not set.');
 }
 return $this->discriminatorColumn;
 }
 public function setDiscriminatorMap(array $map)
 {
 foreach ($map as $value => $className) {
 $this->addDiscriminatorMapClass($value, $className);
 }
 }
 public function addDiscriminatorMapClass($name, $className)
 {
 $className = $this->fullyQualifiedClassName($className);
 $className = ltrim($className, '\\');
 $this->discriminatorMap[$name] = $className;
 if ($this->name === $className) {
 $this->discriminatorValue = $name;
 return;
 }
 if (!(class_exists($className) || interface_exists($className))) {
 throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
 }
 if (is_subclass_of($className, $this->name) && !in_array($className, $this->subClasses, \true)) {
 $this->subClasses[] = $className;
 }
 }
 public function hasNamedQuery($queryName)
 {
 return isset($this->namedQueries[$queryName]);
 }
 public function hasNamedNativeQuery($queryName)
 {
 return isset($this->namedNativeQueries[$queryName]);
 }
 public function hasSqlResultSetMapping($name)
 {
 return isset($this->sqlResultSetMappings[$name]);
 }
 public function hasAssociation($fieldName)
 {
 return isset($this->associationMappings[$fieldName]);
 }
 public function isSingleValuedAssociation($fieldName)
 {
 return isset($this->associationMappings[$fieldName]) && $this->associationMappings[$fieldName]['type'] & self::TO_ONE;
 }
 public function isCollectionValuedAssociation($fieldName)
 {
 return isset($this->associationMappings[$fieldName]) && !($this->associationMappings[$fieldName]['type'] & self::TO_ONE);
 }
 public function isAssociationWithSingleJoinColumn($fieldName)
 {
 return isset($this->associationMappings[$fieldName]) && isset($this->associationMappings[$fieldName]['joinColumns'][0]) && !isset($this->associationMappings[$fieldName]['joinColumns'][1]);
 }
 public function getSingleAssociationJoinColumnName($fieldName)
 {
 if (!$this->isAssociationWithSingleJoinColumn($fieldName)) {
 throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
 }
 return $this->associationMappings[$fieldName]['joinColumns'][0]['name'];
 }
 public function getSingleAssociationReferencedJoinColumnName($fieldName)
 {
 if (!$this->isAssociationWithSingleJoinColumn($fieldName)) {
 throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
 }
 return $this->associationMappings[$fieldName]['joinColumns'][0]['referencedColumnName'];
 }
 public function getFieldForColumn($columnName)
 {
 if (isset($this->fieldNames[$columnName])) {
 return $this->fieldNames[$columnName];
 }
 foreach ($this->associationMappings as $assocName => $mapping) {
 if ($this->isAssociationWithSingleJoinColumn($assocName) && $this->associationMappings[$assocName]['joinColumns'][0]['name'] === $columnName) {
 return $assocName;
 }
 }
 throw MappingException::noFieldNameFoundForColumn($this->name, $columnName);
 }
 public function setIdGenerator($generator)
 {
 $this->idGenerator = $generator;
 }
 public function setCustomGeneratorDefinition(array $definition)
 {
 $this->customGeneratorDefinition = $definition;
 }
 public function setSequenceGeneratorDefinition(array $definition)
 {
 if (!isset($definition['sequenceName']) || trim($definition['sequenceName']) === '') {
 throw MappingException::missingSequenceName($this->name);
 }
 if ($definition['sequenceName'][0] === '`') {
 $definition['sequenceName'] = trim($definition['sequenceName'], '`');
 $definition['quoted'] = \true;
 }
 if (!isset($definition['allocationSize']) || trim((string) $definition['allocationSize']) === '') {
 $definition['allocationSize'] = '1';
 }
 if (!isset($definition['initialValue']) || trim((string) $definition['initialValue']) === '') {
 $definition['initialValue'] = '1';
 }
 $definition['allocationSize'] = (string) $definition['allocationSize'];
 $definition['initialValue'] = (string) $definition['initialValue'];
 $this->sequenceGeneratorDefinition = $definition;
 }
 public function setVersionMapping(array &$mapping)
 {
 $this->isVersioned = \true;
 $this->versionField = $mapping['fieldName'];
 $this->requiresFetchAfterChange = \true;
 if (!isset($mapping['default'])) {
 if (in_array($mapping['type'], ['integer', 'bigint', 'smallint'], \true)) {
 $mapping['default'] = 1;
 } elseif ($mapping['type'] === 'datetime') {
 $mapping['default'] = 'CURRENT_TIMESTAMP';
 } else {
 throw MappingException::unsupportedOptimisticLockingType($this->name, $mapping['fieldName'], $mapping['type']);
 }
 }
 }
 public function setVersioned($bool)
 {
 $this->isVersioned = $bool;
 if ($bool) {
 $this->requiresFetchAfterChange = \true;
 }
 }
 public function setVersionField($versionField)
 {
 $this->versionField = $versionField;
 }
 public function markReadOnly()
 {
 $this->isReadOnly = \true;
 }
 public function getFieldNames()
 {
 return array_keys($this->fieldMappings);
 }
 public function getAssociationNames()
 {
 return array_keys($this->associationMappings);
 }
 public function getAssociationTargetClass($assocName)
 {
 if (!isset($this->associationMappings[$assocName])) {
 throw new InvalidArgumentException("Association name expected, '" . $assocName . "' is not an association.");
 }
 return $this->associationMappings[$assocName]['targetEntity'];
 }
 public function getName()
 {
 return $this->name;
 }
 public function getQuotedIdentifierColumnNames($platform)
 {
 $quotedColumnNames = [];
 foreach ($this->identifier as $idProperty) {
 if (isset($this->fieldMappings[$idProperty])) {
 $quotedColumnNames[] = isset($this->fieldMappings[$idProperty]['quoted']) ? $platform->quoteIdentifier($this->fieldMappings[$idProperty]['columnName']) : $this->fieldMappings[$idProperty]['columnName'];
 continue;
 }
 // Association defined as Id field
 $joinColumns = $this->associationMappings[$idProperty]['joinColumns'];
 $assocQuotedColumnNames = array_map(static function ($joinColumn) use($platform) {
 return isset($joinColumn['quoted']) ? $platform->quoteIdentifier($joinColumn['name']) : $joinColumn['name'];
 }, $joinColumns);
 $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
 }
 return $quotedColumnNames;
 }
 public function getQuotedColumnName($field, $platform)
 {
 return isset($this->fieldMappings[$field]['quoted']) ? $platform->quoteIdentifier($this->fieldMappings[$field]['columnName']) : $this->fieldMappings[$field]['columnName'];
 }
 public function getQuotedTableName($platform)
 {
 return isset($this->table['quoted']) ? $platform->quoteIdentifier($this->table['name']) : $this->table['name'];
 }
 public function getQuotedJoinTableName(array $assoc, $platform)
 {
 return isset($assoc['joinTable']['quoted']) ? $platform->quoteIdentifier($assoc['joinTable']['name']) : $assoc['joinTable']['name'];
 }
 public function isAssociationInverseSide($fieldName)
 {
 return isset($this->associationMappings[$fieldName]) && !$this->associationMappings[$fieldName]['isOwningSide'];
 }
 public function getAssociationMappedByTargetField($fieldName)
 {
 return $this->associationMappings[$fieldName]['mappedBy'];
 }
 public function getAssociationsByTargetClass($targetClass)
 {
 $relations = [];
 foreach ($this->associationMappings as $mapping) {
 if ($mapping['targetEntity'] === $targetClass) {
 $relations[$mapping['fieldName']] = $mapping;
 }
 }
 return $relations;
 }
 public function fullyQualifiedClassName($className)
 {
 if (empty($className)) {
 return $className;
 }
 if (strpos($className, '\\') === \false && $this->namespace) {
 return $this->namespace . '\\' . $className;
 }
 return $className;
 }
 public function getMetadataValue($name)
 {
 if (isset($this->{$name})) {
 return $this->{$name};
 }
 return null;
 }
 public function mapEmbedded(array $mapping)
 {
 $this->assertFieldNotMapped($mapping['fieldName']);
 if (!isset($mapping['class']) && $this->isTypedProperty($mapping['fieldName'])) {
 $type = $this->reflClass->getProperty($mapping['fieldName'])->getType();
 if ($type instanceof ReflectionNamedType) {
 $mapping['class'] = $type->getName();
 }
 }
 $this->embeddedClasses[$mapping['fieldName']] = ['class' => $this->fullyQualifiedClassName($mapping['class']), 'columnPrefix' => $mapping['columnPrefix'] ?? null, 'declaredField' => $mapping['declaredField'] ?? null, 'originalField' => $mapping['originalField'] ?? null];
 }
 public function inlineEmbeddable($property, ClassMetadataInfo $embeddable)
 {
 foreach ($embeddable->fieldMappings as $fieldMapping) {
 $fieldMapping['originalClass'] = $fieldMapping['originalClass'] ?? $embeddable->name;
 $fieldMapping['declaredField'] = isset($fieldMapping['declaredField']) ? $property . '.' . $fieldMapping['declaredField'] : $property;
 $fieldMapping['originalField'] = $fieldMapping['originalField'] ?? $fieldMapping['fieldName'];
 $fieldMapping['fieldName'] = $property . '.' . $fieldMapping['fieldName'];
 if (!empty($this->embeddedClasses[$property]['columnPrefix'])) {
 $fieldMapping['columnName'] = $this->embeddedClasses[$property]['columnPrefix'] . $fieldMapping['columnName'];
 } elseif ($this->embeddedClasses[$property]['columnPrefix'] !== \false) {
 $fieldMapping['columnName'] = $this->namingStrategy->embeddedFieldToColumnName($property, $fieldMapping['columnName'], $this->reflClass->name, $embeddable->reflClass->name);
 }
 $this->mapField($fieldMapping);
 }
 }
 private function assertFieldNotMapped(string $fieldName) : void
 {
 if (isset($this->fieldMappings[$fieldName]) || isset($this->associationMappings[$fieldName]) || isset($this->embeddedClasses[$fieldName])) {
 throw MappingException::duplicateFieldMapping($this->name, $fieldName);
 }
 }
 public function getSequenceName(AbstractPlatform $platform)
 {
 $sequencePrefix = $this->getSequencePrefix($platform);
 $columnName = $this->getSingleIdentifierColumnName();
 return $sequencePrefix . '_' . $columnName . '_seq';
 }
 public function getSequencePrefix(AbstractPlatform $platform)
 {
 $tableName = $this->getTableName();
 $sequencePrefix = $tableName;
 // Prepend the schema name to the table name if there is one
 $schemaName = $this->getSchemaName();
 if ($schemaName) {
 $sequencePrefix = $schemaName . '.' . $tableName;
 if (!$platform->supportsSchemas() && $platform->canEmulateSchemas()) {
 $sequencePrefix = $schemaName . '__' . $tableName;
 }
 }
 return $sequencePrefix;
 }
 private function assertMappingOrderBy(array $mapping) : void
 {
 if (isset($mapping['orderBy']) && !is_array($mapping['orderBy'])) {
 throw new InvalidArgumentException("'orderBy' is expected to be an array, not " . gettype($mapping['orderBy']));
 }
 }
 private function getAccessibleProperty(ReflectionService $reflService, string $class, string $field) : ?ReflectionProperty
 {
 $reflectionProperty = $reflService->getAccessibleProperty($class, $field);
 if ($reflectionProperty !== null && PHP_VERSION_ID >= 80100 && $reflectionProperty->isReadOnly()) {
 $reflectionProperty = new ReflectionReadonlyProperty($reflectionProperty);
 }
 return $reflectionProperty;
 }
}