{

/**

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

/**

protected $alreadyInSave = false;

/**

protected $attachments;

/**

protected $category;

/**

protected $deleted = false;

/**

protected $description;

/**

protected $discontinued;

/**

protected $list_price;

/**

protected $minimum_reorder_quantity;

/**

protected $modifiedColumns = [];

/**

protected $new = true;

/**

protected $product_code;

/**

protected $product_id;

/**

protected $product_name;

/**

protected $quantity_per_unit;

/**

protected $reorder_level;

/**

protected $standard_cost;

/**

protected $target_level;

/**

protected $virtualColumns = [];

/**

public function __construct()

{

$this->applyDefaultValues();

}

/**

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

}

/**

public function applyDefaultValues() : void

{

$this->standard_cost = '0.0000';

$this->list_price = '0.0000';

$this->discontinued = 0;

}

/**

public function buildCriteria() : Criteria

{

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

if ($this->isColumnModified(ProductTableMap::COL_PRODUCT_ID)) {

$criteria->add(ProductTableMap::COL_PRODUCT_ID, $this->product_id);

}

if ($this->isColumnModified(ProductTableMap::COL_PRODUCT_CODE)) {

$criteria->add(ProductTableMap::COL_PRODUCT_CODE, $this->product_code);

}

if ($this->isColumnModified(ProductTableMap::COL_PRODUCT_NAME)) {

$criteria->add(ProductTableMap::COL_PRODUCT_NAME, $this->product_name);

}

if ($this->isColumnModified(ProductTableMap::COL_DESCRIPTION)) {

$criteria->add(ProductTableMap::COL_DESCRIPTION, $this->description);

}

if ($this->isColumnModified(ProductTableMap::COL_STANDARD_COST)) {

$criteria->add(ProductTableMap::COL_STANDARD_COST, $this->standard_cost);

}

if ($this->isColumnModified(ProductTableMap::COL_LIST_PRICE)) {

$criteria->add(ProductTableMap::COL_LIST_PRICE, $this->list_price);

}

if ($this->isColumnModified(ProductTableMap::COL_REORDER_LEVEL)) {

$criteria->add(ProductTableMap::COL_REORDER_LEVEL, $this->reorder_level);

}

if ($this->isColumnModified(ProductTableMap::COL_TARGET_LEVEL)) {

$criteria->add(ProductTableMap::COL_TARGET_LEVEL, $this->target_level);

}

if ($this->isColumnModified(ProductTableMap::COL_QUANTITY_PER_UNIT)) {

$criteria->add(ProductTableMap::COL_QUANTITY_PER_UNIT, $this->quantity_per_unit);

}

if ($this->isColumnModified(ProductTableMap::COL_DISCONTINUED)) {

$criteria->add(ProductTableMap::COL_DISCONTINUED, $this->discontinued);

}

if ($this->isColumnModified(ProductTableMap::COL_MINIMUM_REORDER_QUANTITY)) {

$criteria->add(ProductTableMap::COL_MINIMUM_REORDER_QUANTITY, $this->minimum_reorder_quantity);

}

if ($this->isColumnModified(ProductTableMap::COL_CATEGORY)) {

$criteria->add(ProductTableMap::COL_CATEGORY, $this->category);

}

if ($this->isColumnModified(ProductTableMap::COL_ATTACHMENTS)) {

$criteria->add(ProductTableMap::COL_ATTACHMENTS, $this->attachments);

}

return $criteria;

}

/**

public function buildPkeyCriteria() : Criteria

{

$criteria = ChildProductQuery::create();

$criteria->add(ProductTableMap::COL_PRODUCT_ID, $this->product_id);

return $criteria;

}

/**

public function clear()

{

$this->product_id = null;

$this->product_code = null;

$this->product_name = null;

$this->description = null;

$this->standard_cost = null;

$this->list_price = null;

$this->reorder_level = null;

$this->target_level = null;

$this->quantity_per_unit = null;

$this->discontinued = null;

$this->minimum_reorder_quantity = null;

$this->category = null;

$this->attachments = null;

$this->alreadyInSave = false;

$this->clearAllReferences();

$this->applyDefaultValues();

$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->setProductCode($this->getProductCode());

$copyObj->setProductName($this->getProductName());

$copyObj->setDescription($this->getDescription());

$copyObj->setStandardCost($this->getStandardCost());

$copyObj->setListPrice($this->getListPrice());

$copyObj->setReorderLevel($this->getReorderLevel());

$copyObj->setTargetLevel($this->getTargetLevel());

$copyObj->setQuantityPerUnit($this->getQuantityPerUnit());

$copyObj->setDiscontinued($this->getDiscontinued());

$copyObj->setMinimumReorderQuantity($this->getMinimumReorderQuantity());

$copyObj->setCategory($this->getCategory());

$copyObj->setAttachments($this->getAttachments());

if ($makeNew) {

$copyObj->setNew(true);

$copyObj->setProductId(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(ProductTableMap::DATABASE_NAME);

}

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

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

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

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

}

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

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

}

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

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

}

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

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

}

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

$this->setStandardCost($arr[$keys[4]]);

}

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

$this->setListPrice($arr[$keys[5]]);

}

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

$this->setReorderLevel($arr[$keys[6]]);

}

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

$this->setTargetLevel($arr[$keys[7]]);

}

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

$this->setQuantityPerUnit($arr[$keys[8]]);

}

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

$this->setDiscontinued($arr[$keys[9]]);

}

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

$this->setMinimumReorderQuantity($arr[$keys[10]]);

}

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

$this->setCategory($arr[$keys[11]]);

}

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

$this->setAttachments($arr[$keys[12]]);

}

return $this;

}

/**

public function getAttachments()

{

return $this->attachments;

}

/**

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

{

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

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

return $field;

}

/**

public function getByPosition(int $pos)

{

switch ($pos) {

case 0:

return $this->getProductId();

case 1:

return $this->getProductCode();

case 2:

return $this->getProductName();

case 3:

return $this->getDescription();

case 4:

return $this->getStandardCost();

case 5:

return $this->getListPrice();

case 6:

return $this->getReorderLevel();

case 7:

return $this->getTargetLevel();

case 8:

return $this->getQuantityPerUnit();

case 9:

return $this->getDiscontinued();

case 10:

return $this->getMinimumReorderQuantity();

case 11:

return $this->getCategory();

case 12:

return $this->getAttachments();

default:

return;

} // switch()

}

/**

public function getCategory()

{

return $this->category;

}

/**

public function getDescription()

{

return $this->description;

}

/**

public function getDiscontinued()

{

return $this->discontinued;

}

/**

public function getListPrice()

{

return $this->list_price;

}

/**

public function getMinimumReorderQuantity()

{

return $this->minimum_reorder_quantity;

}

/**

public function getModifiedColumns() : array

{

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

}

/**

public function getPrimaryKey()

{

return $this->getProductId();

}

/**

public function getProductCode()

{

return $this->product_code;

}

/**

public function getProductId()

{

return $this->product_id;

}

/**

public function getProductName()

{

return $this->product_name;

}

/**

public function getQuantityPerUnit()

{

return $this->quantity_per_unit;

}

/**

public function getReorderLevel()

{

return $this->reorder_level;

}

/**

public function getStandardCost()

{

return $this->standard_cost;

}

/**

public function getTargetLevel()

{

return $this->target_level;

}

/**

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

$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

{

if ('0.0000' !== $this->standard_cost) {

return false;

}

if ('0.0000' !== $this->list_price) {

return false;

}

return ! (0 !== $this->discontinued);

// otherwise, everything was equal, so 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 : ProductTableMap::translateFieldName('ProductId', TableMap::TYPE_PHPNAME, $indexType)];

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

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

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

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

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

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

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 4 + $startcol : ProductTableMap::translateFieldName('StandardCost', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 5 + $startcol : ProductTableMap::translateFieldName('ListPrice', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 6 + $startcol : ProductTableMap::translateFieldName('ReorderLevel', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 7 + $startcol : ProductTableMap::translateFieldName('TargetLevel', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 8 + $startcol : ProductTableMap::translateFieldName('QuantityPerUnit', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 9 + $startcol : ProductTableMap::translateFieldName('Discontinued', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 10 + $startcol : ProductTableMap::translateFieldName('MinimumReorderQuantity', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 11 + $startcol : ProductTableMap::translateFieldName('Category', TableMap::TYPE_PHPNAME, $indexType)];

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

$col = $row[TableMap::TYPE_NUM == $indexType ? 12 + $startcol : ProductTableMap::translateFieldName('Attachments', TableMap::TYPE_PHPNAME, $indexType)];

if (null !== $col) {

$this->attachments = \fopen('php://memory', 'r+');

\fwrite($this->attachments, $col);

\rewind($this->attachments);

} else {

$this->attachments = null;

}

$this->resetModified();

$this->setNew(false);

if ($rehydrate) {

$this->ensureConsistency();

}

return $startcol + 13; // 13 = ProductTableMap::NUM_HYDRATE_COLUMNS.

} catch (Exception $e) {

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

}

}