# File core/lib/Thelia/Model/om/BaseRewriting.php | thelia

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