       1: <?php
       2:
       3: namespace Thelia\Model\om;
       4:
       5: use \BaseObject;
       6: use \BasePeer;
       7: use \Criteria;
       8: use \DateTime;
       9: use \Exception;
      10: use \PDO;
      11: use \Persistent;
      12: use \Propel;
      13: use \PropelDateTime;
      14: use \PropelException;
      15: use \PropelPDO;
      16: use Thelia\Model\Combination;
      17: use Thelia\Model\CombinationQuery;
      18: use Thelia\Model\Product;
      19: use Thelia\Model\ProductQuery;
      20: use Thelia\Model\Stock;
      21: use Thelia\Model\StockPeer;
      22: use Thelia\Model\StockQuery;
      23:
      24: /**
      25:  * Base class that represents a row from the 'stock' table.
      26:  *
      27:  *
      28:  *
      29:  * @package    propel.generator.Thelia.Model.om
      30:  */
      31: abstract class BaseStock extends BaseObject implements Persistent
      32: {
      33:     /**
      34:      * Peer class name
      35:      */
      36:     const PEER = 'Thelia\\Model\\StockPeer';
      37:
      38:     /**
      39:      * The Peer class.
      40:      * Instance provides a convenient way of calling static methods on a class
      41:      * that calling code may not be able to identify.
      42:      * @var        StockPeer
      43:      */
      44:     protected static $peer;
      45:
      46:     /**
      47:      * The flag var to prevent infinit loop in deep copy
      48:      * @var       boolean
      49:      */
      50:     protected $startCopy = false;
      51:
      52:     /**
      53:      * The value for the id field.
      54:      * @var        int
      55:      */
      56:     protected $id;
      57:
      58:     /**
      59:      * The value for the combination_id field.
      60:      * @var        int
      61:      */
      62:     protected $combination_id;
      63:
      64:     /**
      65:      * The value for the product_id field.
      66:      * @var        int
      67:      */
      68:     protected $product_id;
      69:
      70:     /**
      71:      * The value for the increase field.
      72:      * @var        double
      73:      */
      74:     protected $increase;
      75:
      76:     /**
      77:      * The value for the value field.
      78:      * @var        double
      79:      */
      80:     protected $value;
      81:
      82:     /**
      83:      * The value for the created_at field.
      84:      * @var        string
      85:      */
      86:     protected $created_at;
      87:
      88:     /**
      89:      * The value for the updated_at field.
      90:      * @var        string
      91:      */
      92:     protected $updated_at;
      93:
      94:     /**
      95:      * @var        Combination
      96:      */
      97:     protected $aCombination;
      98:
      99:     /**
     100:      * @var        Product
     101:      */
     102:     protected $aProduct;
     103:
     104:     /**
     105:      * Flag to prevent endless save loop, if this object is referenced
     106:      * by another object which falls in this transaction.
     107:      * @var        boolean
     108:      */
     109:     protected $alreadyInSave = false;
     110:
     111:     /**
     112:      * Flag to prevent endless validation loop, if this object is referenced
     113:      * by another object which falls in this transaction.
     114:      * @var        boolean
     115:      */
     116:     protected $alreadyInValidation = false;
     117:
     118:     /**
     119:      * Flag to prevent endless clearAllReferences($deep=true) loop, if this object is referenced
     120:      * @var        boolean
     121:      */
     122:     protected $alreadyInClearAllReferencesDeep = false;
     123:
     124:     /**
     125:      * Get the [id] column value.
     126:      *
     127:      * @return int
     128:      */
     129:     public function getId()
     130:     {
     131:         return $this->id;
     132:     }
     133:
     134:     /**
     135:      * Get the [combination_id] column value.
     136:      *
     137:      * @return int
     138:      */
     139:     public function getCombinationId()
     140:     {
     141:         return $this->combination_id;
     142:     }
     143:
     144:     /**
     145:      * Get the [product_id] column value.
     146:      *
     147:      * @return int
     148:      */
     149:     public function getProductId()
     150:     {
     151:         return $this->product_id;
     152:     }
     153:
     154:     /**
     155:      * Get the [increase] column value.
     156:      *
     157:      * @return double
     158:      */
     159:     public function getIncrease()
     160:     {
     161:         return $this->increase;
     162:     }
     163:
     164:     /**
     165:      * Get the [value] column value.
     166:      *
     167:      * @return double
     168:      */
     169:     public function getValue()
     170:     {
     171:         return $this->value;
     172:     }
     173:
     174:     /**
     175:      * Get the [optionally formatted] temporal [created_at] column value.
     176:      *
     177:      *
     178:      * @param string $format The date/time format string (either date()-style or strftime()-style).
     179:      *               If format is null, then the raw DateTime object will be returned.
     180:      * @return mixed Formatted date/time value as string or DateTime object (if format is null), null if column is null, and 0 if column value is 0000-00-00 00:00:00
     181:      * @throws PropelException - if unable to parse/validate the date/time value.
     182:      */
     183:     public function getCreatedAt($format = 'Y-m-d H:i:s')
     184:     {
     185:         if ($this->created_at === null) {
     186:             return null;
     187:         }
     188:
     189:         if ($this->created_at === '0000-00-00 00:00:00') {
     190:             // while technically this is not a default value of null,
     191:             // this seems to be closest in meaning.
     192:             return null;
     193:         }
     194:
     195:         try {
     196:             $dt = new DateTime($this->created_at);
     197:         } catch (Exception $x) {
     198:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
     199:         }
     200:
     201:         if ($format === null) {
     202:             // Because propel.useDateTimeClass is true, we return a DateTime object.
     203:             return $dt;
     204:         }
     205:
     206:         if (strpos($format, '%') !== false) {
     207:             return strftime($format, $dt->format('U'));
     208:         }
     209:
     210:         return $dt->format($format);
     211:
     212:     }
     213:
     214:     /**
     215:      * Get the [optionally formatted] temporal [updated_at] column value.
     216:      *
     217:      *
     218:      * @param string $format The date/time format string (either date()-style or strftime()-style).
     219:      *               If format is null, then the raw DateTime object will be returned.
     220:      * @return mixed Formatted date/time value as string or DateTime object (if format is null), null if column is null, and 0 if column value is 0000-00-00 00:00:00
     221:      * @throws PropelException - if unable to parse/validate the date/time value.
     222:      */
     223:     public function getUpdatedAt($format = 'Y-m-d H:i:s')
     224:     {
     225:         if ($this->updated_at === null) {
     226:             return null;
     227:         }
     228:
     229:         if ($this->updated_at === '0000-00-00 00:00:00') {
     230:             // while technically this is not a default value of null,
     231:             // this seems to be closest in meaning.
     232:             return null;
     233:         }
     234:
     235:         try {
     236:             $dt = new DateTime($this->updated_at);
     237:         } catch (Exception $x) {
     238:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
     239:         }
     240:
     241:         if ($format === null) {
     242:             // Because propel.useDateTimeClass is true, we return a DateTime object.
     243:             return $dt;
     244:         }
     245:
     246:         if (strpos($format, '%') !== false) {
     247:             return strftime($format, $dt->format('U'));
     248:         }
     249:
     250:         return $dt->format($format);
     251:
     252:     }
     253:
     254:     /**
     255:      * Set the value of [id] column.
     256:      *
     257:      * @param int $v new value
     258:      * @return Stock The current object (for fluent API support)
     259:      */
     260:     public function setId($v)
     261:     {
     262:         if ($v !== null && is_numeric($v)) {
     263:             $v = (int) $v;
     264:         }
     265:
     266:         if ($this->id !== $v) {
     267:             $this->id = $v;
     268:             $this->modifiedColumns[] = StockPeer::ID;
     269:         }
     270:
     271:
     272:         return $this;
     273:     } // setId()
     274:
     275:     /**
     276:      * Set the value of [combination_id] column.
     277:      *
     278:      * @param int $v new value
     279:      * @return Stock The current object (for fluent API support)
     280:      */
     281:     public function setCombinationId($v)
     282:     {
     283:         if ($v !== null && is_numeric($v)) {
     284:             $v = (int) $v;
     285:         }
     286:
     287:         if ($this->combination_id !== $v) {
     288:             $this->combination_id = $v;
     289:             $this->modifiedColumns[] = StockPeer::COMBINATION_ID;
     290:         }
     291:
     292:         if ($this->aCombination !== null && $this->aCombination->getId() !== $v) {
     293:             $this->aCombination = null;
     294:         }
     295:
     296:
     297:         return $this;
     298:     } // setCombinationId()
     299:
     300:     /**
     301:      * Set the value of [product_id] column.
     302:      *
     303:      * @param int $v new value
     304:      * @return Stock The current object (for fluent API support)
     305:      */
     306:     public function setProductId($v)
     307:     {
     308:         if ($v !== null && is_numeric($v)) {
     309:             $v = (int) $v;
     310:         }
     311:
     312:         if ($this->product_id !== $v) {
     313:             $this->product_id = $v;
     314:             $this->modifiedColumns[] = StockPeer::PRODUCT_ID;
     315:         }
     316:
     317:         if ($this->aProduct !== null && $this->aProduct->getId() !== $v) {
     318:             $this->aProduct = null;
     319:         }
     320:
     321:
     322:         return $this;
     323:     } // setProductId()
     324:
     325:     /**
     326:      * Set the value of [increase] column.
     327:      *
     328:      * @param double $v new value
     329:      * @return Stock The current object (for fluent API support)
     330:      */
     331:     public function setIncrease($v)
     332:     {
     333:         if ($v !== null && is_numeric($v)) {
     334:             $v = (double) $v;
     335:         }
     336:
     337:         if ($this->increase !== $v) {
     338:             $this->increase = $v;
     339:             $this->modifiedColumns[] = StockPeer::INCREASE;
     340:         }
     341:
     342:
     343:         return $this;
     344:     } // setIncrease()
     345:
     346:     /**
     347:      * Set the value of [value] column.
     348:      *
     349:      * @param double $v new value
     350:      * @return Stock The current object (for fluent API support)
     351:      */
     352:     public function setValue($v)
     353:     {
     354:         if ($v !== null && is_numeric($v)) {
     355:             $v = (double) $v;
     356:         }
     357:
     358:         if ($this->value !== $v) {
     359:             $this->value = $v;
     360:             $this->modifiedColumns[] = StockPeer::VALUE;
     361:         }
     362:
     363:
     364:         return $this;
     365:     } // setValue()
     366:
     367:     /**
     368:      * Sets the value of [created_at] column to a normalized version of the date/time value specified.
     369:      *
     370:      * @param mixed $v string, integer (timestamp), or DateTime value.
     371:      *               Empty strings are treated as null.
     372:      * @return Stock The current object (for fluent API support)
     373:      */
     374:     public function setCreatedAt($v)
     375:     {
     376:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
     377:         if ($this->created_at !== null || $dt !== null) {
     378:             $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
     379:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
     380:             if ($currentDateAsString !== $newDateAsString) {
     381:                 $this->created_at = $newDateAsString;
     382:                 $this->modifiedColumns[] = StockPeer::CREATED_AT;
     383:             }
     384:         } // if either are not null
     385:
     386:
     387:         return $this;
     388:     } // setCreatedAt()
     389:
     390:     /**
     391:      * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
     392:      *
     393:      * @param mixed $v string, integer (timestamp), or DateTime value.
     394:      *               Empty strings are treated as null.
     395:      * @return Stock The current object (for fluent API support)
     396:      */
     397:     public function setUpdatedAt($v)
     398:     {
     399:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
     400:         if ($this->updated_at !== null || $dt !== null) {
     401:             $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
     402:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
     403:             if ($currentDateAsString !== $newDateAsString) {
     404:                 $this->updated_at = $newDateAsString;
     405:                 $this->modifiedColumns[] = StockPeer::UPDATED_AT;
     406:             }
     407:         } // if either are not null
     408:
     409:
     410:         return $this;
     411:     } // setUpdatedAt()
     412:
     413:     /**
     414:      * Indicates whether the columns in this object are only set to default values.
     415:      *
     416:      * This method can be used in conjunction with isModified() to indicate whether an object is both
     417:      * modified _and_ has some values set which are non-default.
     418:      *
     419:      * @return boolean Whether the columns in this object are only been set with default values.
     420:      */
     421:     public function hasOnlyDefaultValues()
     422:     {
     423:         // otherwise, everything was equal, so return true
     424:         return true;
     425:     } // hasOnlyDefaultValues()
     426:
     427:     /**
     428:      * Hydrates (populates) the object variables with values from the database resultset.
     429:      *
     430:      * An offset (0-based "start column") is specified so that objects can be hydrated
     431:      * with a subset of the columns in the resultset rows.  This is needed, for example,
     432:      * for results of JOIN queries where the resultset row includes columns from two or
     433:      * more tables.
     434:      *
     435:      * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
     436:      * @param int $startcol 0-based offset column which indicates which restultset column to start with.
     437:      * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
     438:      * @return int             next starting column
     439:      * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
     440:      */
     441:     public function hydrate($row, $startcol = 0, $rehydrate = false)
     442:     {
     443:         try {
     444:
     445:             $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
     446:             $this->combination_id = ($row[$startcol + 1] !== null) ? (int) $row[$startcol + 1] : null;
     447:             $this->product_id = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
     448:             $this->increase = ($row[$startcol + 3] !== null) ? (double) $row[$startcol + 3] : null;
     449:             $this->value = ($row[$startcol + 4] !== null) ? (double) $row[$startcol + 4] : null;
     450:             $this->created_at = ($row[$startcol + 5] !== null) ? (string) $row[$startcol + 5] : null;
     451:             $this->updated_at = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
     452:             $this->resetModified();
     453:
     454:             $this->setNew(false);
     455:
     456:             if ($rehydrate) {
     457:                 $this->ensureConsistency();
     458:             }
     459:             $this->postHydrate($row, $startcol, $rehydrate);
     460:             return $startcol + 7; // 7 = StockPeer::NUM_HYDRATE_COLUMNS.
     461:
     462:         } catch (Exception $e) {
     463:             throw new PropelException("Error populating Stock object", $e);
     464:         }
     465:     }
     466:
     467:     /**
     468:      * Checks and repairs the internal consistency of the object.
     469:      *
     470:      * This method is executed after an already-instantiated object is re-hydrated
     471:      * from the database.  It exists to check any foreign keys to make sure that
     472:      * the objects related to the current object are correct based on foreign key.
     473:      *
     474:      * You can override this method in the stub class, but you should always invoke
     475:      * the base method from the overridden method (i.e. parent::ensureConsistency()),
     476:      * in case your model changes.
     477:      *
     478:      * @throws PropelException
     479:      */
     480:     public function ensureConsistency()
     481:     {
     482:
     483:         if ($this->aCombination !== null && $this->combination_id !== $this->aCombination->getId()) {
     484:             $this->aCombination = null;
     485:         }
     486:         if ($this->aProduct !== null && $this->product_id !== $this->aProduct->getId()) {
     487:             $this->aProduct = null;
     488:         }
     489:     } // ensureConsistency
     490:
     491:     /**
     492:      * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
     493:      *
     494:      * This will only work if the object has been saved and has a valid primary key set.
     495:      *
     496:      * @param boolean $deep (optional) Whether to also de-associated any related objects.
     497:      * @param PropelPDO $con (optional) The PropelPDO connection to use.
     498:      * @return void
     499:      * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
     500:      */
     501:     public function reload($deep = false, PropelPDO $con = null)
     502:     {
     503:         if ($this->isDeleted()) {
     504:             throw new PropelException("Cannot reload a deleted object.");
     505:         }
     506:
     507:         if ($this->isNew()) {
     508:             throw new PropelException("Cannot reload an unsaved object.");
     509:         }
     510:
     511:         if ($con === null) {
     512:             $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     513:         }
     514:
     515:         // We don't need to alter the object instance pool; we're just modifying this instance
     516:         // already in the pool.
     517:
     518:         $stmt = StockPeer::doSelectStmt($this->buildPkeyCriteria(), $con);
     519:         $row = $stmt->fetch(PDO::FETCH_NUM);
     520:         $stmt->closeCursor();
     521:         if (!$row) {
     522:             throw new PropelException('Cannot find matching row in the database to reload object values.');
     523:         }
     524:         $this->hydrate($row, 0, true); // rehydrate
     525:
     526:         if ($deep) {  // also de-associate any related objects?
     527:
     528:             $this->aCombination = null;
     529:             $this->aProduct = null;
     530:         } // if (deep)
     531:     }
     532:
     533:     /**
     534:      * Removes this object from datastore and sets delete attribute.
     535:      *
     536:      * @param PropelPDO $con
     537:      * @return void
     538:      * @throws PropelException
     539:      * @throws Exception
     540:      * @see        BaseObject::setDeleted()
     541:      * @see        BaseObject::isDeleted()
     542:      */
     543:     public function delete(PropelPDO $con = null)
     544:     {
     545:         if ($this->isDeleted()) {
     546:             throw new PropelException("This object has already been deleted.");
     547:         }
     548:
     549:         if ($con === null) {
     550:             $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     551:         }
     552:
     553:         $con->beginTransaction();
     554:         try {
     555:             $deleteQuery = StockQuery::create()
     556:                 ->filterByPrimaryKey($this->getPrimaryKey());
     557:             $ret = $this->preDelete($con);
     558:             if ($ret) {
     559:                 $deleteQuery->delete($con);
     560:                 $this->postDelete($con);
     561:                 $con->commit();
     562:                 $this->setDeleted(true);
     563:             } else {
     564:                 $con->commit();
     565:             }
     566:         } catch (Exception $e) {
     567:             $con->rollBack();
     568:             throw $e;
     569:         }
     570:     }
     571:
     572:     /**
     573:      * Persists this object to the database.
     574:      *
     575:      * If the object is new, it inserts it; otherwise an update is performed.
     576:      * All modified related objects will also be persisted in the doSave()
     577:      * method.  This method wraps all precipitate database operations in a
     578:      * single transaction.
     579:      *
     580:      * @param PropelPDO $con
     581:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
     582:      * @throws PropelException
     583:      * @throws Exception
     584:      * @see        doSave()
     585:      */
     586:     public function save(PropelPDO $con = null)
     587:     {
     588:         if ($this->isDeleted()) {
     589:             throw new PropelException("You cannot save an object that has been deleted.");
     590:         }
     591:
     592:         if ($con === null) {
     593:             $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     594:         }
     595:
     596:         $con->beginTransaction();
     597:         $isInsert = $this->isNew();
     598:         try {
     599:             $ret = $this->preSave($con);
     600:             if ($isInsert) {
     601:                 $ret = $ret && $this->preInsert($con);
     602:                 // timestampable behavior
     603:                 if (!$this->isColumnModified(StockPeer::CREATED_AT)) {
     604:                     $this->setCreatedAt(time());
     605:                 }
     606:                 if (!$this->isColumnModified(StockPeer::UPDATED_AT)) {
     607:                     $this->setUpdatedAt(time());
     608:                 }
     609:             } else {
     610:                 $ret = $ret && $this->preUpdate($con);
     611:                 // timestampable behavior
     612:                 if ($this->isModified() && !$this->isColumnModified(StockPeer::UPDATED_AT)) {
     613:                     $this->setUpdatedAt(time());
     614:                 }
     615:             }
     616:             if ($ret) {
     617:                 $affectedRows = $this->doSave($con);
     618:                 if ($isInsert) {
     619:                     $this->postInsert($con);
     620:                 } else {
     621:                     $this->postUpdate($con);
     622:                 }
     623:                 $this->postSave($con);
     624:                 StockPeer::addInstanceToPool($this);
     625:             } else {
     626:                 $affectedRows = 0;
     627:             }
     628:             $con->commit();
     629:
     630:             return $affectedRows;
     631:         } catch (Exception $e) {
     632:             $con->rollBack();
     633:             throw $e;
     634:         }
     635:     }
     636:
     637:     /**
     638:      * Performs the work of inserting or updating the row in the database.
     639:      *
     640:      * If the object is new, it inserts it; otherwise an update is performed.
     641:      * All related objects are also updated in this method.
     642:      *
     643:      * @param PropelPDO $con
     644:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
     645:      * @throws PropelException
     646:      * @see        save()
     647:      */
     648:     protected function doSave(PropelPDO $con)
     649:     {
     650:         $affectedRows = 0; // initialize var to track total num of affected rows
     651:         if (!$this->alreadyInSave) {
     652:             $this->alreadyInSave = true;
     653:
     654:             // We call the save method on the following object(s) if they
     655:             // were passed to this object by their coresponding set
     656:             // method.  This object relates to these object(s) by a
     657:             // foreign key reference.
     658:
     659:             if ($this->aCombination !== null) {
     660:                 if ($this->aCombination->isModified() || $this->aCombination->isNew()) {
     661:                     $affectedRows += $this->aCombination->save($con);
     662:                 }
     663:                 $this->setCombination($this->aCombination);
     664:             }
     665:
     666:             if ($this->aProduct !== null) {
     667:                 if ($this->aProduct->isModified() || $this->aProduct->isNew()) {
     668:                     $affectedRows += $this->aProduct->save($con);
     669:                 }
     670:                 $this->setProduct($this->aProduct);
     671:             }
     672:
     673:             if ($this->isNew() || $this->isModified()) {
     674:                 // persist changes
     675:                 if ($this->isNew()) {
     676:                     $this->doInsert($con);
     677:                 } else {
     678:                     $this->doUpdate($con);
     679:                 }
     680:                 $affectedRows += 1;
     681:                 $this->resetModified();
     682:             }
     683:
     684:             $this->alreadyInSave = false;
     685:
     686:         }
     687:
     688:         return $affectedRows;
     689:     } // doSave()
     690:
     691:     /**
     692:      * Insert the row in the database.
     693:      *
     694:      * @param PropelPDO $con
     695:      *
     696:      * @throws PropelException
     697:      * @see        doSave()
     698:      */
     699:     protected function doInsert(PropelPDO $con)
     700:     {
     701:         $modifiedColumns = array();
     702:         $index = 0;
     703:
     704:         $this->modifiedColumns[] = StockPeer::ID;
     705:         if (null !== $this->id) {
     706:             throw new PropelException('Cannot insert a value for auto-increment primary key (' . StockPeer::ID . ')');
     707:         }
     708:
     709:          // check the columns in natural order for more readable SQL queries
     710:         if ($this->isColumnModified(StockPeer::ID)) {
     711:             $modifiedColumns[':p' . $index++]  = '`id`';
     712:         }
     713:         if ($this->isColumnModified(StockPeer::COMBINATION_ID)) {
     714:             $modifiedColumns[':p' . $index++]  = '`combination_id`';
     715:         }
     716:         if ($this->isColumnModified(StockPeer::PRODUCT_ID)) {
     717:             $modifiedColumns[':p' . $index++]  = '`product_id`';
     718:         }
     719:         if ($this->isColumnModified(StockPeer::INCREASE)) {
     720:             $modifiedColumns[':p' . $index++]  = '`increase`';
     721:         }
     722:         if ($this->isColumnModified(StockPeer::VALUE)) {
     723:             $modifiedColumns[':p' . $index++]  = '`value`';
     724:         }
     725:         if ($this->isColumnModified(StockPeer::CREATED_AT)) {
     726:             $modifiedColumns[':p' . $index++]  = '`created_at`';
     727:         }
     728:         if ($this->isColumnModified(StockPeer::UPDATED_AT)) {
     729:             $modifiedColumns[':p' . $index++]  = '`updated_at`';
     730:         }
     731:
     732:         $sql = sprintf(
     733:             'INSERT INTO `stock` (%s) VALUES (%s)',
     734:             implode(', ', $modifiedColumns),
     735:             implode(', ', array_keys($modifiedColumns))
     736:         );
     737:
     738:         try {
     739:             $stmt = $con->prepare($sql);
     740:             foreach ($modifiedColumns as $identifier => $columnName) {
     741:                 switch ($columnName) {
     742:                     case '`id`':
     743:                         $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
     744:                         break;
     745:                     case '`combination_id`':
     746:                         $stmt->bindValue($identifier, $this->combination_id, PDO::PARAM_INT);
     747:                         break;
     748:                     case '`product_id`':
     749:                         $stmt->bindValue($identifier, $this->product_id, PDO::PARAM_INT);
     750:                         break;
     751:                     case '`increase`':
     752:                         $stmt->bindValue($identifier, $this->increase, PDO::PARAM_STR);
     753:                         break;
     754:                     case '`value`':
     755:                         $stmt->bindValue($identifier, $this->value, PDO::PARAM_STR);
     756:                         break;
     757:                     case '`created_at`':
     758:                         $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
     759:                         break;
     760:                     case '`updated_at`':
     761:                         $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
     762:                         break;
     763:                 }
     764:             }
     765:             $stmt->execute();
     766:         } catch (Exception $e) {
     767:             Propel::log($e->getMessage(), Propel::LOG_ERR);
     768:             throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
     769:         }
     770:
     771:         try {
     772:             $pk = $con->lastInsertId();
     773:         } catch (Exception $e) {
     774:             throw new PropelException('Unable to get autoincrement id.', $e);
     775:         }
     776:         $this->setId($pk);
     777:
     778:         $this->setNew(false);
     779:     }
     780:
     781:     /**
     782:      * Update the row in the database.
     783:      *
     784:      * @param PropelPDO $con
     785:      *
     786:      * @see        doSave()
     787:      */
     788:     protected function doUpdate(PropelPDO $con)
     789:     {
     790:         $selectCriteria = $this->buildPkeyCriteria();
     791:         $valuesCriteria = $this->buildCriteria();
     792:         BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
     793:     }
     794:
     795:     /**
     796:      * Array of ValidationFailed objects.
     797:      * @var        array ValidationFailed[]
     798:      */
     799:     protected $validationFailures = array();
     800:
     801:     /**
     802:      * Gets any ValidationFailed objects that resulted from last call to validate().
     803:      *
     804:      *
     805:      * @return array ValidationFailed[]
     806:      * @see        validate()
     807:      */
     808:     public function getValidationFailures()
     809:     {
     810:         return $this->validationFailures;
     811:     }
     812:
     813:     /**
     814:      * Validates the objects modified field values and all objects related to this table.
     815:      *
     816:      * If $columns is either a column name or an array of column names
     817:      * only those columns are validated.
     818:      *
     819:      * @param mixed $columns Column name or an array of column names.
     820:      * @return boolean Whether all columns pass validation.
     821:      * @see        doValidate()
     822:      * @see        getValidationFailures()
     823:      */
     824:     public function validate($columns = null)
     825:     {
     826:         $res = $this->doValidate($columns);
     827:         if ($res === true) {
     828:             $this->validationFailures = array();
     829:
     830:             return true;
     831:         }
     832:
     833:         $this->validationFailures = $res;
     834:
     835:         return false;
     836:     }
     837:
     838:     /**
     839:      * This function performs the validation work for complex object models.
     840:      *
     841:      * In addition to checking the current object, all related objects will
     842:      * also be validated.  If all pass then <code>true</code> is returned; otherwise
     843:      * an aggreagated array of ValidationFailed objects will be returned.
     844:      *
     845:      * @param array $columns Array of column names to validate.
     846:      * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
     847:      */
     848:     protected function doValidate($columns = null)
     849:     {
     850:         if (!$this->alreadyInValidation) {
     851:             $this->alreadyInValidation = true;
     852:             $retval = null;
     853:
     854:             $failureMap = array();
     855:
     856:
     857:             // We call the validate method on the following object(s) if they
     858:             // were passed to this object by their coresponding set
     859:             // method.  This object relates to these object(s) by a
     860:             // foreign key reference.
     861:
     862:             if ($this->aCombination !== null) {
     863:                 if (!$this->aCombination->validate($columns)) {
     864:                     $failureMap = array_merge($failureMap, $this->aCombination->getValidationFailures());
     865:                 }
     866:             }
     867:
     868:             if ($this->aProduct !== null) {
     869:                 if (!$this->aProduct->validate($columns)) {
     870:                     $failureMap = array_merge($failureMap, $this->aProduct->getValidationFailures());
     871:                 }
     872:             }
     873:
     874:
     875:             if (($retval = StockPeer::doValidate($this, $columns)) !== true) {
     876:                 $failureMap = array_merge($failureMap, $retval);
     877:             }
     878:
     879:
     880:
     881:             $this->alreadyInValidation = false;
     882:         }
     883:
     884:         return (!empty($failureMap) ? $failureMap : true);
     885:     }
     886:
     887:     /**
     888:      * Retrieves a field from the object by name passed in as a string.
     889:      *
     890:      * @param string $name name
     891:      * @param string $type The type of fieldname the $name is of:
     892:      *               one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
     893:      *               BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
     894:      *               Defaults to BasePeer::TYPE_PHPNAME
     895:      * @return mixed Value of field.
     896:      */
     897:     public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
     898:     {
     899:         $pos = StockPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
     900:         $field = $this->getByPosition($pos);
     901:
     902:         return $field;
     903:     }
     904:
     905:     /**
     906:      * Retrieves a field from the object by Position as specified in the xml schema.
     907:      * Zero-based.
     908:      *
     909:      * @param int $pos position in xml schema
     910:      * @return mixed Value of field at $pos
     911:      */
     912:     public function getByPosition($pos)
     913:     {
     914:         switch ($pos) {
     915:             case 0:
     916:                 return $this->getId();
     917:                 break;
     918:             case 1:
     919:                 return $this->getCombinationId();
     920:                 break;
     921:             case 2:
     922:                 return $this->getProductId();
     923:                 break;
     924:             case 3:
     925:                 return $this->getIncrease();
     926:                 break;
     927:             case 4:
     928:                 return $this->getValue();
     929:                 break;
     930:             case 5:
     931:                 return $this->getCreatedAt();
     932:                 break;
     933:             case 6:
     934:                 return $this->getUpdatedAt();
     935:                 break;
     936:             default:
     937:                 return null;
     938:                 break;
     939:         } // switch()
     940:     }
     941:
     942:     /**
     943:      * Exports the object as an array.
     944:      *
     945:      * You can specify the key type of the array by passing one of the class
     946:      * type constants.
     947:      *
     948:      * @param     string  $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
     949:      *                    BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
     950:      *                    Defaults to BasePeer::TYPE_PHPNAME.
     951:      * @param     boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
     952:      * @param     array $alreadyDumpedObjects List of objects to skip to avoid recursion
     953:      * @param     boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
     954:      *
     955:      * @return array an associative array containing the field names (as keys) and field values
     956:      */
     957:     public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
     958:     {
     959:         if (isset($alreadyDumpedObjects['Stock'][$this->getPrimaryKey()])) {
     960:             return '*RECURSION*';
     961:         }
     962:         $alreadyDumpedObjects['Stock'][$this->getPrimaryKey()] = true;
     963:         $keys = StockPeer::getFieldNames($keyType);
     964:         $result = array(
     965:             $keys[0] => $this->getId(),
     966:             $keys[1] => $this->getCombinationId(),
     967:             $keys[2] => $this->getProductId(),
     968:             $keys[3] => $this->getIncrease(),
     969:             $keys[4] => $this->getValue(),
     970:             $keys[5] => $this->getCreatedAt(),
     971:             $keys[6] => $this->getUpdatedAt(),
     972:         );
     973:         if ($includeForeignObjects) {
     974:             if (null !== $this->aCombination) {
     975:                 $result['Combination'] = $this->aCombination->toArray($keyType, $includeLazyLoadColumns,  $alreadyDumpedObjects, true);
     976:             }
     977:             if (null !== $this->aProduct) {
     978:                 $result['Product'] = $this->aProduct->toArray($keyType, $includeLazyLoadColumns,  $alreadyDumpedObjects, true);
     979:             }
     980:         }
     981:
     982:         return $result;
     983:     }
     984:
     985:     /**
     986:      * Sets a field from the object by name passed in as a string.
     987:      *
     988:      * @param string $name peer name
     989:      * @param mixed $value field value
     990:      * @param string $type The type of fieldname the $name is of:
     991:      *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
     992:      *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
     993:      *                     Defaults to BasePeer::TYPE_PHPNAME
     994:      * @return void
     995:      */
     996:     public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
     997:     {
     998:         $pos = StockPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
     999:
    1000:         $this->setByPosition($pos, $value);
    1001:     }
    1002:
    1003:     /**
    1004:      * Sets a field from the object by Position as specified in the xml schema.
    1005:      * Zero-based.
    1006:      *
    1007:      * @param int $pos position in xml schema
    1008:      * @param mixed $value field value
    1009:      * @return void
    1010:      */
    1011:     public function setByPosition($pos, $value)
    1012:     {
    1013:         switch ($pos) {
    1014:             case 0:
    1015:                 $this->setId($value);
    1016:                 break;
    1017:             case 1:
    1018:                 $this->setCombinationId($value);
    1019:                 break;
    1020:             case 2:
    1021:                 $this->setProductId($value);
    1022:                 break;
    1023:             case 3:
    1024:                 $this->setIncrease($value);
    1025:                 break;
    1026:             case 4:
    1027:                 $this->setValue($value);
    1028:                 break;
    1029:             case 5:
    1030:                 $this->setCreatedAt($value);
    1031:                 break;
    1032:             case 6:
    1033:                 $this->setUpdatedAt($value);
    1034:                 break;
    1035:         } // switch()
    1036:     }
    1037:
    1038:     /**
    1039:      * Populates the object using an array.
    1040:      *
    1041:      * This is particularly useful when populating an object from one of the
    1042:      * request arrays (e.g. $_POST).  This method goes through the column
    1043:      * names, checking to see whether a matching key exists in populated
    1044:      * array. If so the setByName() method is called for that column.
    1045:      *
    1046:      * You can specify the key type of the array by additionally passing one
    1047:      * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
    1048:      * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
    1049:      * The default key type is the column's BasePeer::TYPE_PHPNAME
    1050:      *
    1051:      * @param array  $arr     An array to populate the object from.
    1052:      * @param string $keyType The type of keys the array uses.
    1053:      * @return void
    1054:      */
    1055:     public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
    1056:     {
    1057:         $keys = StockPeer::getFieldNames($keyType);
    1058:
    1059:         if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
    1060:         if (array_key_exists($keys[1], $arr)) $this->setCombinationId($arr[$keys[1]]);
    1061:         if (array_key_exists($keys[2], $arr)) $this->setProductId($arr[$keys[2]]);
    1062:         if (array_key_exists($keys[3], $arr)) $this->setIncrease($arr[$keys[3]]);
    1063:         if (array_key_exists($keys[4], $arr)) $this->setValue($arr[$keys[4]]);
    1064:         if (array_key_exists($keys[5], $arr)) $this->setCreatedAt($arr[$keys[5]]);
    1065:         if (array_key_exists($keys[6], $arr)) $this->setUpdatedAt($arr[$keys[6]]);
    1066:     }
    1067:
    1068:     /**
    1069:      * Build a Criteria object containing the values of all modified columns in this object.
    1070:      *
    1071:      * @return Criteria The Criteria object containing all modified values.
    1072:      */
    1073:     public function buildCriteria()
    1074:     {
    1075:         $criteria = new Criteria(StockPeer::DATABASE_NAME);
    1076:
    1077:         if ($this->isColumnModified(StockPeer::ID)) $criteria->add(StockPeer::ID, $this->id);
    1078:         if ($this->isColumnModified(StockPeer::COMBINATION_ID)) $criteria->add(StockPeer::COMBINATION_ID, $this->combination_id);
    1079:         if ($this->isColumnModified(StockPeer::PRODUCT_ID)) $criteria->add(StockPeer::PRODUCT_ID, $this->product_id);
    1080:         if ($this->isColumnModified(StockPeer::INCREASE)) $criteria->add(StockPeer::INCREASE, $this->increase);
    1081:         if ($this->isColumnModified(StockPeer::VALUE)) $criteria->add(StockPeer::VALUE, $this->value);
    1082:         if ($this->isColumnModified(StockPeer::CREATED_AT)) $criteria->add(StockPeer::CREATED_AT, $this->created_at);
    1083:         if ($this->isColumnModified(StockPeer::UPDATED_AT)) $criteria->add(StockPeer::UPDATED_AT, $this->updated_at);
    1084:
    1085:         return $criteria;
    1086:     }
    1087:
    1088:     /**
    1089:      * Builds a Criteria object containing the primary key for this object.
    1090:      *
    1091:      * Unlike buildCriteria() this method includes the primary key values regardless
    1092:      * of whether or not they have been modified.
    1093:      *
    1094:      * @return Criteria The Criteria object containing value(s) for primary key(s).
    1095:      */
    1096:     public function buildPkeyCriteria()
    1097:     {
    1098:         $criteria = new Criteria(StockPeer::DATABASE_NAME);
    1099:         $criteria->add(StockPeer::ID, $this->id);
    1100:
    1101:         return $criteria;
    1102:     }
    1103:
    1104:     /**
    1105:      * Returns the primary key for this object (row).
    1106:      * @return int
    1107:      */
    1108:     public function getPrimaryKey()
    1109:     {
    1110:         return $this->getId();
    1111:     }
    1112:
    1113:     /**
    1114:      * Generic method to set the primary key (id column).
    1115:      *
    1116:      * @param  int $key Primary key.
    1117:      * @return void
    1118:      */
    1119:     public function setPrimaryKey($key)
    1120:     {
    1121:         $this->setId($key);
    1122:     }
    1123:
    1124:     /**
    1125:      * Returns true if the primary key for this object is null.
    1126:      * @return boolean
    1127:      */
    1128:     public function isPrimaryKeyNull()
    1129:     {
    1130:
    1131:         return null === $this->getId();
    1132:     }
    1133:
    1134:     /**
    1135:      * Sets contents of passed object to values from current object.
    1136:      *
    1137:      * If desired, this method can also make copies of all associated (fkey referrers)
    1138:      * objects.
    1139:      *
    1140:      * @param object $copyObj An object of Stock (or compatible) type.
    1141:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
    1142:      * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
    1143:      * @throws PropelException
    1144:      */
    1145:     public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
    1146:     {
    1147:         $copyObj->setCombinationId($this->getCombinationId());
    1148:         $copyObj->setProductId($this->getProductId());
    1149:         $copyObj->setIncrease($this->getIncrease());
    1150:         $copyObj->setValue($this->getValue());
    1151:         $copyObj->setCreatedAt($this->getCreatedAt());
    1152:         $copyObj->setUpdatedAt($this->getUpdatedAt());
    1153:
    1154:         if ($deepCopy && !$this->startCopy) {
    1155:             // important: temporarily setNew(false) because this affects the behavior of
    1156:             // the getter/setter methods for fkey referrer objects.
    1157:             $copyObj->setNew(false);
    1158:             // store object hash to prevent cycle
    1159:             $this->startCopy = true;
    1160:
    1161:             //unflag object copy
    1162:             $this->startCopy = false;
    1163:         } // if ($deepCopy)
    1164:
    1165:         if ($makeNew) {
    1166:             $copyObj->setNew(true);
    1167:             $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
    1168:         }
    1169:     }
    1170:
    1171:     /**
    1172:      * Makes a copy of this object that will be inserted as a new row in table when saved.
    1173:      * It creates a new object filling in the simple attributes, but skipping any primary
    1174:      * keys that are defined for the table.
    1175:      *
    1176:      * If desired, this method can also make copies of all associated (fkey referrers)
    1177:      * objects.
    1178:      *
    1179:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
    1180:      * @return Stock Clone of current object.
    1181:      * @throws PropelException
    1182:      */
    1183:     public function copy($deepCopy = false)
    1184:     {
    1185:         // we use get_class(), because this might be a subclass
    1186:         $clazz = get_class($this);
    1187:         $copyObj = new $clazz();
    1188:         $this->copyInto($copyObj, $deepCopy);
    1189:
    1190:         return $copyObj;
    1191:     }
    1192:
    1193:     /**
    1194:      * Returns a peer instance associated with this om.
    1195:      *
    1196:      * Since Peer classes are not to have any instance attributes, this method returns the
    1197:      * same instance for all member of this class. The method could therefore
    1198:      * be static, but this would prevent one from overriding the behavior.
    1199:      *
    1200:      * @return StockPeer
    1201:      */
    1202:     public function getPeer()
    1203:     {
    1204:         if (self::$peer === null) {
    1205:             self::$peer = new StockPeer();
    1206:         }
    1207:
    1208:         return self::$peer;
    1209:     }
    1210:
    1211:     /**
    1212:      * Declares an association between this object and a Combination object.
    1213:      *
    1214:      * @param             Combination $v
    1215:      * @return Stock The current object (for fluent API support)
    1216:      * @throws PropelException
    1217:      */
    1218:     public function setCombination(Combination $v = null)
    1219:     {
    1220:         if ($v === null) {
    1221:             $this->setCombinationId(NULL);
    1222:         } else {
    1223:             $this->setCombinationId($v->getId());
    1224:         }
    1225:
    1226:         $this->aCombination = $v;
    1227:
    1228:         // Add binding for other direction of this n:n relationship.
    1229:         // If this object has already been added to the Combination object, it will not be re-added.
    1230:         if ($v !== null) {
    1231:             $v->addStock($this);
    1232:         }
    1233:
    1234:
    1235:         return $this;
    1236:     }
    1237:
    1238:
    1239:     /**
    1240:      * Get the associated Combination object
    1241:      *
    1242:      * @param PropelPDO $con Optional Connection object.
    1243:      * @param $doQuery Executes a query to get the object if required
    1244:      * @return Combination The associated Combination object.
    1245:      * @throws PropelException
    1246:      */
    1247:     public function getCombination(PropelPDO $con = null, $doQuery = true)
    1248:     {
    1249:         if ($this->aCombination === null && ($this->combination_id !== null) && $doQuery) {
    1250:             $this->aCombination = CombinationQuery::create()->findPk($this->combination_id, $con);
    1251:             /* The following can be used additionally to
    1252:                 guarantee the related object contains a reference
    1253:                 to this object.  This level of coupling may, however, be
    1254:                 undesirable since it could result in an only partially populated collection
    1255:                 in the referenced object.
    1256:                 $this->aCombination->addStocks($this);
    1257:              */
    1258:         }
    1259:
    1260:         return $this->aCombination;
    1261:     }
    1262:
    1263:     /**
    1264:      * Declares an association between this object and a Product object.
    1265:      *
    1266:      * @param             Product $v
    1267:      * @return Stock The current object (for fluent API support)
    1268:      * @throws PropelException
    1269:      */
    1270:     public function setProduct(Product $v = null)
    1271:     {
    1272:         if ($v === null) {
    1273:             $this->setProductId(NULL);
    1274:         } else {
    1275:             $this->setProductId($v->getId());
    1276:         }
    1277:
    1278:         $this->aProduct = $v;
    1279:
    1280:         // Add binding for other direction of this n:n relationship.
    1281:         // If this object has already been added to the Product object, it will not be re-added.
    1282:         if ($v !== null) {
    1283:             $v->addStock($this);
    1284:         }
    1285:
    1286:
    1287:         return $this;
    1288:     }
    1289:
    1290:
    1291:     /**
    1292:      * Get the associated Product object
    1293:      *
    1294:      * @param PropelPDO $con Optional Connection object.
    1295:      * @param $doQuery Executes a query to get the object if required
    1296:      * @return Product The associated Product object.
    1297:      * @throws PropelException
    1298:      */
    1299:     public function getProduct(PropelPDO $con = null, $doQuery = true)
    1300:     {
    1301:         if ($this->aProduct === null && ($this->product_id !== null) && $doQuery) {
    1302:             $this->aProduct = ProductQuery::create()->findPk($this->product_id, $con);
    1303:             /* The following can be used additionally to
    1304:                 guarantee the related object contains a reference
    1305:                 to this object.  This level of coupling may, however, be
    1306:                 undesirable since it could result in an only partially populated collection
    1307:                 in the referenced object.
    1308:                 $this->aProduct->addStocks($this);
    1309:              */
    1310:         }
    1311:
    1312:         return $this->aProduct;
    1313:     }
    1314:
    1315:     /**
    1316:      * Clears the current object and sets all attributes to their default values
    1317:      */
    1318:     public function clear()
    1319:     {
    1320:         $this->id = null;
    1321:         $this->combination_id = null;
    1322:         $this->product_id = null;
    1323:         $this->increase = null;
    1324:         $this->value = null;
    1325:         $this->created_at = null;
    1326:         $this->updated_at = null;
    1327:         $this->alreadyInSave = false;
    1328:         $this->alreadyInValidation = false;
    1329:         $this->alreadyInClearAllReferencesDeep = false;
    1330:         $this->clearAllReferences();
    1331:         $this->resetModified();
    1332:         $this->setNew(true);
    1333:         $this->setDeleted(false);
    1334:     }
    1335:
    1336:     /**
    1337:      * Resets all references to other model objects or collections of model objects.
    1338:      *
    1339:      * This method is a user-space workaround for PHP's inability to garbage collect
    1340:      * objects with circular references (even in PHP 5.3). This is currently necessary
    1341:      * when using Propel in certain daemon or large-volumne/high-memory operations.
    1342:      *
    1343:      * @param boolean $deep Whether to also clear the references on all referrer objects.
    1344:      */
    1345:     public function clearAllReferences($deep = false)
    1346:     {
    1347:         if ($deep && !$this->alreadyInClearAllReferencesDeep) {
    1348:             $this->alreadyInClearAllReferencesDeep = true;
    1349:             if ($this->aCombination instanceof Persistent) {
    1350:               $this->aCombination->clearAllReferences($deep);
    1351:             }
    1352:             if ($this->aProduct instanceof Persistent) {
    1353:               $this->aProduct->clearAllReferences($deep);
    1354:             }
    1355:
    1356:             $this->alreadyInClearAllReferencesDeep = false;
    1357:         } // if ($deep)
    1358:
    1359:         $this->aCombination = null;
    1360:         $this->aProduct = null;
    1361:     }
    1362:
    1363:     /**
    1364:      * return the string representation of this object
    1365:      *
    1366:      * @return string
    1367:      */
    1368:     public function __toString()
    1369:     {
    1370:         return (string) $this->exportTo(StockPeer::DEFAULT_STRING_FORMAT);
    1371:     }
    1372:
    1373:     /**
    1374:      * return true is the object is in saving state
    1375:      *
    1376:      * @return boolean
    1377:      */
    1378:     public function isAlreadyInSave()
    1379:     {
    1380:         return $this->alreadyInSave;
    1381:     }
    1382:
    1383:     // timestampable behavior
    1384:
    1385:     /**
    1386:      * Mark the current object so that the update date doesn't get updated during next save
    1387:      *
    1388:      * @return     Stock The current object (for fluent API support)
    1389:      */
    1390:     public function keepUpdateDateUnchanged()
    1391:     {
    1392:         $this->modifiedColumns[] = StockPeer::UPDATED_AT;
    1393:
    1394:         return $this;
    1395:     }
    1396:
    1397: }
    1398: