{

/**

public const TABLE_MAP = '\\SOB\\Propel2\\Map\\PrivilegeTableMap';

/**

protected $alreadyInSave = false;

/**

protected $deleted = false;

/**

protected $modifiedColumns = [];

/**

protected $new = true;

/**

protected $privilege;

/**

protected $privilege_id;

/**

protected $virtualColumns = [];

/**

public function __construct()

{

}

/**

public function __call($name, $params)

{

if (0 === \strpos($name, 'get')) {

$virtualColumn = \substr($name, 3);

if ($this->hasVirtualColumn($virtualColumn)) {

return $this->getVirtualColumn($virtualColumn);

}

$virtualColumn = \lcfirst($virtualColumn);

if ($this->hasVirtualColumn($virtualColumn)) {

return $this->getVirtualColumn($virtualColumn);

}

}

if (0 === \strpos($name, 'from')) {

$format = \substr($name, 4);

$inputData = $params[0];

$keyType = $params[1] ?? TableMap::TYPE_PHPNAME;

return $this->importFrom($format, $inputData, $keyType);

}

if (0 === \strpos($name, 'to')) {

$format = \substr($name, 2);

$includeLazyLoadColumns = $params[0] ?? true;

$keyType = $params[1] ?? TableMap::TYPE_PHPNAME;

return $this->exportTo($format, $includeLazyLoadColumns, $keyType);

}

throw new BadMethodCallException(\sprintf('Call to undefined method: %s.', $name));

}

/**

public function __sleep() : array

{

$this->clearAllReferences();

$cls = new \ReflectionClass($this);

$propertyNames = [];

$serializableProperties = \array_diff($cls->getProperties(), $cls->getProperties(\ReflectionProperty::IS_STATIC));

foreach($serializableProperties as $property) {

$propertyNames[] = $property->getName();

}

return $propertyNames;

}

/**

public function __toString()

{

return (string)$this->exportTo(PrivilegeTableMap::DEFAULT_STRING_FORMAT);

}

/**

public function buildCriteria() : Criteria

{

$criteria = new Criteria(PrivilegeTableMap::DATABASE_NAME);

if ($this->isColumnModified(PrivilegeTableMap::COL_PRIVILEGE_ID)) {

$criteria->add(PrivilegeTableMap::COL_PRIVILEGE_ID, $this->privilege_id);

}

if ($this->isColumnModified(PrivilegeTableMap::COL_PRIVILEGE)) {

$criteria->add(PrivilegeTableMap::COL_PRIVILEGE, $this->privilege);

}

return $criteria;

}

/**

public function buildPkeyCriteria() : Criteria

{

$criteria = ChildPrivilegeQuery::create();

$criteria->add(PrivilegeTableMap::COL_PRIVILEGE_ID, $this->privilege_id);

return $criteria;

}

/**

public function clear()

{

$this->privilege_id = null;

$this->privilege = null;

$this->alreadyInSave = false;

$this->clearAllReferences();

$this->resetModified();

$this->setNew(true);

$this->setDeleted(false);

return $this;

}

/**

public function clearAllReferences(bool $deep = false)

{

if ($deep) {

} // if ($deep)

return $this;

}

/**

public function copy(bool $deepCopy = false)

{

// we use get_class(), because this might be a subclass

$clazz = static::class;

$copyObj = new $clazz();

$this->copyInto($copyObj, $deepCopy);

return $copyObj;

}

/**

public function copyInto(object $copyObj, bool $deepCopy = false, bool $makeNew = true) : void

{

$copyObj->setPrivilege($this->getPrivilege());

if ($makeNew) {

$copyObj->setNew(true);

$copyObj->setPrivilegeId(null); // this is a auto-increment column, so set to default value

}

}

/**

public function delete(?ConnectionInterface $con = null) : void

{

if ($this->isDeleted()) {

throw new PropelException('This object has already been deleted.');

}

if (null === $con) {

$con = Propel::getServiceContainer()->getWriteConnection(PrivilegeTableMap::DATABASE_NAME);

}

$con->transaction(function() use ($con) : void {

$deleteQuery = ChildPrivilegeQuery::create()

->filterByPrimaryKey($this->getPrimaryKey());

$ret = $this->preDelete($con);

if ($ret) {

$deleteQuery->delete($con);

$this->postDelete($con);

$this->setDeleted(true);

}

});

}

/**

public function ensureConsistency() : void

{

}

/**

public function equals($obj) : bool

{

if (! $obj instanceof static) {

return false;

}

if ($this === $obj) {

return true;

}

if (null === $this->getPrimaryKey() || null === $obj->getPrimaryKey()) {

return false;

}

return $this->getPrimaryKey() === $obj->getPrimaryKey();

}

/**

public function exportTo($parser, bool $includeLazyLoadColumns = true, string $keyType = TableMap::TYPE_PHPNAME) : string

{

if (! $parser instanceof AbstractParser) {

$parser = AbstractParser::getParser($parser);

}

return $parser->fromArray($this->toArray($keyType, $includeLazyLoadColumns, [], true));

}

/**

public function fromArray(array $arr, string $keyType = TableMap::TYPE_PHPNAME)

{

$keys = PrivilegeTableMap::getFieldNames($keyType);

if (\array_key_exists($keys[0], $arr)) {

$this->setPrivilegeId($arr[$keys[0]]);

}

if (\array_key_exists($keys[1], $arr)) {

$this->setPrivilege($arr[$keys[1]]);

}

return $this;

}

/**

public function getByName(string $name, string $type = TableMap::TYPE_PHPNAME)

{

$pos = PrivilegeTableMap::translateFieldName($name, $type, TableMap::TYPE_NUM);

$field = $this->getByPosition($pos);

return $field;

}

/**

public function getByPosition(int $pos)

{

switch ($pos) {

case 0:

return $this->getPrivilegeId();

case 1:

return $this->getPrivilege();

default:

return;

} // switch()

}

/**

public function getModifiedColumns() : array

{

return $this->modifiedColumns ? \array_keys($this->modifiedColumns) : [];

}

/**

public function getPrimaryKey()

{

return $this->getPrivilegeId();

}

/**

public function getPrivilege()

{

return $this->privilege;

}

/**

public function getPrivilegeId()

{

return $this->privilege_id;

}

/**

public function getVirtualColumn(string $name)

{

if (! $this->hasVirtualColumn($name)) {

throw new PropelException(\sprintf('Cannot get value of nonexistent virtual column `%s`.', $name));

}

return $this->virtualColumns[$name];

}

/**

public function getVirtualColumns() : array

{

return $this->virtualColumns;

}

/**

public function hashCode()

{

$validPk = null !== $this->getPrivilegeId();

$validPrimaryKeyFKs = 0;

$primaryKeyFKs = [];

if ($validPk) {

return \crc32(\json_encode($this->getPrimaryKey(), JSON_UNESCAPED_UNICODE));

} elseif ($validPrimaryKeyFKs) {

return \crc32(\json_encode($primaryKeyFKs, JSON_UNESCAPED_UNICODE));

}

return \spl_object_hash($this);

}

/**

public function hasOnlyDefaultValues() : bool

{

// otherwise, everything was equal, so return TRUE

return true;

}

/**

public function hasVirtualColumn(string $name) : bool

{

return \array_key_exists($name, $this->virtualColumns);

}

/**

public function hydrate(array $row, int $startcol = 0, bool $rehydrate = false, string $indexType = TableMap::TYPE_NUM) : int

{

try {

$col = $row[TableMap::TYPE_NUM == $indexType ? 0 + $startcol : PrivilegeTableMap::translateFieldName('PrivilegeId', TableMap::TYPE_PHPNAME, $indexType)];

$this->privilege_id = (null !== $col) ? (int)$col : null;

$col = $row[TableMap::TYPE_NUM == $indexType ? 1 + $startcol : PrivilegeTableMap::translateFieldName('Privilege', TableMap::TYPE_PHPNAME, $indexType)];

$this->privilege = (null !== $col) ? (string)$col : null;

$this->resetModified();

$this->setNew(false);

if ($rehydrate) {

$this->ensureConsistency();

}

return $startcol + 2; // 2 = PrivilegeTableMap::NUM_HYDRATE_COLUMNS.

} catch (Exception $e) {

throw new PropelException(\sprintf('Error populating %s object', '\\SOB\\Propel2\\Privilege'), 0, $e);

}

}

/**

public function importFrom($parser, string $data, string $keyType = TableMap::TYPE_PHPNAME)

{

if (! $parser instanceof AbstractParser) {

$parser = AbstractParser::getParser($parser);

}

$this->fromArray($parser->toArray($data), $keyType);

return $this;

}

/**

public function isColumnModified(string $col) : bool

{

return $this->modifiedColumns && isset($this->modifiedColumns[$col]);

}

/**

public function isDeleted() : bool

{

return $this->deleted;

}

/**

public function isModified() : bool

{

return (bool)$this->modifiedColumns;

}

/**

public function isNew() : bool

{

return $this->new;

}

/**

public function isPrimaryKeyNull() : bool

{

return null === $this->getPrivilegeId();

}

/**

public function postDelete(?ConnectionInterface $con = null) : void

{

}

/**

public function postInsert(?ConnectionInterface $con = null) : void

{

}

/**

public function postSave(?ConnectionInterface $con = null) : void

{

}

/**

public function postUpdate(?ConnectionInterface $con = null) : void

{

}

/**

public function preDelete(?ConnectionInterface $con = null) : bool

{

return true;

}

/**

public function preInsert(?ConnectionInterface $con = null) : bool

{

return true;

}

/**

public function preSave(?ConnectionInterface $con = null) : bool

{

return true;

}

/**

public function preUpdate(?ConnectionInterface $con = null) : bool

{

return true;

}

/**

public function reload(bool $deep = false, ?ConnectionInterface $con = null) : void

{

if ($this->isDeleted()) {

throw new PropelException('Cannot reload a deleted object.');

}

if ($this->isNew()) {

throw new PropelException('Cannot reload an unsaved object.');

}

if (null === $con) {

$con = Propel::getServiceContainer()->getReadConnection(PrivilegeTableMap::DATABASE_NAME);

}

// We don't need to alter the object instance pool; we're just modifying this instance

// already in the pool.

$dataFetcher = ChildPrivilegeQuery::create(null, $this->buildPkeyCriteria())->setFormatter(ModelCriteria::FORMAT_STATEMENT)->find($con);

$row = $dataFetcher->fetch();

$dataFetcher->close();

if (! $row) {

throw new PropelException('Cannot find matching row in the database to reload object values.');

}

$this->hydrate($row, 0, true, $dataFetcher->getIndexType()); // rehydrate

if ($deep) { // also de-associate any related objects?

} // if (deep)

}

/**

public function resetModified(?string $col = null) : void

{

if (null !== $col) {

unset($this->modifiedColumns[$col]);

} else {

$this->modifiedColumns = [];

}

}

/**

public function save(?ConnectionInterface $con = null) : int

{

if ($this->isDeleted()) {

throw new PropelException('You cannot save an object that has been deleted.');

}

if ($this->alreadyInSave) {

return 0;

}

if (null === $con) {

$con = Propel::getServiceContainer()->getWriteConnection(PrivilegeTableMap::DATABASE_NAME);

}

return $con->transaction(function() use ($con) {

$ret = $this->preSave($con);

$isInsert = $this->isNew();

if ($isInsert) {

$ret = $ret && $this->preInsert($con);

} else {

$ret = $ret && $this->preUpdate($con);

}

if ($ret) {

$affectedRows = $this->doSave($con);

if ($isInsert) {

$this->postInsert($con);

} else {

$this->postUpdate($con);

}

$this->postSave($con);

PrivilegeTableMap::addInstanceToPool($this);

} else {

$affectedRows = 0;

}

return $affectedRows;

});

}

/**

public function setByName(string $name, $value, string $type = TableMap::TYPE_PHPNAME)

{

$pos = PrivilegeTableMap::translateFieldName($name, $type, TableMap::TYPE_NUM);

$this->setByPosition($pos, $value);

return $this;

}

/**

public function setByPosition(int $pos, $value)

{

switch ($pos) {

case 0:

$this->setPrivilegeId($value);

break;

case 1:

$this->setPrivilege($value);

break;

} // switch()

return $this;

}

/**

public function setDeleted(bool $b) : void

{

$this->deleted = $b;

}

/**

public function setNew(bool $b) : void

{

$this->new = $b;

}

/**

public function setPrimaryKey(?int $key = null) : void

{

$this->setPrivilegeId($key);

}

/**

public function setPrivilege($v)

{

if (null !== $v) {

$v = (string)$v;

}

if ($this->privilege !== $v) {

$this->privilege = $v;

$this->modifiedColumns[PrivilegeTableMap::COL_PRIVILEGE] = true;

}

return $this;

}

/**

public function setPrivilegeId($v)

{

if (null !== $v) {

$v = (int)$v;

}

if ($this->privilege_id !== $v) {

$this->privilege_id = $v;

$this->modifiedColumns[PrivilegeTableMap::COL_PRIVILEGE_ID] = true;

}

return $this;

}

/**

public function setVirtualColumn(string $name, $value)

{

$this->virtualColumns[$name] = $value;

return $this;

}

/**

public function toArray(string $keyType = TableMap::TYPE_PHPNAME, bool $includeLazyLoadColumns = true, array $alreadyDumpedObjects = []) : array

{

if (isset($alreadyDumpedObjects['Privilege'][$this->hashCode()])) {

return ['*RECURSION*'];

}

$alreadyDumpedObjects['Privilege'][$this->hashCode()] = true;

$keys = PrivilegeTableMap::getFieldNames($keyType);

$result = [

$keys[0] => $this->getPrivilegeId(),