{

/**

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

/**

protected $alreadyInSave = false;

/**

protected $deleted = false;

/**

protected $imageable_type;

/**

protected $imageableid;

/**

protected $imageid;

/**

protected $modifiedColumns = [];

/**

protected $new = true;

/**

protected $path;

/**

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(ImageTableMap::DEFAULT_STRING_FORMAT);

}

/**

public function buildCriteria() : Criteria

{

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

if ($this->isColumnModified(ImageTableMap::COL_IMAGEID)) {

$criteria->add(ImageTableMap::COL_IMAGEID, $this->imageid);

}

if ($this->isColumnModified(ImageTableMap::COL_IMAGEABLEID)) {

$criteria->add(ImageTableMap::COL_IMAGEABLEID, $this->imageableid);

}

if ($this->isColumnModified(ImageTableMap::COL_IMAGEABLE_TYPE)) {

$criteria->add(ImageTableMap::COL_IMAGEABLE_TYPE, $this->imageable_type);

}

if ($this->isColumnModified(ImageTableMap::COL_PATH)) {

$criteria->add(ImageTableMap::COL_PATH, $this->path);

}

return $criteria;

}

/**

public function buildPkeyCriteria() : Criteria

{

$criteria = ChildImageQuery::create();

$criteria->add(ImageTableMap::COL_IMAGEID, $this->imageid);

return $criteria;

}

/**

public function clear()

{

$this->imageid = null;

$this->imageableid = null;

$this->imageable_type = null;

$this->path = 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->setImageableid($this->getImageableid());

$copyObj->setImageableType($this->getImageableType());

$copyObj->setPath($this->getPath());

if ($makeNew) {

$copyObj->setNew(true);

$copyObj->setImageid(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(ImageTableMap::DATABASE_NAME);

}

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

$deleteQuery = ChildImageQuery::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 = ImageTableMap::getFieldNames($keyType);

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

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

}

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

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

}

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

$this->setImageableType($arr[$keys[2]]);

}

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

$this->setPath($arr[$keys[3]]);

}

return $this;

}

/**

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

{

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

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

return $field;

}

/**

public function getByPosition(int $pos)

{

switch ($pos) {

case 0:

return $this->getImageid();

case 1:

return $this->getImageableid();

case 2:

return $this->getImageableType();

case 3:

return $this->getPath();

default:

return;

} // switch()

}

/**

public function getImageableid()

{

return $this->imageableid;

}

/**

public function getImageableType()

{

return $this->imageable_type;

}

/**

public function getImageid()

{

return $this->imageid;

}

/**

public function getModifiedColumns() : array

{

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

}

/**

public function getPath()

{

return $this->path;

}

/**

public function getPrimaryKey()

{

return $this->getImageid();

}

/**

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->getImageid();

$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 : ImageTableMap::translateFieldName('Imageid', TableMap::TYPE_PHPNAME, $indexType)];

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

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

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 2 + $startcol : ImageTableMap::translateFieldName('ImageableType', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 3 + $startcol : ImageTableMap::translateFieldName('Path', TableMap::TYPE_PHPNAME, $indexType)];

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

$this->resetModified();

$this->setNew(false);

if ($rehydrate) {

$this->ensureConsistency();

}

return $startcol + 4; // 4 = ImageTableMap::NUM_HYDRATE_COLUMNS.

} catch (Exception $e) {

throw new PropelException(\sprintf('Error populating %s object', '\\SOB\\Propel2\\Image'), 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->getImageid();

}

/**

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(ImageTableMap::DATABASE_NAME);

}

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

// already in the pool.

$dataFetcher = ChildImageQuery::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(ImageTableMap::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);

ImageTableMap::addInstanceToPool($this);

} else {

$affectedRows = 0;

}

return $affectedRows;

});

}

/**

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

{

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

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

return $this;

}

/**

public function setByPosition(int $pos, $value)

{

switch ($pos) {

case 0:

$this->setImageid($value);

break;

case 1:

$this->setImageableid($value);

break;

case 2:

$this->setImageableType($value);

break;

case 3:

$this->setPath($value);

break;

} // switch()

return $this;

}

/**

public function setDeleted(bool $b) : void

{

$this->deleted = $b;

}

/**

public function setImageableid($v)

{

if (null !== $v) {

$v = (int)$v;

}

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

$this->imageableid = $v;

$this->modifiedColumns[ImageTableMap::COL_IMAGEABLEID] = true;

}

return $this;

}

/**