{

/**

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

/**

protected $alreadyInSave = false;

/**

protected $amount_due;

/**

protected $deleted = false;

/**

protected $due_date;

/**

protected $invoice_date;

/**

protected $invoice_id;

/**

protected $modifiedColumns = [];

/**

protected $new = true;

/**

protected $order_id;

/**

protected $shipping;

/**

protected $tax;

/**

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

}

/**

public function applyDefaultValues() : void

{

$this->tax = '0.0000';

$this->shipping = '0.0000';

$this->amount_due = '0.0000';

}

/**

public function buildCriteria() : Criteria

{

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

if ($this->isColumnModified(InvoiceTableMap::COL_INVOICE_ID)) {

$criteria->add(InvoiceTableMap::COL_INVOICE_ID, $this->invoice_id);

}

if ($this->isColumnModified(InvoiceTableMap::COL_ORDER_ID)) {

$criteria->add(InvoiceTableMap::COL_ORDER_ID, $this->order_id);

}

if ($this->isColumnModified(InvoiceTableMap::COL_INVOICE_DATE)) {

$criteria->add(InvoiceTableMap::COL_INVOICE_DATE, $this->invoice_date);

}

if ($this->isColumnModified(InvoiceTableMap::COL_DUE_DATE)) {

$criteria->add(InvoiceTableMap::COL_DUE_DATE, $this->due_date);

}

if ($this->isColumnModified(InvoiceTableMap::COL_TAX)) {

$criteria->add(InvoiceTableMap::COL_TAX, $this->tax);

}

if ($this->isColumnModified(InvoiceTableMap::COL_SHIPPING)) {

$criteria->add(InvoiceTableMap::COL_SHIPPING, $this->shipping);

}

if ($this->isColumnModified(InvoiceTableMap::COL_AMOUNT_DUE)) {

$criteria->add(InvoiceTableMap::COL_AMOUNT_DUE, $this->amount_due);

}

return $criteria;

}

/**

public function buildPkeyCriteria() : Criteria

{

$criteria = ChildInvoiceQuery::create();

$criteria->add(InvoiceTableMap::COL_INVOICE_ID, $this->invoice_id);

return $criteria;

}

/**

public function clear()

{

$this->invoice_id = null;

$this->order_id = null;

$this->invoice_date = null;

$this->due_date = null;

$this->tax = null;

$this->shipping = null;

$this->amount_due = 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->setOrderId($this->getOrderId());

$copyObj->setInvoiceDate($this->getInvoiceDate());

$copyObj->setDueDate($this->getDueDate());

$copyObj->setTax($this->getTax());

$copyObj->setShipping($this->getShipping());

$copyObj->setAmountDue($this->getAmountDue());

if ($makeNew) {

$copyObj->setNew(true);

$copyObj->setInvoiceId(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(InvoiceTableMap::DATABASE_NAME);

}

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

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

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

return $this;

}

/**

public function getAmountDue()

{

return $this->amount_due;

}

/**

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

{

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

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

return $field;

}

/**

public function getByPosition(int $pos)

{

switch ($pos) {

case 0:

return $this->getInvoiceId();

case 1:

return $this->getOrderId();

case 2:

return $this->getInvoiceDate();

case 3:

return $this->getDueDate();

case 4:

return $this->getTax();

case 5:

return $this->getShipping();

case 6:

return $this->getAmountDue();

default:

return;

} // switch()

}

/**

public function getDueDate($format = null)

{

if (null === $format) {

return $this->due_date;

}

return $this->due_date instanceof \DateTimeInterface ? $this->due_date->format($format) : null;

}

/**

public function getInvoiceDate($format = null)

{

if (null === $format) {

return $this->invoice_date;

}

return $this->invoice_date instanceof \DateTimeInterface ? $this->invoice_date->format($format) : null;

}

/**

public function getInvoiceId()

{

return $this->invoice_id;

}

/**

public function getModifiedColumns() : array

{

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

}

/**

public function getOrderId()

{

return $this->order_id;

}

/**

public function getPrimaryKey()

{

return $this->getInvoiceId();

}

/**

public function getShipping()

{

return $this->shipping;

}

/**

public function getTax()

{

return $this->tax;

}

/**

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

$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->tax) {

return false;

}

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

return false;

}

return ! ('0.0000' !== $this->amount_due);

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

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

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

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

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

if ('0000-00-00 00:00:00' === $col) {

$col = null;

}

$this->invoice_date = (null !== $col) ? PropelDateTime::newInstance($col, null, 'DateTime') : null;

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

if ('0000-00-00 00:00:00' === $col) {

$col = null;

}

$this->due_date = (null !== $col) ? PropelDateTime::newInstance($col, null, 'DateTime') : null;

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

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

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

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

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

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

$this->resetModified();

$this->setNew(false);

if ($rehydrate) {

$this->ensureConsistency();

}

return $startcol + 7; // 7 = InvoiceTableMap::NUM_HYDRATE_COLUMNS.

} catch (Exception $e) {

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

}

/**

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

}

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

// already in the pool.

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