       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 \PropelCollection;
      14: use \PropelDateTime;
      15: use \PropelException;
      16: use \PropelObjectCollection;
      17: use \PropelPDO;
      18: use Thelia\Model\Content;
      19: use Thelia\Model\ContentAssoc;
      20: use Thelia\Model\ContentAssocQuery;
      21: use Thelia\Model\ContentFolder;
      22: use Thelia\Model\ContentFolderQuery;
      23: use Thelia\Model\ContentI18n;
      24: use Thelia\Model\ContentI18nQuery;
      25: use Thelia\Model\ContentPeer;
      26: use Thelia\Model\ContentQuery;
      27: use Thelia\Model\ContentVersion;
      28: use Thelia\Model\ContentVersionPeer;
      29: use Thelia\Model\ContentVersionQuery;
      30: use Thelia\Model\Document;
      31: use Thelia\Model\DocumentQuery;
      32: use Thelia\Model\Image;
      33: use Thelia\Model\ImageQuery;
      34: use Thelia\Model\Rewriting;
      35: use Thelia\Model\RewritingQuery;
      36:
      37: /**
      38:  * Base class that represents a row from the 'content' table.
      39:  *
      40:  *
      41:  *
      42:  * @package    propel.generator.Thelia.Model.om
      43:  */
      44: abstract class BaseContent extends BaseObject implements Persistent
      45: {
      46:     /**
      47:      * Peer class name
      48:      */
      49:     const PEER = 'Thelia\\Model\\ContentPeer';
      50:
      51:     /**
      52:      * The Peer class.
      53:      * Instance provides a convenient way of calling static methods on a class
      54:      * that calling code may not be able to identify.
      55:      * @var        ContentPeer
      56:      */
      57:     protected static $peer;
      58:
      59:     /**
      60:      * The flag var to prevent infinit loop in deep copy
      61:      * @var       boolean
      62:      */
      63:     protected $startCopy = false;
      64:
      65:     /**
      66:      * The value for the id field.
      67:      * @var        int
      68:      */
      69:     protected $id;
      70:
      71:     /**
      72:      * The value for the visible field.
      73:      * @var        int
      74:      */
      75:     protected $visible;
      76:
      77:     /**
      78:      * The value for the position field.
      79:      * @var        int
      80:      */
      81:     protected $position;
      82:
      83:     /**
      84:      * The value for the created_at field.
      85:      * @var        string
      86:      */
      87:     protected $created_at;
      88:
      89:     /**
      90:      * The value for the updated_at field.
      91:      * @var        string
      92:      */
      93:     protected $updated_at;
      94:
      95:     /**
      96:      * The value for the version field.
      97:      * Note: this column has a database default value of: 0
      98:      * @var        int
      99:      */
     100:     protected $version;
     101:
     102:     /**
     103:      * The value for the version_created_at field.
     104:      * @var        string
     105:      */
     106:     protected $version_created_at;
     107:
     108:     /**
     109:      * The value for the version_created_by field.
     110:      * @var        string
     111:      */
     112:     protected $version_created_by;
     113:
     114:     /**
     115:      * @var        PropelObjectCollection|ContentAssoc[] Collection to store aggregation of ContentAssoc objects.
     116:      */
     117:     protected $collContentAssocs;
     118:     protected $collContentAssocsPartial;
     119:
     120:     /**
     121:      * @var        PropelObjectCollection|Image[] Collection to store aggregation of Image objects.
     122:      */
     123:     protected $collImages;
     124:     protected $collImagesPartial;
     125:
     126:     /**
     127:      * @var        PropelObjectCollection|Document[] Collection to store aggregation of Document objects.
     128:      */
     129:     protected $collDocuments;
     130:     protected $collDocumentsPartial;
     131:
     132:     /**
     133:      * @var        PropelObjectCollection|Rewriting[] Collection to store aggregation of Rewriting objects.
     134:      */
     135:     protected $collRewritings;
     136:     protected $collRewritingsPartial;
     137:
     138:     /**
     139:      * @var        PropelObjectCollection|ContentFolder[] Collection to store aggregation of ContentFolder objects.
     140:      */
     141:     protected $collContentFolders;
     142:     protected $collContentFoldersPartial;
     143:
     144:     /**
     145:      * @var        PropelObjectCollection|ContentI18n[] Collection to store aggregation of ContentI18n objects.
     146:      */
     147:     protected $collContentI18ns;
     148:     protected $collContentI18nsPartial;
     149:
     150:     /**
     151:      * @var        PropelObjectCollection|ContentVersion[] Collection to store aggregation of ContentVersion objects.
     152:      */
     153:     protected $collContentVersions;
     154:     protected $collContentVersionsPartial;
     155:
     156:     /**
     157:      * Flag to prevent endless save loop, if this object is referenced
     158:      * by another object which falls in this transaction.
     159:      * @var        boolean
     160:      */
     161:     protected $alreadyInSave = false;
     162:
     163:     /**
     164:      * Flag to prevent endless validation loop, if this object is referenced
     165:      * by another object which falls in this transaction.
     166:      * @var        boolean
     167:      */
     168:     protected $alreadyInValidation = false;
     169:
     170:     /**
     171:      * Flag to prevent endless clearAllReferences($deep=true) loop, if this object is referenced
     172:      * @var        boolean
     173:      */
     174:     protected $alreadyInClearAllReferencesDeep = false;
     175:
     176:     // i18n behavior
     177:
     178:     /**
     179:      * Current locale
     180:      * @var        string
     181:      */
     182:     protected $currentLocale = 'en_US';
     183:
     184:     /**
     185:      * Current translation objects
     186:      * @var        array[ContentI18n]
     187:      */
     188:     protected $currentTranslations;
     189:
     190:     // versionable behavior
     191:
     192:
     193:     /**
     194:      * @var bool
     195:      */
     196:     protected $enforceVersion = false;
     197:
     198:     /**
     199:      * An array of objects scheduled for deletion.
     200:      * @var     PropelObjectCollection
     201:      */
     202:     protected $contentAssocsScheduledForDeletion = null;
     203:
     204:     /**
     205:      * An array of objects scheduled for deletion.
     206:      * @var     PropelObjectCollection
     207:      */
     208:     protected $imagesScheduledForDeletion = null;
     209:
     210:     /**
     211:      * An array of objects scheduled for deletion.
     212:      * @var     PropelObjectCollection
     213:      */
     214:     protected $documentsScheduledForDeletion = null;
     215:
     216:     /**
     217:      * An array of objects scheduled for deletion.
     218:      * @var     PropelObjectCollection
     219:      */
     220:     protected $rewritingsScheduledForDeletion = null;
     221:
     222:     /**
     223:      * An array of objects scheduled for deletion.
     224:      * @var     PropelObjectCollection
     225:      */
     226:     protected $contentFoldersScheduledForDeletion = null;
     227:
     228:     /**
     229:      * An array of objects scheduled for deletion.
     230:      * @var     PropelObjectCollection
     231:      */
     232:     protected $contentI18nsScheduledForDeletion = null;
     233:
     234:     /**
     235:      * An array of objects scheduled for deletion.
     236:      * @var     PropelObjectCollection
     237:      */
     238:     protected $contentVersionsScheduledForDeletion = null;
     239:
     240:     /**
     241:      * Applies default values to this object.
     242:      * This method should be called from the object's constructor (or
     243:      * equivalent initialization method).
     244:      * @see        __construct()
     245:      */
     246:     public function applyDefaultValues()
     247:     {
     248:         $this->version = 0;
     249:     }
     250:
     251:     /**
     252:      * Initializes internal state of BaseContent object.
     253:      * @see        applyDefaults()
     254:      */
     255:     public function __construct()
     256:     {
     257:         parent::__construct();
     258:         $this->applyDefaultValues();
     259:     }
     260:
     261:     /**
     262:      * Get the [id] column value.
     263:      *
     264:      * @return int
     265:      */
     266:     public function getId()
     267:     {
     268:         return $this->id;
     269:     }
     270:
     271:     /**
     272:      * Get the [visible] column value.
     273:      *
     274:      * @return int
     275:      */
     276:     public function getVisible()
     277:     {
     278:         return $this->visible;
     279:     }
     280:
     281:     /**
     282:      * Get the [position] column value.
     283:      *
     284:      * @return int
     285:      */
     286:     public function getPosition()
     287:     {
     288:         return $this->position;
     289:     }
     290:
     291:     /**
     292:      * Get the [optionally formatted] temporal [created_at] column value.
     293:      *
     294:      *
     295:      * @param string $format The date/time format string (either date()-style or strftime()-style).
     296:      *               If format is null, then the raw DateTime object will be returned.
     297:      * @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
     298:      * @throws PropelException - if unable to parse/validate the date/time value.
     299:      */
     300:     public function getCreatedAt($format = 'Y-m-d H:i:s')
     301:     {
     302:         if ($this->created_at === null) {
     303:             return null;
     304:         }
     305:
     306:         if ($this->created_at === '0000-00-00 00:00:00') {
     307:             // while technically this is not a default value of null,
     308:             // this seems to be closest in meaning.
     309:             return null;
     310:         }
     311:
     312:         try {
     313:             $dt = new DateTime($this->created_at);
     314:         } catch (Exception $x) {
     315:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
     316:         }
     317:
     318:         if ($format === null) {
     319:             // Because propel.useDateTimeClass is true, we return a DateTime object.
     320:             return $dt;
     321:         }
     322:
     323:         if (strpos($format, '%') !== false) {
     324:             return strftime($format, $dt->format('U'));
     325:         }
     326:
     327:         return $dt->format($format);
     328:
     329:     }
     330:
     331:     /**
     332:      * Get the [optionally formatted] temporal [updated_at] column value.
     333:      *
     334:      *
     335:      * @param string $format The date/time format string (either date()-style or strftime()-style).
     336:      *               If format is null, then the raw DateTime object will be returned.
     337:      * @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
     338:      * @throws PropelException - if unable to parse/validate the date/time value.
     339:      */
     340:     public function getUpdatedAt($format = 'Y-m-d H:i:s')
     341:     {
     342:         if ($this->updated_at === null) {
     343:             return null;
     344:         }
     345:
     346:         if ($this->updated_at === '0000-00-00 00:00:00') {
     347:             // while technically this is not a default value of null,
     348:             // this seems to be closest in meaning.
     349:             return null;
     350:         }
     351:
     352:         try {
     353:             $dt = new DateTime($this->updated_at);
     354:         } catch (Exception $x) {
     355:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
     356:         }
     357:
     358:         if ($format === null) {
     359:             // Because propel.useDateTimeClass is true, we return a DateTime object.
     360:             return $dt;
     361:         }
     362:
     363:         if (strpos($format, '%') !== false) {
     364:             return strftime($format, $dt->format('U'));
     365:         }
     366:
     367:         return $dt->format($format);
     368:
     369:     }
     370:
     371:     /**
     372:      * Get the [version] column value.
     373:      *
     374:      * @return int
     375:      */
     376:     public function getVersion()
     377:     {
     378:         return $this->version;
     379:     }
     380:
     381:     /**
     382:      * Get the [optionally formatted] temporal [version_created_at] column value.
     383:      *
     384:      *
     385:      * @param string $format The date/time format string (either date()-style or strftime()-style).
     386:      *               If format is null, then the raw DateTime object will be returned.
     387:      * @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
     388:      * @throws PropelException - if unable to parse/validate the date/time value.
     389:      */
     390:     public function getVersionCreatedAt($format = 'Y-m-d H:i:s')
     391:     {
     392:         if ($this->version_created_at === null) {
     393:             return null;
     394:         }
     395:
     396:         if ($this->version_created_at === '0000-00-00 00:00:00') {
     397:             // while technically this is not a default value of null,
     398:             // this seems to be closest in meaning.
     399:             return null;
     400:         }
     401:
     402:         try {
     403:             $dt = new DateTime($this->version_created_at);
     404:         } catch (Exception $x) {
     405:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->version_created_at, true), $x);
     406:         }
     407:
     408:         if ($format === null) {
     409:             // Because propel.useDateTimeClass is true, we return a DateTime object.
     410:             return $dt;
     411:         }
     412:
     413:         if (strpos($format, '%') !== false) {
     414:             return strftime($format, $dt->format('U'));
     415:         }
     416:
     417:         return $dt->format($format);
     418:
     419:     }
     420:
     421:     /**
     422:      * Get the [version_created_by] column value.
     423:      *
     424:      * @return string
     425:      */
     426:     public function getVersionCreatedBy()
     427:     {
     428:         return $this->version_created_by;
     429:     }
     430:
     431:     /**
     432:      * Set the value of [id] column.
     433:      *
     434:      * @param int $v new value
     435:      * @return Content The current object (for fluent API support)
     436:      */
     437:     public function setId($v)
     438:     {
     439:         if ($v !== null && is_numeric($v)) {
     440:             $v = (int) $v;
     441:         }
     442:
     443:         if ($this->id !== $v) {
     444:             $this->id = $v;
     445:             $this->modifiedColumns[] = ContentPeer::ID;
     446:         }
     447:
     448:
     449:         return $this;
     450:     } // setId()
     451:
     452:     /**
     453:      * Set the value of [visible] column.
     454:      *
     455:      * @param int $v new value
     456:      * @return Content The current object (for fluent API support)
     457:      */
     458:     public function setVisible($v)
     459:     {
     460:         if ($v !== null && is_numeric($v)) {
     461:             $v = (int) $v;
     462:         }
     463:
     464:         if ($this->visible !== $v) {
     465:             $this->visible = $v;
     466:             $this->modifiedColumns[] = ContentPeer::VISIBLE;
     467:         }
     468:
     469:
     470:         return $this;
     471:     } // setVisible()
     472:
     473:     /**
     474:      * Set the value of [position] column.
     475:      *
     476:      * @param int $v new value
     477:      * @return Content The current object (for fluent API support)
     478:      */
     479:     public function setPosition($v)
     480:     {
     481:         if ($v !== null && is_numeric($v)) {
     482:             $v = (int) $v;
     483:         }
     484:
     485:         if ($this->position !== $v) {
     486:             $this->position = $v;
     487:             $this->modifiedColumns[] = ContentPeer::POSITION;
     488:         }
     489:
     490:
     491:         return $this;
     492:     } // setPosition()
     493:
     494:     /**
     495:      * Sets the value of [created_at] column to a normalized version of the date/time value specified.
     496:      *
     497:      * @param mixed $v string, integer (timestamp), or DateTime value.
     498:      *               Empty strings are treated as null.
     499:      * @return Content The current object (for fluent API support)
     500:      */
     501:     public function setCreatedAt($v)
     502:     {
     503:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
     504:         if ($this->created_at !== null || $dt !== null) {
     505:             $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
     506:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
     507:             if ($currentDateAsString !== $newDateAsString) {
     508:                 $this->created_at = $newDateAsString;
     509:                 $this->modifiedColumns[] = ContentPeer::CREATED_AT;
     510:             }
     511:         } // if either are not null
     512:
     513:
     514:         return $this;
     515:     } // setCreatedAt()
     516:
     517:     /**
     518:      * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
     519:      *
     520:      * @param mixed $v string, integer (timestamp), or DateTime value.
     521:      *               Empty strings are treated as null.
     522:      * @return Content The current object (for fluent API support)
     523:      */
     524:     public function setUpdatedAt($v)
     525:     {
     526:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
     527:         if ($this->updated_at !== null || $dt !== null) {
     528:             $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
     529:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
     530:             if ($currentDateAsString !== $newDateAsString) {
     531:                 $this->updated_at = $newDateAsString;
     532:                 $this->modifiedColumns[] = ContentPeer::UPDATED_AT;
     533:             }
     534:         } // if either are not null
     535:
     536:
     537:         return $this;
     538:     } // setUpdatedAt()
     539:
     540:     /**
     541:      * Set the value of [version] column.
     542:      *
     543:      * @param int $v new value
     544:      * @return Content The current object (for fluent API support)
     545:      */
     546:     public function setVersion($v)
     547:     {
     548:         if ($v !== null && is_numeric($v)) {
     549:             $v = (int) $v;
     550:         }
     551:
     552:         if ($this->version !== $v) {
     553:             $this->version = $v;
     554:             $this->modifiedColumns[] = ContentPeer::VERSION;
     555:         }
     556:
     557:
     558:         return $this;
     559:     } // setVersion()
     560:
     561:     /**
     562:      * Sets the value of [version_created_at] column to a normalized version of the date/time value specified.
     563:      *
     564:      * @param mixed $v string, integer (timestamp), or DateTime value.
     565:      *               Empty strings are treated as null.
     566:      * @return Content The current object (for fluent API support)
     567:      */
     568:     public function setVersionCreatedAt($v)
     569:     {
     570:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
     571:         if ($this->version_created_at !== null || $dt !== null) {
     572:             $currentDateAsString = ($this->version_created_at !== null && $tmpDt = new DateTime($this->version_created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
     573:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
     574:             if ($currentDateAsString !== $newDateAsString) {
     575:                 $this->version_created_at = $newDateAsString;
     576:                 $this->modifiedColumns[] = ContentPeer::VERSION_CREATED_AT;
     577:             }
     578:         } // if either are not null
     579:
     580:
     581:         return $this;
     582:     } // setVersionCreatedAt()
     583:
     584:     /**
     585:      * Set the value of [version_created_by] column.
     586:      *
     587:      * @param string $v new value
     588:      * @return Content The current object (for fluent API support)
     589:      */
     590:     public function setVersionCreatedBy($v)
     591:     {
     592:         if ($v !== null && is_numeric($v)) {
     593:             $v = (string) $v;
     594:         }
     595:
     596:         if ($this->version_created_by !== $v) {
     597:             $this->version_created_by = $v;
     598:             $this->modifiedColumns[] = ContentPeer::VERSION_CREATED_BY;
     599:         }
     600:
     601:
     602:         return $this;
     603:     } // setVersionCreatedBy()
     604:
     605:     /**
     606:      * Indicates whether the columns in this object are only set to default values.
     607:      *
     608:      * This method can be used in conjunction with isModified() to indicate whether an object is both
     609:      * modified _and_ has some values set which are non-default.
     610:      *
     611:      * @return boolean Whether the columns in this object are only been set with default values.
     612:      */
     613:     public function hasOnlyDefaultValues()
     614:     {
     615:             if ($this->version !== 0) {
     616:                 return false;
     617:             }
     618:
     619:         // otherwise, everything was equal, so return true
     620:         return true;
     621:     } // hasOnlyDefaultValues()
     622:
     623:     /**
     624:      * Hydrates (populates) the object variables with values from the database resultset.
     625:      *
     626:      * An offset (0-based "start column") is specified so that objects can be hydrated
     627:      * with a subset of the columns in the resultset rows.  This is needed, for example,
     628:      * for results of JOIN queries where the resultset row includes columns from two or
     629:      * more tables.
     630:      *
     631:      * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
     632:      * @param int $startcol 0-based offset column which indicates which restultset column to start with.
     633:      * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
     634:      * @return int             next starting column
     635:      * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
     636:      */
     637:     public function hydrate($row, $startcol = 0, $rehydrate = false)
     638:     {
     639:         try {
     640:
     641:             $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
     642:             $this->visible = ($row[$startcol + 1] !== null) ? (int) $row[$startcol + 1] : null;
     643:             $this->position = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
     644:             $this->created_at = ($row[$startcol + 3] !== null) ? (string) $row[$startcol + 3] : null;
     645:             $this->updated_at = ($row[$startcol + 4] !== null) ? (string) $row[$startcol + 4] : null;
     646:             $this->version = ($row[$startcol + 5] !== null) ? (int) $row[$startcol + 5] : null;
     647:             $this->version_created_at = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
     648:             $this->version_created_by = ($row[$startcol + 7] !== null) ? (string) $row[$startcol + 7] : null;
     649:             $this->resetModified();
     650:
     651:             $this->setNew(false);
     652:
     653:             if ($rehydrate) {
     654:                 $this->ensureConsistency();
     655:             }
     656:             $this->postHydrate($row, $startcol, $rehydrate);
     657:             return $startcol + 8; // 8 = ContentPeer::NUM_HYDRATE_COLUMNS.
     658:
     659:         } catch (Exception $e) {
     660:             throw new PropelException("Error populating Content object", $e);
     661:         }
     662:     }
     663:
     664:     /**
     665:      * Checks and repairs the internal consistency of the object.
     666:      *
     667:      * This method is executed after an already-instantiated object is re-hydrated
     668:      * from the database.  It exists to check any foreign keys to make sure that
     669:      * the objects related to the current object are correct based on foreign key.
     670:      *
     671:      * You can override this method in the stub class, but you should always invoke
     672:      * the base method from the overridden method (i.e. parent::ensureConsistency()),
     673:      * in case your model changes.
     674:      *
     675:      * @throws PropelException
     676:      */
     677:     public function ensureConsistency()
     678:     {
     679:
     680:     } // ensureConsistency
     681:
     682:     /**
     683:      * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
     684:      *
     685:      * This will only work if the object has been saved and has a valid primary key set.
     686:      *
     687:      * @param boolean $deep (optional) Whether to also de-associated any related objects.
     688:      * @param PropelPDO $con (optional) The PropelPDO connection to use.
     689:      * @return void
     690:      * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
     691:      */
     692:     public function reload($deep = false, PropelPDO $con = null)
     693:     {
     694:         if ($this->isDeleted()) {
     695:             throw new PropelException("Cannot reload a deleted object.");
     696:         }
     697:
     698:         if ($this->isNew()) {
     699:             throw new PropelException("Cannot reload an unsaved object.");
     700:         }
     701:
     702:         if ($con === null) {
     703:             $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     704:         }
     705:
     706:         // We don't need to alter the object instance pool; we're just modifying this instance
     707:         // already in the pool.
     708:
     709:         $stmt = ContentPeer::doSelectStmt($this->buildPkeyCriteria(), $con);
     710:         $row = $stmt->fetch(PDO::FETCH_NUM);
     711:         $stmt->closeCursor();
     712:         if (!$row) {
     713:             throw new PropelException('Cannot find matching row in the database to reload object values.');
     714:         }
     715:         $this->hydrate($row, 0, true); // rehydrate
     716:
     717:         if ($deep) {  // also de-associate any related objects?
     718:
     719:             $this->collContentAssocs = null;
     720:
     721:             $this->collImages = null;
     722:
     723:             $this->collDocuments = null;
     724:
     725:             $this->collRewritings = null;
     726:
     727:             $this->collContentFolders = null;
     728:
     729:             $this->collContentI18ns = null;
     730:
     731:             $this->collContentVersions = null;
     732:
     733:         } // if (deep)
     734:     }
     735:
     736:     /**
     737:      * Removes this object from datastore and sets delete attribute.
     738:      *
     739:      * @param PropelPDO $con
     740:      * @return void
     741:      * @throws PropelException
     742:      * @throws Exception
     743:      * @see        BaseObject::setDeleted()
     744:      * @see        BaseObject::isDeleted()
     745:      */
     746:     public function delete(PropelPDO $con = null)
     747:     {
     748:         if ($this->isDeleted()) {
     749:             throw new PropelException("This object has already been deleted.");
     750:         }
     751:
     752:         if ($con === null) {
     753:             $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     754:         }
     755:
     756:         $con->beginTransaction();
     757:         try {
     758:             $deleteQuery = ContentQuery::create()
     759:                 ->filterByPrimaryKey($this->getPrimaryKey());
     760:             $ret = $this->preDelete($con);
     761:             if ($ret) {
     762:                 $deleteQuery->delete($con);
     763:                 $this->postDelete($con);
     764:                 $con->commit();
     765:                 $this->setDeleted(true);
     766:             } else {
     767:                 $con->commit();
     768:             }
     769:         } catch (Exception $e) {
     770:             $con->rollBack();
     771:             throw $e;
     772:         }
     773:     }
     774:
     775:     /**
     776:      * Persists this object to the database.
     777:      *
     778:      * If the object is new, it inserts it; otherwise an update is performed.
     779:      * All modified related objects will also be persisted in the doSave()
     780:      * method.  This method wraps all precipitate database operations in a
     781:      * single transaction.
     782:      *
     783:      * @param PropelPDO $con
     784:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
     785:      * @throws PropelException
     786:      * @throws Exception
     787:      * @see        doSave()
     788:      */
     789:     public function save(PropelPDO $con = null)
     790:     {
     791:         if ($this->isDeleted()) {
     792:             throw new PropelException("You cannot save an object that has been deleted.");
     793:         }
     794:
     795:         if ($con === null) {
     796:             $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     797:         }
     798:
     799:         $con->beginTransaction();
     800:         $isInsert = $this->isNew();
     801:         try {
     802:             $ret = $this->preSave($con);
     803:             // versionable behavior
     804:             if ($this->isVersioningNecessary()) {
     805:                 $this->setVersion($this->isNew() ? 1 : $this->getLastVersionNumber($con) + 1);
     806:                 if (!$this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) {
     807:                     $this->setVersionCreatedAt(time());
     808:                 }
     809:                 $createVersion = true; // for postSave hook
     810:             }
     811:             if ($isInsert) {
     812:                 $ret = $ret && $this->preInsert($con);
     813:                 // timestampable behavior
     814:                 if (!$this->isColumnModified(ContentPeer::CREATED_AT)) {
     815:                     $this->setCreatedAt(time());
     816:                 }
     817:                 if (!$this->isColumnModified(ContentPeer::UPDATED_AT)) {
     818:                     $this->setUpdatedAt(time());
     819:                 }
     820:             } else {
     821:                 $ret = $ret && $this->preUpdate($con);
     822:                 // timestampable behavior
     823:                 if ($this->isModified() && !$this->isColumnModified(ContentPeer::UPDATED_AT)) {
     824:                     $this->setUpdatedAt(time());
     825:                 }
     826:             }
     827:             if ($ret) {
     828:                 $affectedRows = $this->doSave($con);
     829:                 if ($isInsert) {
     830:                     $this->postInsert($con);
     831:                 } else {
     832:                     $this->postUpdate($con);
     833:                 }
     834:                 $this->postSave($con);
     835:                 // versionable behavior
     836:                 if (isset($createVersion)) {
     837:                     $this->addVersion($con);
     838:                 }
     839:                 ContentPeer::addInstanceToPool($this);
     840:             } else {
     841:                 $affectedRows = 0;
     842:             }
     843:             $con->commit();
     844:
     845:             return $affectedRows;
     846:         } catch (Exception $e) {
     847:             $con->rollBack();
     848:             throw $e;
     849:         }
     850:     }
     851:
     852:     /**
     853:      * Performs the work of inserting or updating the row in the database.
     854:      *
     855:      * If the object is new, it inserts it; otherwise an update is performed.
     856:      * All related objects are also updated in this method.
     857:      *
     858:      * @param PropelPDO $con
     859:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
     860:      * @throws PropelException
     861:      * @see        save()
     862:      */
     863:     protected function doSave(PropelPDO $con)
     864:     {
     865:         $affectedRows = 0; // initialize var to track total num of affected rows
     866:         if (!$this->alreadyInSave) {
     867:             $this->alreadyInSave = true;
     868:
     869:             if ($this->isNew() || $this->isModified()) {
     870:                 // persist changes
     871:                 if ($this->isNew()) {
     872:                     $this->doInsert($con);
     873:                 } else {
     874:                     $this->doUpdate($con);
     875:                 }
     876:                 $affectedRows += 1;
     877:                 $this->resetModified();
     878:             }
     879:
     880:             if ($this->contentAssocsScheduledForDeletion !== null) {
     881:                 if (!$this->contentAssocsScheduledForDeletion->isEmpty()) {
     882:                     foreach ($this->contentAssocsScheduledForDeletion as $contentAssoc) {
     883:                         // need to save related object because we set the relation to null
     884:                         $contentAssoc->save($con);
     885:                     }
     886:                     $this->contentAssocsScheduledForDeletion = null;
     887:                 }
     888:             }
     889:
     890:             if ($this->collContentAssocs !== null) {
     891:                 foreach ($this->collContentAssocs as $referrerFK) {
     892:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     893:                         $affectedRows += $referrerFK->save($con);
     894:                     }
     895:                 }
     896:             }
     897:
     898:             if ($this->imagesScheduledForDeletion !== null) {
     899:                 if (!$this->imagesScheduledForDeletion->isEmpty()) {
     900:                     foreach ($this->imagesScheduledForDeletion as $image) {
     901:                         // need to save related object because we set the relation to null
     902:                         $image->save($con);
     903:                     }
     904:                     $this->imagesScheduledForDeletion = null;
     905:                 }
     906:             }
     907:
     908:             if ($this->collImages !== null) {
     909:                 foreach ($this->collImages as $referrerFK) {
     910:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     911:                         $affectedRows += $referrerFK->save($con);
     912:                     }
     913:                 }
     914:             }
     915:
     916:             if ($this->documentsScheduledForDeletion !== null) {
     917:                 if (!$this->documentsScheduledForDeletion->isEmpty()) {
     918:                     foreach ($this->documentsScheduledForDeletion as $document) {
     919:                         // need to save related object because we set the relation to null
     920:                         $document->save($con);
     921:                     }
     922:                     $this->documentsScheduledForDeletion = null;
     923:                 }
     924:             }
     925:
     926:             if ($this->collDocuments !== null) {
     927:                 foreach ($this->collDocuments as $referrerFK) {
     928:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     929:                         $affectedRows += $referrerFK->save($con);
     930:                     }
     931:                 }
     932:             }
     933:
     934:             if ($this->rewritingsScheduledForDeletion !== null) {
     935:                 if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
     936:                     foreach ($this->rewritingsScheduledForDeletion as $rewriting) {
     937:                         // need to save related object because we set the relation to null
     938:                         $rewriting->save($con);
     939:                     }
     940:                     $this->rewritingsScheduledForDeletion = null;
     941:                 }
     942:             }
     943:
     944:             if ($this->collRewritings !== null) {
     945:                 foreach ($this->collRewritings as $referrerFK) {
     946:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     947:                         $affectedRows += $referrerFK->save($con);
     948:                     }
     949:                 }
     950:             }
     951:
     952:             if ($this->contentFoldersScheduledForDeletion !== null) {
     953:                 if (!$this->contentFoldersScheduledForDeletion->isEmpty()) {
     954:                     ContentFolderQuery::create()
     955:                         ->filterByPrimaryKeys($this->contentFoldersScheduledForDeletion->getPrimaryKeys(false))
     956:                         ->delete($con);
     957:                     $this->contentFoldersScheduledForDeletion = null;
     958:                 }
     959:             }
     960:
     961:             if ($this->collContentFolders !== null) {
     962:                 foreach ($this->collContentFolders as $referrerFK) {
     963:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     964:                         $affectedRows += $referrerFK->save($con);
     965:                     }
     966:                 }
     967:             }
     968:
     969:             if ($this->contentI18nsScheduledForDeletion !== null) {
     970:                 if (!$this->contentI18nsScheduledForDeletion->isEmpty()) {
     971:                     ContentI18nQuery::create()
     972:                         ->filterByPrimaryKeys($this->contentI18nsScheduledForDeletion->getPrimaryKeys(false))
     973:                         ->delete($con);
     974:                     $this->contentI18nsScheduledForDeletion = null;
     975:                 }
     976:             }
     977:
     978:             if ($this->collContentI18ns !== null) {
     979:                 foreach ($this->collContentI18ns as $referrerFK) {
     980:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     981:                         $affectedRows += $referrerFK->save($con);
     982:                     }
     983:                 }
     984:             }
     985:
     986:             if ($this->contentVersionsScheduledForDeletion !== null) {
     987:                 if (!$this->contentVersionsScheduledForDeletion->isEmpty()) {
     988:                     ContentVersionQuery::create()
     989:                         ->filterByPrimaryKeys($this->contentVersionsScheduledForDeletion->getPrimaryKeys(false))
     990:                         ->delete($con);
     991:                     $this->contentVersionsScheduledForDeletion = null;
     992:                 }
     993:             }
     994:
     995:             if ($this->collContentVersions !== null) {
     996:                 foreach ($this->collContentVersions as $referrerFK) {
     997:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
     998:                         $affectedRows += $referrerFK->save($con);
     999:                     }
    1000:                 }
    1001:             }
    1002:
    1003:             $this->alreadyInSave = false;
    1004:
    1005:         }
    1006:
    1007:         return $affectedRows;
    1008:     } // doSave()
    1009:
    1010:     /**
    1011:      * Insert the row in the database.
    1012:      *
    1013:      * @param PropelPDO $con
    1014:      *
    1015:      * @throws PropelException
    1016:      * @see        doSave()
    1017:      */
    1018:     protected function doInsert(PropelPDO $con)
    1019:     {
    1020:         $modifiedColumns = array();
    1021:         $index = 0;
    1022:
    1023:         $this->modifiedColumns[] = ContentPeer::ID;
    1024:         if (null !== $this->id) {
    1025:             throw new PropelException('Cannot insert a value for auto-increment primary key (' . ContentPeer::ID . ')');
    1026:         }
    1027:
    1028:          // check the columns in natural order for more readable SQL queries
    1029:         if ($this->isColumnModified(ContentPeer::ID)) {
    1030:             $modifiedColumns[':p' . $index++]  = '`id`';
    1031:         }
    1032:         if ($this->isColumnModified(ContentPeer::VISIBLE)) {
    1033:             $modifiedColumns[':p' . $index++]  = '`visible`';
    1034:         }
    1035:         if ($this->isColumnModified(ContentPeer::POSITION)) {
    1036:             $modifiedColumns[':p' . $index++]  = '`position`';
    1037:         }
    1038:         if ($this->isColumnModified(ContentPeer::CREATED_AT)) {
    1039:             $modifiedColumns[':p' . $index++]  = '`created_at`';
    1040:         }
    1041:         if ($this->isColumnModified(ContentPeer::UPDATED_AT)) {
    1042:             $modifiedColumns[':p' . $index++]  = '`updated_at`';
    1043:         }
    1044:         if ($this->isColumnModified(ContentPeer::VERSION)) {
    1045:             $modifiedColumns[':p' . $index++]  = '`version`';
    1046:         }
    1047:         if ($this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) {
    1048:             $modifiedColumns[':p' . $index++]  = '`version_created_at`';
    1049:         }
    1050:         if ($this->isColumnModified(ContentPeer::VERSION_CREATED_BY)) {
    1051:             $modifiedColumns[':p' . $index++]  = '`version_created_by`';
    1052:         }
    1053:
    1054:         $sql = sprintf(
    1055:             'INSERT INTO `content` (%s) VALUES (%s)',
    1056:             implode(', ', $modifiedColumns),
    1057:             implode(', ', array_keys($modifiedColumns))
    1058:         );
    1059:
    1060:         try {
    1061:             $stmt = $con->prepare($sql);
    1062:             foreach ($modifiedColumns as $identifier => $columnName) {
    1063:                 switch ($columnName) {
    1064:                     case '`id`':
    1065:                         $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
    1066:                         break;
    1067:                     case '`visible`':
    1068:                         $stmt->bindValue($identifier, $this->visible, PDO::PARAM_INT);
    1069:                         break;
    1070:                     case '`position`':
    1071:                         $stmt->bindValue($identifier, $this->position, PDO::PARAM_INT);
    1072:                         break;
    1073:                     case '`created_at`':
    1074:                         $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
    1075:                         break;
    1076:                     case '`updated_at`':
    1077:                         $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
    1078:                         break;
    1079:                     case '`version`':
    1080:                         $stmt->bindValue($identifier, $this->version, PDO::PARAM_INT);
    1081:                         break;
    1082:                     case '`version_created_at`':
    1083:                         $stmt->bindValue($identifier, $this->version_created_at, PDO::PARAM_STR);
    1084:                         break;
    1085:                     case '`version_created_by`':
    1086:                         $stmt->bindValue($identifier, $this->version_created_by, PDO::PARAM_STR);
    1087:                         break;
    1088:                 }
    1089:             }
    1090:             $stmt->execute();
    1091:         } catch (Exception $e) {
    1092:             Propel::log($e->getMessage(), Propel::LOG_ERR);
    1093:             throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
    1094:         }
    1095:
    1096:         try {
    1097:             $pk = $con->lastInsertId();
    1098:         } catch (Exception $e) {
    1099:             throw new PropelException('Unable to get autoincrement id.', $e);
    1100:         }
    1101:         $this->setId($pk);
    1102:
    1103:         $this->setNew(false);
    1104:     }
    1105:
    1106:     /**
    1107:      * Update the row in the database.
    1108:      *
    1109:      * @param PropelPDO $con
    1110:      *
    1111:      * @see        doSave()
    1112:      */
    1113:     protected function doUpdate(PropelPDO $con)
    1114:     {
    1115:         $selectCriteria = $this->buildPkeyCriteria();
    1116:         $valuesCriteria = $this->buildCriteria();
    1117:         BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
    1118:     }
    1119:
    1120:     /**
    1121:      * Array of ValidationFailed objects.
    1122:      * @var        array ValidationFailed[]
    1123:      */
    1124:     protected $validationFailures = array();
    1125:
    1126:     /**
    1127:      * Gets any ValidationFailed objects that resulted from last call to validate().
    1128:      *
    1129:      *
    1130:      * @return array ValidationFailed[]
    1131:      * @see        validate()
    1132:      */
    1133:     public function getValidationFailures()
    1134:     {
    1135:         return $this->validationFailures;
    1136:     }
    1137:
    1138:     /**
    1139:      * Validates the objects modified field values and all objects related to this table.
    1140:      *
    1141:      * If $columns is either a column name or an array of column names
    1142:      * only those columns are validated.
    1143:      *
    1144:      * @param mixed $columns Column name or an array of column names.
    1145:      * @return boolean Whether all columns pass validation.
    1146:      * @see        doValidate()
    1147:      * @see        getValidationFailures()
    1148:      */
    1149:     public function validate($columns = null)
    1150:     {
    1151:         $res = $this->doValidate($columns);
    1152:         if ($res === true) {
    1153:             $this->validationFailures = array();
    1154:
    1155:             return true;
    1156:         }
    1157:
    1158:         $this->validationFailures = $res;
    1159:
    1160:         return false;
    1161:     }
    1162:
    1163:     /**
    1164:      * This function performs the validation work for complex object models.
    1165:      *
    1166:      * In addition to checking the current object, all related objects will
    1167:      * also be validated.  If all pass then <code>true</code> is returned; otherwise
    1168:      * an aggreagated array of ValidationFailed objects will be returned.
    1169:      *
    1170:      * @param array $columns Array of column names to validate.
    1171:      * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
    1172:      */
    1173:     protected function doValidate($columns = null)
    1174:     {
    1175:         if (!$this->alreadyInValidation) {
    1176:             $this->alreadyInValidation = true;
    1177:             $retval = null;
    1178:
    1179:             $failureMap = array();
    1180:
    1181:
    1182:             if (($retval = ContentPeer::doValidate($this, $columns)) !== true) {
    1183:                 $failureMap = array_merge($failureMap, $retval);
    1184:             }
    1185:
    1186:
    1187:                 if ($this->collContentAssocs !== null) {
    1188:                     foreach ($this->collContentAssocs as $referrerFK) {
    1189:                         if (!$referrerFK->validate($columns)) {
    1190:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1191:                         }
    1192:                     }
    1193:                 }
    1194:
    1195:                 if ($this->collImages !== null) {
    1196:                     foreach ($this->collImages as $referrerFK) {
    1197:                         if (!$referrerFK->validate($columns)) {
    1198:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1199:                         }
    1200:                     }
    1201:                 }
    1202:
    1203:                 if ($this->collDocuments !== null) {
    1204:                     foreach ($this->collDocuments as $referrerFK) {
    1205:                         if (!$referrerFK->validate($columns)) {
    1206:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1207:                         }
    1208:                     }
    1209:                 }
    1210:
    1211:                 if ($this->collRewritings !== null) {
    1212:                     foreach ($this->collRewritings as $referrerFK) {
    1213:                         if (!$referrerFK->validate($columns)) {
    1214:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1215:                         }
    1216:                     }
    1217:                 }
    1218:
    1219:                 if ($this->collContentFolders !== null) {
    1220:                     foreach ($this->collContentFolders as $referrerFK) {
    1221:                         if (!$referrerFK->validate($columns)) {
    1222:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1223:                         }
    1224:                     }
    1225:                 }
    1226:
    1227:                 if ($this->collContentI18ns !== null) {
    1228:                     foreach ($this->collContentI18ns as $referrerFK) {
    1229:                         if (!$referrerFK->validate($columns)) {
    1230:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1231:                         }
    1232:                     }
    1233:                 }
    1234:
    1235:                 if ($this->collContentVersions !== null) {
    1236:                     foreach ($this->collContentVersions as $referrerFK) {
    1237:                         if (!$referrerFK->validate($columns)) {
    1238:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
    1239:                         }
    1240:                     }
    1241:                 }
    1242:
    1243:
    1244:             $this->alreadyInValidation = false;
    1245:         }
    1246:
    1247:         return (!empty($failureMap) ? $failureMap : true);
    1248:     }
    1249:
    1250:     /**
    1251:      * Retrieves a field from the object by name passed in as a string.
    1252:      *
    1253:      * @param string $name name
    1254:      * @param string $type The type of fieldname the $name is of:
    1255:      *               one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
    1256:      *               BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
    1257:      *               Defaults to BasePeer::TYPE_PHPNAME
    1258:      * @return mixed Value of field.
    1259:      */
    1260:     public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
    1261:     {
    1262:         $pos = ContentPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
    1263:         $field = $this->getByPosition($pos);
    1264:
    1265:         return $field;
    1266:     }
    1267:
    1268:     /**
    1269:      * Retrieves a field from the object by Position as specified in the xml schema.
    1270:      * Zero-based.
    1271:      *
    1272:      * @param int $pos position in xml schema
    1273:      * @return mixed Value of field at $pos
    1274:      */
    1275:     public function getByPosition($pos)
    1276:     {
    1277:         switch ($pos) {
    1278:             case 0:
    1279:                 return $this->getId();
    1280:                 break;
    1281:             case 1:
    1282:                 return $this->getVisible();
    1283:                 break;
    1284:             case 2:
    1285:                 return $this->getPosition();
    1286:                 break;
    1287:             case 3:
    1288:                 return $this->getCreatedAt();
    1289:                 break;
    1290:             case 4:
    1291:                 return $this->getUpdatedAt();
    1292:                 break;
    1293:             case 5:
    1294:                 return $this->getVersion();
    1295:                 break;
    1296:             case 6:
    1297:                 return $this->getVersionCreatedAt();
    1298:                 break;
    1299:             case 7:
    1300:                 return $this->getVersionCreatedBy();
    1301:                 break;
    1302:             default:
    1303:                 return null;
    1304:                 break;
    1305:         } // switch()
    1306:     }
    1307:
    1308:     /**
    1309:      * Exports the object as an array.
    1310:      *
    1311:      * You can specify the key type of the array by passing one of the class
    1312:      * type constants.
    1313:      *
    1314:      * @param     string  $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
    1315:      *                    BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
    1316:      *                    Defaults to BasePeer::TYPE_PHPNAME.
    1317:      * @param     boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
    1318:      * @param     array $alreadyDumpedObjects List of objects to skip to avoid recursion
    1319:      * @param     boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
    1320:      *
    1321:      * @return array an associative array containing the field names (as keys) and field values
    1322:      */
    1323:     public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
    1324:     {
    1325:         if (isset($alreadyDumpedObjects['Content'][$this->getPrimaryKey()])) {
    1326:             return '*RECURSION*';
    1327:         }
    1328:         $alreadyDumpedObjects['Content'][$this->getPrimaryKey()] = true;
    1329:         $keys = ContentPeer::getFieldNames($keyType);
    1330:         $result = array(
    1331:             $keys[0] => $this->getId(),
    1332:             $keys[1] => $this->getVisible(),
    1333:             $keys[2] => $this->getPosition(),
    1334:             $keys[3] => $this->getCreatedAt(),
    1335:             $keys[4] => $this->getUpdatedAt(),
    1336:             $keys[5] => $this->getVersion(),
    1337:             $keys[6] => $this->getVersionCreatedAt(),
    1338:             $keys[7] => $this->getVersionCreatedBy(),
    1339:         );
    1340:         if ($includeForeignObjects) {
    1341:             if (null !== $this->collContentAssocs) {
    1342:                 $result['ContentAssocs'] = $this->collContentAssocs->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1343:             }
    1344:             if (null !== $this->collImages) {
    1345:                 $result['Images'] = $this->collImages->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1346:             }
    1347:             if (null !== $this->collDocuments) {
    1348:                 $result['Documents'] = $this->collDocuments->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1349:             }
    1350:             if (null !== $this->collRewritings) {
    1351:                 $result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1352:             }
    1353:             if (null !== $this->collContentFolders) {
    1354:                 $result['ContentFolders'] = $this->collContentFolders->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1355:             }
    1356:             if (null !== $this->collContentI18ns) {
    1357:                 $result['ContentI18ns'] = $this->collContentI18ns->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1358:             }
    1359:             if (null !== $this->collContentVersions) {
    1360:                 $result['ContentVersions'] = $this->collContentVersions->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
    1361:             }
    1362:         }
    1363:
    1364:         return $result;
    1365:     }
    1366:
    1367:     /**
    1368:      * Sets a field from the object by name passed in as a string.
    1369:      *
    1370:      * @param string $name peer name
    1371:      * @param mixed $value field value
    1372:      * @param string $type The type of fieldname the $name is of:
    1373:      *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
    1374:      *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
    1375:      *                     Defaults to BasePeer::TYPE_PHPNAME
    1376:      * @return void
    1377:      */
    1378:     public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
    1379:     {
    1380:         $pos = ContentPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
    1381:
    1382:         $this->setByPosition($pos, $value);
    1383:     }
    1384:
    1385:     /**
    1386:      * Sets a field from the object by Position as specified in the xml schema.
    1387:      * Zero-based.
    1388:      *
    1389:      * @param int $pos position in xml schema
    1390:      * @param mixed $value field value
    1391:      * @return void
    1392:      */
    1393:     public function setByPosition($pos, $value)
    1394:     {
    1395:         switch ($pos) {
    1396:             case 0:
    1397:                 $this->setId($value);
    1398:                 break;
    1399:             case 1:
    1400:                 $this->setVisible($value);
    1401:                 break;
    1402:             case 2:
    1403:                 $this->setPosition($value);
    1404:                 break;
    1405:             case 3:
    1406:                 $this->setCreatedAt($value);
    1407:                 break;
    1408:             case 4:
    1409:                 $this->setUpdatedAt($value);
    1410:                 break;
    1411:             case 5:
    1412:                 $this->setVersion($value);
    1413:                 break;
    1414:             case 6:
    1415:                 $this->setVersionCreatedAt($value);
    1416:                 break;
    1417:             case 7:
    1418:                 $this->setVersionCreatedBy($value);
    1419:                 break;
    1420:         } // switch()
    1421:     }
    1422:
    1423:     /**
    1424:      * Populates the object using an array.
    1425:      *
    1426:      * This is particularly useful when populating an object from one of the
    1427:      * request arrays (e.g. $_POST).  This method goes through the column
    1428:      * names, checking to see whether a matching key exists in populated
    1429:      * array. If so the setByName() method is called for that column.
    1430:      *
    1431:      * You can specify the key type of the array by additionally passing one
    1432:      * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
    1433:      * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
    1434:      * The default key type is the column's BasePeer::TYPE_PHPNAME
    1435:      *
    1436:      * @param array  $arr     An array to populate the object from.
    1437:      * @param string $keyType The type of keys the array uses.
    1438:      * @return void
    1439:      */
    1440:     public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
    1441:     {
    1442:         $keys = ContentPeer::getFieldNames($keyType);
    1443:
    1444:         if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
    1445:         if (array_key_exists($keys[1], $arr)) $this->setVisible($arr[$keys[1]]);
    1446:         if (array_key_exists($keys[2], $arr)) $this->setPosition($arr[$keys[2]]);
    1447:         if (array_key_exists($keys[3], $arr)) $this->setCreatedAt($arr[$keys[3]]);
    1448:         if (array_key_exists($keys[4], $arr)) $this->setUpdatedAt($arr[$keys[4]]);
    1449:         if (array_key_exists($keys[5], $arr)) $this->setVersion($arr[$keys[5]]);
    1450:         if (array_key_exists($keys[6], $arr)) $this->setVersionCreatedAt($arr[$keys[6]]);
    1451:         if (array_key_exists($keys[7], $arr)) $this->setVersionCreatedBy($arr[$keys[7]]);
    1452:     }
    1453:
    1454:     /**
    1455:      * Build a Criteria object containing the values of all modified columns in this object.
    1456:      *
    1457:      * @return Criteria The Criteria object containing all modified values.
    1458:      */
    1459:     public function buildCriteria()
    1460:     {
    1461:         $criteria = new Criteria(ContentPeer::DATABASE_NAME);
    1462:
    1463:         if ($this->isColumnModified(ContentPeer::ID)) $criteria->add(ContentPeer::ID, $this->id);
    1464:         if ($this->isColumnModified(ContentPeer::VISIBLE)) $criteria->add(ContentPeer::VISIBLE, $this->visible);
    1465:         if ($this->isColumnModified(ContentPeer::POSITION)) $criteria->add(ContentPeer::POSITION, $this->position);
    1466:         if ($this->isColumnModified(ContentPeer::CREATED_AT)) $criteria->add(ContentPeer::CREATED_AT, $this->created_at);
    1467:         if ($this->isColumnModified(ContentPeer::UPDATED_AT)) $criteria->add(ContentPeer::UPDATED_AT, $this->updated_at);
    1468:         if ($this->isColumnModified(ContentPeer::VERSION)) $criteria->add(ContentPeer::VERSION, $this->version);
    1469:         if ($this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) $criteria->add(ContentPeer::VERSION_CREATED_AT, $this->version_created_at);
    1470:         if ($this->isColumnModified(ContentPeer::VERSION_CREATED_BY)) $criteria->add(ContentPeer::VERSION_CREATED_BY, $this->version_created_by);
    1471:
    1472:         return $criteria;
    1473:     }
    1474:
    1475:     /**
    1476:      * Builds a Criteria object containing the primary key for this object.
    1477:      *
    1478:      * Unlike buildCriteria() this method includes the primary key values regardless
    1479:      * of whether or not they have been modified.
    1480:      *
    1481:      * @return Criteria The Criteria object containing value(s) for primary key(s).
    1482:      */
    1483:     public function buildPkeyCriteria()
    1484:     {
    1485:         $criteria = new Criteria(ContentPeer::DATABASE_NAME);
    1486:         $criteria->add(ContentPeer::ID, $this->id);
    1487:
    1488:         return $criteria;
    1489:     }
    1490:
    1491:     /**
    1492:      * Returns the primary key for this object (row).
    1493:      * @return int
    1494:      */
    1495:     public function getPrimaryKey()
    1496:     {
    1497:         return $this->getId();
    1498:     }
    1499:
    1500:     /**
    1501:      * Generic method to set the primary key (id column).
    1502:      *
    1503:      * @param  int $key Primary key.
    1504:      * @return void
    1505:      */
    1506:     public function setPrimaryKey($key)
    1507:     {
    1508:         $this->setId($key);
    1509:     }
    1510:
    1511:     /**
    1512:      * Returns true if the primary key for this object is null.
    1513:      * @return boolean
    1514:      */
    1515:     public function isPrimaryKeyNull()
    1516:     {
    1517:
    1518:         return null === $this->getId();
    1519:     }
    1520:
    1521:     /**
    1522:      * Sets contents of passed object to values from current object.
    1523:      *
    1524:      * If desired, this method can also make copies of all associated (fkey referrers)
    1525:      * objects.
    1526:      *
    1527:      * @param object $copyObj An object of Content (or compatible) type.
    1528:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
    1529:      * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
    1530:      * @throws PropelException
    1531:      */
    1532:     public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
    1533:     {
    1534:         $copyObj->setVisible($this->getVisible());
    1535:         $copyObj->setPosition($this->getPosition());
    1536:         $copyObj->setCreatedAt($this->getCreatedAt());
    1537:         $copyObj->setUpdatedAt($this->getUpdatedAt());
    1538:         $copyObj->setVersion($this->getVersion());
    1539:         $copyObj->setVersionCreatedAt($this->getVersionCreatedAt());
    1540:         $copyObj->setVersionCreatedBy($this->getVersionCreatedBy());
    1541:
    1542:         if ($deepCopy && !$this->startCopy) {
    1543:             // important: temporarily setNew(false) because this affects the behavior of
    1544:             // the getter/setter methods for fkey referrer objects.
    1545:             $copyObj->setNew(false);
    1546:             // store object hash to prevent cycle
    1547:             $this->startCopy = true;
    1548:
    1549:             foreach ($this->getContentAssocs() as $relObj) {
    1550:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1551:                     $copyObj->addContentAssoc($relObj->copy($deepCopy));
    1552:                 }
    1553:             }
    1554:
    1555:             foreach ($this->getImages() as $relObj) {
    1556:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1557:                     $copyObj->addImage($relObj->copy($deepCopy));
    1558:                 }
    1559:             }
    1560:
    1561:             foreach ($this->getDocuments() as $relObj) {
    1562:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1563:                     $copyObj->addDocument($relObj->copy($deepCopy));
    1564:                 }
    1565:             }
    1566:
    1567:             foreach ($this->getRewritings() as $relObj) {
    1568:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1569:                     $copyObj->addRewriting($relObj->copy($deepCopy));
    1570:                 }
    1571:             }
    1572:
    1573:             foreach ($this->getContentFolders() as $relObj) {
    1574:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1575:                     $copyObj->addContentFolder($relObj->copy($deepCopy));
    1576:                 }
    1577:             }
    1578:
    1579:             foreach ($this->getContentI18ns() as $relObj) {
    1580:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1581:                     $copyObj->addContentI18n($relObj->copy($deepCopy));
    1582:                 }
    1583:             }
    1584:
    1585:             foreach ($this->getContentVersions() as $relObj) {
    1586:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
    1587:                     $copyObj->addContentVersion($relObj->copy($deepCopy));
    1588:                 }
    1589:             }
    1590:
    1591:             //unflag object copy
    1592:             $this->startCopy = false;
    1593:         } // if ($deepCopy)
    1594:
    1595:         if ($makeNew) {
    1596:             $copyObj->setNew(true);
    1597:             $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
    1598:         }
    1599:     }
    1600:
    1601:     /**
    1602:      * Makes a copy of this object that will be inserted as a new row in table when saved.
    1603:      * It creates a new object filling in the simple attributes, but skipping any primary
    1604:      * keys that are defined for the table.
    1605:      *
    1606:      * If desired, this method can also make copies of all associated (fkey referrers)
    1607:      * objects.
    1608:      *
    1609:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
    1610:      * @return Content Clone of current object.
    1611:      * @throws PropelException
    1612:      */
    1613:     public function copy($deepCopy = false)
    1614:     {
    1615:         // we use get_class(), because this might be a subclass
    1616:         $clazz = get_class($this);
    1617:         $copyObj = new $clazz();
    1618:         $this->copyInto($copyObj, $deepCopy);
    1619:
    1620:         return $copyObj;
    1621:     }
    1622:
    1623:     /**
    1624:      * Returns a peer instance associated with this om.
    1625:      *
    1626:      * Since Peer classes are not to have any instance attributes, this method returns the
    1627:      * same instance for all member of this class. The method could therefore
    1628:      * be static, but this would prevent one from overriding the behavior.
    1629:      *
    1630:      * @return ContentPeer
    1631:      */
    1632:     public function getPeer()
    1633:     {
    1634:         if (self::$peer === null) {
    1635:             self::$peer = new ContentPeer();
    1636:         }
    1637:
    1638:         return self::$peer;
    1639:     }
    1640:
    1641:
    1642:     /**
    1643:      * Initializes a collection based on the name of a relation.
    1644:      * Avoids crafting an 'init[$relationName]s' method name
    1645:      * that wouldn't work when StandardEnglishPluralizer is used.
    1646:      *
    1647:      * @param string $relationName The name of the relation to initialize
    1648:      * @return void
    1649:      */
    1650:     public function initRelation($relationName)
    1651:     {
    1652:         if ('ContentAssoc' == $relationName) {
    1653:             $this->initContentAssocs();
    1654:         }
    1655:         if ('Image' == $relationName) {
    1656:             $this->initImages();
    1657:         }
    1658:         if ('Document' == $relationName) {
    1659:             $this->initDocuments();
    1660:         }
    1661:         if ('Rewriting' == $relationName) {
    1662:             $this->initRewritings();
    1663:         }
    1664:         if ('ContentFolder' == $relationName) {
    1665:             $this->initContentFolders();
    1666:         }
    1667:         if ('ContentI18n' == $relationName) {
    1668:             $this->initContentI18ns();
    1669:         }
    1670:         if ('ContentVersion' == $relationName) {
    1671:             $this->initContentVersions();
    1672:         }
    1673:     }
    1674:
    1675:     /**
    1676:      * Clears out the collContentAssocs collection
    1677:      *
    1678:      * This does not modify the database; however, it will remove any associated objects, causing
    1679:      * them to be refetched by subsequent calls to accessor method.
    1680:      *
    1681:      * @return Content The current object (for fluent API support)
    1682:      * @see        addContentAssocs()
    1683:      */
    1684:     public function clearContentAssocs()
    1685:     {
    1686:         $this->collContentAssocs = null; // important to set this to null since that means it is uninitialized
    1687:         $this->collContentAssocsPartial = null;
    1688:
    1689:         return $this;
    1690:     }
    1691:
    1692:     /**
    1693:      * reset is the collContentAssocs collection loaded partially
    1694:      *
    1695:      * @return void
    1696:      */
    1697:     public function resetPartialContentAssocs($v = true)
    1698:     {
    1699:         $this->collContentAssocsPartial = $v;
    1700:     }
    1701:
    1702:     /**
    1703:      * Initializes the collContentAssocs collection.
    1704:      *
    1705:      * By default this just sets the collContentAssocs collection to an empty array (like clearcollContentAssocs());
    1706:      * however, you may wish to override this method in your stub class to provide setting appropriate
    1707:      * to your application -- for example, setting the initial array to the values stored in database.
    1708:      *
    1709:      * @param boolean $overrideExisting If set to true, the method call initializes
    1710:      *                                        the collection even if it is not empty
    1711:      *
    1712:      * @return void
    1713:      */
    1714:     public function initContentAssocs($overrideExisting = true)
    1715:     {
    1716:         if (null !== $this->collContentAssocs && !$overrideExisting) {
    1717:             return;
    1718:         }
    1719:         $this->collContentAssocs = new PropelObjectCollection();
    1720:         $this->collContentAssocs->setModel('ContentAssoc');
    1721:     }
    1722:
    1723:     /**
    1724:      * Gets an array of ContentAssoc objects which contain a foreign key that references this object.
    1725:      *
    1726:      * If the $criteria is not null, it is used to always fetch the results from the database.
    1727:      * Otherwise the results are fetched from the database the first time, then cached.
    1728:      * Next time the same method is called without $criteria, the cached collection is returned.
    1729:      * If this Content is new, it will return
    1730:      * an empty collection or the current collection; the criteria is ignored on a new object.
    1731:      *
    1732:      * @param Criteria $criteria optional Criteria object to narrow the query
    1733:      * @param PropelPDO $con optional connection object
    1734:      * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
    1735:      * @throws PropelException
    1736:      */
    1737:     public function getContentAssocs($criteria = null, PropelPDO $con = null)
    1738:     {
    1739:         $partial = $this->collContentAssocsPartial && !$this->isNew();
    1740:         if (null === $this->collContentAssocs || null !== $criteria  || $partial) {
    1741:             if ($this->isNew() && null === $this->collContentAssocs) {
    1742:                 // return empty collection
    1743:                 $this->initContentAssocs();
    1744:             } else {
    1745:                 $collContentAssocs = ContentAssocQuery::create(null, $criteria)
    1746:                     ->filterByContent($this)
    1747:                     ->find($con);
    1748:                 if (null !== $criteria) {
    1749:                     if (false !== $this->collContentAssocsPartial && count($collContentAssocs)) {
    1750:                       $this->initContentAssocs(false);
    1751:
    1752:                       foreach($collContentAssocs as $obj) {
    1753:                         if (false == $this->collContentAssocs->contains($obj)) {
    1754:                           $this->collContentAssocs->append($obj);
    1755:                         }
    1756:                       }
    1757:
    1758:                       $this->collContentAssocsPartial = true;
    1759:                     }
    1760:
    1761:                     $collContentAssocs->getInternalIterator()->rewind();
    1762:                     return $collContentAssocs;
    1763:                 }
    1764:
    1765:                 if($partial && $this->collContentAssocs) {
    1766:                     foreach($this->collContentAssocs as $obj) {
    1767:                         if($obj->isNew()) {
    1768:                             $collContentAssocs[] = $obj;
    1769:                         }
    1770:                     }
    1771:                 }
    1772:
    1773:                 $this->collContentAssocs = $collContentAssocs;
    1774:                 $this->collContentAssocsPartial = false;
    1775:             }
    1776:         }
    1777:
    1778:         return $this->collContentAssocs;
    1779:     }
    1780:
    1781:     /**
    1782:      * Sets a collection of ContentAssoc objects related by a one-to-many relationship
    1783:      * to the current object.
    1784:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    1785:      * and new objects from the given Propel collection.
    1786:      *
    1787:      * @param PropelCollection $contentAssocs A Propel collection.
    1788:      * @param PropelPDO $con Optional connection object
    1789:      * @return Content The current object (for fluent API support)
    1790:      */
    1791:     public function setContentAssocs(PropelCollection $contentAssocs, PropelPDO $con = null)
    1792:     {
    1793:         $contentAssocsToDelete = $this->getContentAssocs(new Criteria(), $con)->diff($contentAssocs);
    1794:
    1795:         $this->contentAssocsScheduledForDeletion = unserialize(serialize($contentAssocsToDelete));
    1796:
    1797:         foreach ($contentAssocsToDelete as $contentAssocRemoved) {
    1798:             $contentAssocRemoved->setContent(null);
    1799:         }
    1800:
    1801:         $this->collContentAssocs = null;
    1802:         foreach ($contentAssocs as $contentAssoc) {
    1803:             $this->addContentAssoc($contentAssoc);
    1804:         }
    1805:
    1806:         $this->collContentAssocs = $contentAssocs;
    1807:         $this->collContentAssocsPartial = false;
    1808:
    1809:         return $this;
    1810:     }
    1811:
    1812:     /**
    1813:      * Returns the number of related ContentAssoc objects.
    1814:      *
    1815:      * @param Criteria $criteria
    1816:      * @param boolean $distinct
    1817:      * @param PropelPDO $con
    1818:      * @return int             Count of related ContentAssoc objects.
    1819:      * @throws PropelException
    1820:      */
    1821:     public function countContentAssocs(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    1822:     {
    1823:         $partial = $this->collContentAssocsPartial && !$this->isNew();
    1824:         if (null === $this->collContentAssocs || null !== $criteria || $partial) {
    1825:             if ($this->isNew() && null === $this->collContentAssocs) {
    1826:                 return 0;
    1827:             }
    1828:
    1829:             if($partial && !$criteria) {
    1830:                 return count($this->getContentAssocs());
    1831:             }
    1832:             $query = ContentAssocQuery::create(null, $criteria);
    1833:             if ($distinct) {
    1834:                 $query->distinct();
    1835:             }
    1836:
    1837:             return $query
    1838:                 ->filterByContent($this)
    1839:                 ->count($con);
    1840:         }
    1841:
    1842:         return count($this->collContentAssocs);
    1843:     }
    1844:
    1845:     /**
    1846:      * Method called to associate a ContentAssoc object to this object
    1847:      * through the ContentAssoc foreign key attribute.
    1848:      *
    1849:      * @param    ContentAssoc $l ContentAssoc
    1850:      * @return Content The current object (for fluent API support)
    1851:      */
    1852:     public function addContentAssoc(ContentAssoc $l)
    1853:     {
    1854:         if ($this->collContentAssocs === null) {
    1855:             $this->initContentAssocs();
    1856:             $this->collContentAssocsPartial = true;
    1857:         }
    1858:         if (!in_array($l, $this->collContentAssocs->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    1859:             $this->doAddContentAssoc($l);
    1860:         }
    1861:
    1862:         return $this;
    1863:     }
    1864:
    1865:     /**
    1866:      * @param   ContentAssoc $contentAssoc The contentAssoc object to add.
    1867:      */
    1868:     protected function doAddContentAssoc($contentAssoc)
    1869:     {
    1870:         $this->collContentAssocs[]= $contentAssoc;
    1871:         $contentAssoc->setContent($this);
    1872:     }
    1873:
    1874:     /**
    1875:      * @param   ContentAssoc $contentAssoc The contentAssoc object to remove.
    1876:      * @return Content The current object (for fluent API support)
    1877:      */
    1878:     public function removeContentAssoc($contentAssoc)
    1879:     {
    1880:         if ($this->getContentAssocs()->contains($contentAssoc)) {
    1881:             $this->collContentAssocs->remove($this->collContentAssocs->search($contentAssoc));
    1882:             if (null === $this->contentAssocsScheduledForDeletion) {
    1883:                 $this->contentAssocsScheduledForDeletion = clone $this->collContentAssocs;
    1884:                 $this->contentAssocsScheduledForDeletion->clear();
    1885:             }
    1886:             $this->contentAssocsScheduledForDeletion[]= $contentAssoc;
    1887:             $contentAssoc->setContent(null);
    1888:         }
    1889:
    1890:         return $this;
    1891:     }
    1892:
    1893:
    1894:     /**
    1895:      * If this collection has already been initialized with
    1896:      * an identical criteria, it returns the collection.
    1897:      * Otherwise if this Content is new, it will return
    1898:      * an empty collection; or if this Content has previously
    1899:      * been saved, it will retrieve related ContentAssocs from storage.
    1900:      *
    1901:      * This method is protected by default in order to keep the public
    1902:      * api reasonable.  You can provide public methods for those you
    1903:      * actually need in Content.
    1904:      *
    1905:      * @param Criteria $criteria optional Criteria object to narrow the query
    1906:      * @param PropelPDO $con optional connection object
    1907:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    1908:      * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
    1909:      */
    1910:     public function getContentAssocsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    1911:     {
    1912:         $query = ContentAssocQuery::create(null, $criteria);
    1913:         $query->joinWith('Category', $join_behavior);
    1914:
    1915:         return $this->getContentAssocs($query, $con);
    1916:     }
    1917:
    1918:
    1919:     /**
    1920:      * If this collection has already been initialized with
    1921:      * an identical criteria, it returns the collection.
    1922:      * Otherwise if this Content is new, it will return
    1923:      * an empty collection; or if this Content has previously
    1924:      * been saved, it will retrieve related ContentAssocs from storage.
    1925:      *
    1926:      * This method is protected by default in order to keep the public
    1927:      * api reasonable.  You can provide public methods for those you
    1928:      * actually need in Content.
    1929:      *
    1930:      * @param Criteria $criteria optional Criteria object to narrow the query
    1931:      * @param PropelPDO $con optional connection object
    1932:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    1933:      * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
    1934:      */
    1935:     public function getContentAssocsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    1936:     {
    1937:         $query = ContentAssocQuery::create(null, $criteria);
    1938:         $query->joinWith('Product', $join_behavior);
    1939:
    1940:         return $this->getContentAssocs($query, $con);
    1941:     }
    1942:
    1943:     /**
    1944:      * Clears out the collImages collection
    1945:      *
    1946:      * This does not modify the database; however, it will remove any associated objects, causing
    1947:      * them to be refetched by subsequent calls to accessor method.
    1948:      *
    1949:      * @return Content The current object (for fluent API support)
    1950:      * @see        addImages()
    1951:      */
    1952:     public function clearImages()
    1953:     {
    1954:         $this->collImages = null; // important to set this to null since that means it is uninitialized
    1955:         $this->collImagesPartial = null;
    1956:
    1957:         return $this;
    1958:     }
    1959:
    1960:     /**
    1961:      * reset is the collImages collection loaded partially
    1962:      *
    1963:      * @return void
    1964:      */
    1965:     public function resetPartialImages($v = true)
    1966:     {
    1967:         $this->collImagesPartial = $v;
    1968:     }
    1969:
    1970:     /**
    1971:      * Initializes the collImages collection.
    1972:      *
    1973:      * By default this just sets the collImages collection to an empty array (like clearcollImages());
    1974:      * however, you may wish to override this method in your stub class to provide setting appropriate
    1975:      * to your application -- for example, setting the initial array to the values stored in database.
    1976:      *
    1977:      * @param boolean $overrideExisting If set to true, the method call initializes
    1978:      *                                        the collection even if it is not empty
    1979:      *
    1980:      * @return void
    1981:      */
    1982:     public function initImages($overrideExisting = true)
    1983:     {
    1984:         if (null !== $this->collImages && !$overrideExisting) {
    1985:             return;
    1986:         }
    1987:         $this->collImages = new PropelObjectCollection();
    1988:         $this->collImages->setModel('Image');
    1989:     }
    1990:
    1991:     /**
    1992:      * Gets an array of Image objects which contain a foreign key that references this object.
    1993:      *
    1994:      * If the $criteria is not null, it is used to always fetch the results from the database.
    1995:      * Otherwise the results are fetched from the database the first time, then cached.
    1996:      * Next time the same method is called without $criteria, the cached collection is returned.
    1997:      * If this Content is new, it will return
    1998:      * an empty collection or the current collection; the criteria is ignored on a new object.
    1999:      *
    2000:      * @param Criteria $criteria optional Criteria object to narrow the query
    2001:      * @param PropelPDO $con optional connection object
    2002:      * @return PropelObjectCollection|Image[] List of Image objects
    2003:      * @throws PropelException
    2004:      */
    2005:     public function getImages($criteria = null, PropelPDO $con = null)
    2006:     {
    2007:         $partial = $this->collImagesPartial && !$this->isNew();
    2008:         if (null === $this->collImages || null !== $criteria  || $partial) {
    2009:             if ($this->isNew() && null === $this->collImages) {
    2010:                 // return empty collection
    2011:                 $this->initImages();
    2012:             } else {
    2013:                 $collImages = ImageQuery::create(null, $criteria)
    2014:                     ->filterByContent($this)
    2015:                     ->find($con);
    2016:                 if (null !== $criteria) {
    2017:                     if (false !== $this->collImagesPartial && count($collImages)) {
    2018:                       $this->initImages(false);
    2019:
    2020:                       foreach($collImages as $obj) {
    2021:                         if (false == $this->collImages->contains($obj)) {
    2022:                           $this->collImages->append($obj);
    2023:                         }
    2024:                       }
    2025:
    2026:                       $this->collImagesPartial = true;
    2027:                     }
    2028:
    2029:                     $collImages->getInternalIterator()->rewind();
    2030:                     return $collImages;
    2031:                 }
    2032:
    2033:                 if($partial && $this->collImages) {
    2034:                     foreach($this->collImages as $obj) {
    2035:                         if($obj->isNew()) {
    2036:                             $collImages[] = $obj;
    2037:                         }
    2038:                     }
    2039:                 }
    2040:
    2041:                 $this->collImages = $collImages;
    2042:                 $this->collImagesPartial = false;
    2043:             }
    2044:         }
    2045:
    2046:         return $this->collImages;
    2047:     }
    2048:
    2049:     /**
    2050:      * Sets a collection of Image objects related by a one-to-many relationship
    2051:      * to the current object.
    2052:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    2053:      * and new objects from the given Propel collection.
    2054:      *
    2055:      * @param PropelCollection $images A Propel collection.
    2056:      * @param PropelPDO $con Optional connection object
    2057:      * @return Content The current object (for fluent API support)
    2058:      */
    2059:     public function setImages(PropelCollection $images, PropelPDO $con = null)
    2060:     {
    2061:         $imagesToDelete = $this->getImages(new Criteria(), $con)->diff($images);
    2062:
    2063:         $this->imagesScheduledForDeletion = unserialize(serialize($imagesToDelete));
    2064:
    2065:         foreach ($imagesToDelete as $imageRemoved) {
    2066:             $imageRemoved->setContent(null);
    2067:         }
    2068:
    2069:         $this->collImages = null;
    2070:         foreach ($images as $image) {
    2071:             $this->addImage($image);
    2072:         }
    2073:
    2074:         $this->collImages = $images;
    2075:         $this->collImagesPartial = false;
    2076:
    2077:         return $this;
    2078:     }
    2079:
    2080:     /**
    2081:      * Returns the number of related Image objects.
    2082:      *
    2083:      * @param Criteria $criteria
    2084:      * @param boolean $distinct
    2085:      * @param PropelPDO $con
    2086:      * @return int             Count of related Image objects.
    2087:      * @throws PropelException
    2088:      */
    2089:     public function countImages(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    2090:     {
    2091:         $partial = $this->collImagesPartial && !$this->isNew();
    2092:         if (null === $this->collImages || null !== $criteria || $partial) {
    2093:             if ($this->isNew() && null === $this->collImages) {
    2094:                 return 0;
    2095:             }
    2096:
    2097:             if($partial && !$criteria) {
    2098:                 return count($this->getImages());
    2099:             }
    2100:             $query = ImageQuery::create(null, $criteria);
    2101:             if ($distinct) {
    2102:                 $query->distinct();
    2103:             }
    2104:
    2105:             return $query
    2106:                 ->filterByContent($this)
    2107:                 ->count($con);
    2108:         }
    2109:
    2110:         return count($this->collImages);
    2111:     }
    2112:
    2113:     /**
    2114:      * Method called to associate a Image object to this object
    2115:      * through the Image foreign key attribute.
    2116:      *
    2117:      * @param    Image $l Image
    2118:      * @return Content The current object (for fluent API support)
    2119:      */
    2120:     public function addImage(Image $l)
    2121:     {
    2122:         if ($this->collImages === null) {
    2123:             $this->initImages();
    2124:             $this->collImagesPartial = true;
    2125:         }
    2126:         if (!in_array($l, $this->collImages->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    2127:             $this->doAddImage($l);
    2128:         }
    2129:
    2130:         return $this;
    2131:     }
    2132:
    2133:     /**
    2134:      * @param   Image $image The image object to add.
    2135:      */
    2136:     protected function doAddImage($image)
    2137:     {
    2138:         $this->collImages[]= $image;
    2139:         $image->setContent($this);
    2140:     }
    2141:
    2142:     /**
    2143:      * @param   Image $image The image object to remove.
    2144:      * @return Content The current object (for fluent API support)
    2145:      */
    2146:     public function removeImage($image)
    2147:     {
    2148:         if ($this->getImages()->contains($image)) {
    2149:             $this->collImages->remove($this->collImages->search($image));
    2150:             if (null === $this->imagesScheduledForDeletion) {
    2151:                 $this->imagesScheduledForDeletion = clone $this->collImages;
    2152:                 $this->imagesScheduledForDeletion->clear();
    2153:             }
    2154:             $this->imagesScheduledForDeletion[]= $image;
    2155:             $image->setContent(null);
    2156:         }
    2157:
    2158:         return $this;
    2159:     }
    2160:
    2161:
    2162:     /**
    2163:      * If this collection has already been initialized with
    2164:      * an identical criteria, it returns the collection.
    2165:      * Otherwise if this Content is new, it will return
    2166:      * an empty collection; or if this Content has previously
    2167:      * been saved, it will retrieve related Images from storage.
    2168:      *
    2169:      * This method is protected by default in order to keep the public
    2170:      * api reasonable.  You can provide public methods for those you
    2171:      * actually need in Content.
    2172:      *
    2173:      * @param Criteria $criteria optional Criteria object to narrow the query
    2174:      * @param PropelPDO $con optional connection object
    2175:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2176:      * @return PropelObjectCollection|Image[] List of Image objects
    2177:      */
    2178:     public function getImagesJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2179:     {
    2180:         $query = ImageQuery::create(null, $criteria);
    2181:         $query->joinWith('Product', $join_behavior);
    2182:
    2183:         return $this->getImages($query, $con);
    2184:     }
    2185:
    2186:
    2187:     /**
    2188:      * If this collection has already been initialized with
    2189:      * an identical criteria, it returns the collection.
    2190:      * Otherwise if this Content is new, it will return
    2191:      * an empty collection; or if this Content has previously
    2192:      * been saved, it will retrieve related Images from storage.
    2193:      *
    2194:      * This method is protected by default in order to keep the public
    2195:      * api reasonable.  You can provide public methods for those you
    2196:      * actually need in Content.
    2197:      *
    2198:      * @param Criteria $criteria optional Criteria object to narrow the query
    2199:      * @param PropelPDO $con optional connection object
    2200:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2201:      * @return PropelObjectCollection|Image[] List of Image objects
    2202:      */
    2203:     public function getImagesJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2204:     {
    2205:         $query = ImageQuery::create(null, $criteria);
    2206:         $query->joinWith('Category', $join_behavior);
    2207:
    2208:         return $this->getImages($query, $con);
    2209:     }
    2210:
    2211:
    2212:     /**
    2213:      * If this collection has already been initialized with
    2214:      * an identical criteria, it returns the collection.
    2215:      * Otherwise if this Content is new, it will return
    2216:      * an empty collection; or if this Content has previously
    2217:      * been saved, it will retrieve related Images from storage.
    2218:      *
    2219:      * This method is protected by default in order to keep the public
    2220:      * api reasonable.  You can provide public methods for those you
    2221:      * actually need in Content.
    2222:      *
    2223:      * @param Criteria $criteria optional Criteria object to narrow the query
    2224:      * @param PropelPDO $con optional connection object
    2225:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2226:      * @return PropelObjectCollection|Image[] List of Image objects
    2227:      */
    2228:     public function getImagesJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2229:     {
    2230:         $query = ImageQuery::create(null, $criteria);
    2231:         $query->joinWith('Folder', $join_behavior);
    2232:
    2233:         return $this->getImages($query, $con);
    2234:     }
    2235:
    2236:     /**
    2237:      * Clears out the collDocuments collection
    2238:      *
    2239:      * This does not modify the database; however, it will remove any associated objects, causing
    2240:      * them to be refetched by subsequent calls to accessor method.
    2241:      *
    2242:      * @return Content The current object (for fluent API support)
    2243:      * @see        addDocuments()
    2244:      */
    2245:     public function clearDocuments()
    2246:     {
    2247:         $this->collDocuments = null; // important to set this to null since that means it is uninitialized
    2248:         $this->collDocumentsPartial = null;
    2249:
    2250:         return $this;
    2251:     }
    2252:
    2253:     /**
    2254:      * reset is the collDocuments collection loaded partially
    2255:      *
    2256:      * @return void
    2257:      */
    2258:     public function resetPartialDocuments($v = true)
    2259:     {
    2260:         $this->collDocumentsPartial = $v;
    2261:     }
    2262:
    2263:     /**
    2264:      * Initializes the collDocuments collection.
    2265:      *
    2266:      * By default this just sets the collDocuments collection to an empty array (like clearcollDocuments());
    2267:      * however, you may wish to override this method in your stub class to provide setting appropriate
    2268:      * to your application -- for example, setting the initial array to the values stored in database.
    2269:      *
    2270:      * @param boolean $overrideExisting If set to true, the method call initializes
    2271:      *                                        the collection even if it is not empty
    2272:      *
    2273:      * @return void
    2274:      */
    2275:     public function initDocuments($overrideExisting = true)
    2276:     {
    2277:         if (null !== $this->collDocuments && !$overrideExisting) {
    2278:             return;
    2279:         }
    2280:         $this->collDocuments = new PropelObjectCollection();
    2281:         $this->collDocuments->setModel('Document');
    2282:     }
    2283:
    2284:     /**
    2285:      * Gets an array of Document objects which contain a foreign key that references this object.
    2286:      *
    2287:      * If the $criteria is not null, it is used to always fetch the results from the database.
    2288:      * Otherwise the results are fetched from the database the first time, then cached.
    2289:      * Next time the same method is called without $criteria, the cached collection is returned.
    2290:      * If this Content is new, it will return
    2291:      * an empty collection or the current collection; the criteria is ignored on a new object.
    2292:      *
    2293:      * @param Criteria $criteria optional Criteria object to narrow the query
    2294:      * @param PropelPDO $con optional connection object
    2295:      * @return PropelObjectCollection|Document[] List of Document objects
    2296:      * @throws PropelException
    2297:      */
    2298:     public function getDocuments($criteria = null, PropelPDO $con = null)
    2299:     {
    2300:         $partial = $this->collDocumentsPartial && !$this->isNew();
    2301:         if (null === $this->collDocuments || null !== $criteria  || $partial) {
    2302:             if ($this->isNew() && null === $this->collDocuments) {
    2303:                 // return empty collection
    2304:                 $this->initDocuments();
    2305:             } else {
    2306:                 $collDocuments = DocumentQuery::create(null, $criteria)
    2307:                     ->filterByContent($this)
    2308:                     ->find($con);
    2309:                 if (null !== $criteria) {
    2310:                     if (false !== $this->collDocumentsPartial && count($collDocuments)) {
    2311:                       $this->initDocuments(false);
    2312:
    2313:                       foreach($collDocuments as $obj) {
    2314:                         if (false == $this->collDocuments->contains($obj)) {
    2315:                           $this->collDocuments->append($obj);
    2316:                         }
    2317:                       }
    2318:
    2319:                       $this->collDocumentsPartial = true;
    2320:                     }
    2321:
    2322:                     $collDocuments->getInternalIterator()->rewind();
    2323:                     return $collDocuments;
    2324:                 }
    2325:
    2326:                 if($partial && $this->collDocuments) {
    2327:                     foreach($this->collDocuments as $obj) {
    2328:                         if($obj->isNew()) {
    2329:                             $collDocuments[] = $obj;
    2330:                         }
    2331:                     }
    2332:                 }
    2333:
    2334:                 $this->collDocuments = $collDocuments;
    2335:                 $this->collDocumentsPartial = false;
    2336:             }
    2337:         }
    2338:
    2339:         return $this->collDocuments;
    2340:     }
    2341:
    2342:     /**
    2343:      * Sets a collection of Document objects related by a one-to-many relationship
    2344:      * to the current object.
    2345:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    2346:      * and new objects from the given Propel collection.
    2347:      *
    2348:      * @param PropelCollection $documents A Propel collection.
    2349:      * @param PropelPDO $con Optional connection object
    2350:      * @return Content The current object (for fluent API support)
    2351:      */
    2352:     public function setDocuments(PropelCollection $documents, PropelPDO $con = null)
    2353:     {
    2354:         $documentsToDelete = $this->getDocuments(new Criteria(), $con)->diff($documents);
    2355:
    2356:         $this->documentsScheduledForDeletion = unserialize(serialize($documentsToDelete));
    2357:
    2358:         foreach ($documentsToDelete as $documentRemoved) {
    2359:             $documentRemoved->setContent(null);
    2360:         }
    2361:
    2362:         $this->collDocuments = null;
    2363:         foreach ($documents as $document) {
    2364:             $this->addDocument($document);
    2365:         }
    2366:
    2367:         $this->collDocuments = $documents;
    2368:         $this->collDocumentsPartial = false;
    2369:
    2370:         return $this;
    2371:     }
    2372:
    2373:     /**
    2374:      * Returns the number of related Document objects.
    2375:      *
    2376:      * @param Criteria $criteria
    2377:      * @param boolean $distinct
    2378:      * @param PropelPDO $con
    2379:      * @return int             Count of related Document objects.
    2380:      * @throws PropelException
    2381:      */
    2382:     public function countDocuments(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    2383:     {
    2384:         $partial = $this->collDocumentsPartial && !$this->isNew();
    2385:         if (null === $this->collDocuments || null !== $criteria || $partial) {
    2386:             if ($this->isNew() && null === $this->collDocuments) {
    2387:                 return 0;
    2388:             }
    2389:
    2390:             if($partial && !$criteria) {
    2391:                 return count($this->getDocuments());
    2392:             }
    2393:             $query = DocumentQuery::create(null, $criteria);
    2394:             if ($distinct) {
    2395:                 $query->distinct();
    2396:             }
    2397:
    2398:             return $query
    2399:                 ->filterByContent($this)
    2400:                 ->count($con);
    2401:         }
    2402:
    2403:         return count($this->collDocuments);
    2404:     }
    2405:
    2406:     /**
    2407:      * Method called to associate a Document object to this object
    2408:      * through the Document foreign key attribute.
    2409:      *
    2410:      * @param    Document $l Document
    2411:      * @return Content The current object (for fluent API support)
    2412:      */
    2413:     public function addDocument(Document $l)
    2414:     {
    2415:         if ($this->collDocuments === null) {
    2416:             $this->initDocuments();
    2417:             $this->collDocumentsPartial = true;
    2418:         }
    2419:         if (!in_array($l, $this->collDocuments->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    2420:             $this->doAddDocument($l);
    2421:         }
    2422:
    2423:         return $this;
    2424:     }
    2425:
    2426:     /**
    2427:      * @param   Document $document The document object to add.
    2428:      */
    2429:     protected function doAddDocument($document)
    2430:     {
    2431:         $this->collDocuments[]= $document;
    2432:         $document->setContent($this);
    2433:     }
    2434:
    2435:     /**
    2436:      * @param   Document $document The document object to remove.
    2437:      * @return Content The current object (for fluent API support)
    2438:      */
    2439:     public function removeDocument($document)
    2440:     {
    2441:         if ($this->getDocuments()->contains($document)) {
    2442:             $this->collDocuments->remove($this->collDocuments->search($document));
    2443:             if (null === $this->documentsScheduledForDeletion) {
    2444:                 $this->documentsScheduledForDeletion = clone $this->collDocuments;
    2445:                 $this->documentsScheduledForDeletion->clear();
    2446:             }
    2447:             $this->documentsScheduledForDeletion[]= $document;
    2448:             $document->setContent(null);
    2449:         }
    2450:
    2451:         return $this;
    2452:     }
    2453:
    2454:
    2455:     /**
    2456:      * If this collection has already been initialized with
    2457:      * an identical criteria, it returns the collection.
    2458:      * Otherwise if this Content is new, it will return
    2459:      * an empty collection; or if this Content has previously
    2460:      * been saved, it will retrieve related Documents from storage.
    2461:      *
    2462:      * This method is protected by default in order to keep the public
    2463:      * api reasonable.  You can provide public methods for those you
    2464:      * actually need in Content.
    2465:      *
    2466:      * @param Criteria $criteria optional Criteria object to narrow the query
    2467:      * @param PropelPDO $con optional connection object
    2468:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2469:      * @return PropelObjectCollection|Document[] List of Document objects
    2470:      */
    2471:     public function getDocumentsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2472:     {
    2473:         $query = DocumentQuery::create(null, $criteria);
    2474:         $query->joinWith('Product', $join_behavior);
    2475:
    2476:         return $this->getDocuments($query, $con);
    2477:     }
    2478:
    2479:
    2480:     /**
    2481:      * If this collection has already been initialized with
    2482:      * an identical criteria, it returns the collection.
    2483:      * Otherwise if this Content is new, it will return
    2484:      * an empty collection; or if this Content has previously
    2485:      * been saved, it will retrieve related Documents from storage.
    2486:      *
    2487:      * This method is protected by default in order to keep the public
    2488:      * api reasonable.  You can provide public methods for those you
    2489:      * actually need in Content.
    2490:      *
    2491:      * @param Criteria $criteria optional Criteria object to narrow the query
    2492:      * @param PropelPDO $con optional connection object
    2493:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2494:      * @return PropelObjectCollection|Document[] List of Document objects
    2495:      */
    2496:     public function getDocumentsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2497:     {
    2498:         $query = DocumentQuery::create(null, $criteria);
    2499:         $query->joinWith('Category', $join_behavior);
    2500:
    2501:         return $this->getDocuments($query, $con);
    2502:     }
    2503:
    2504:
    2505:     /**
    2506:      * If this collection has already been initialized with
    2507:      * an identical criteria, it returns the collection.
    2508:      * Otherwise if this Content is new, it will return
    2509:      * an empty collection; or if this Content has previously
    2510:      * been saved, it will retrieve related Documents from storage.
    2511:      *
    2512:      * This method is protected by default in order to keep the public
    2513:      * api reasonable.  You can provide public methods for those you
    2514:      * actually need in Content.
    2515:      *
    2516:      * @param Criteria $criteria optional Criteria object to narrow the query
    2517:      * @param PropelPDO $con optional connection object
    2518:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2519:      * @return PropelObjectCollection|Document[] List of Document objects
    2520:      */
    2521:     public function getDocumentsJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2522:     {
    2523:         $query = DocumentQuery::create(null, $criteria);
    2524:         $query->joinWith('Folder', $join_behavior);
    2525:
    2526:         return $this->getDocuments($query, $con);
    2527:     }
    2528:
    2529:     /**
    2530:      * Clears out the collRewritings collection
    2531:      *
    2532:      * This does not modify the database; however, it will remove any associated objects, causing
    2533:      * them to be refetched by subsequent calls to accessor method.
    2534:      *
    2535:      * @return Content The current object (for fluent API support)
    2536:      * @see        addRewritings()
    2537:      */
    2538:     public function clearRewritings()
    2539:     {
    2540:         $this->collRewritings = null; // important to set this to null since that means it is uninitialized
    2541:         $this->collRewritingsPartial = null;
    2542:
    2543:         return $this;
    2544:     }
    2545:
    2546:     /**
    2547:      * reset is the collRewritings collection loaded partially
    2548:      *
    2549:      * @return void
    2550:      */
    2551:     public function resetPartialRewritings($v = true)
    2552:     {
    2553:         $this->collRewritingsPartial = $v;
    2554:     }
    2555:
    2556:     /**
    2557:      * Initializes the collRewritings collection.
    2558:      *
    2559:      * By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
    2560:      * however, you may wish to override this method in your stub class to provide setting appropriate
    2561:      * to your application -- for example, setting the initial array to the values stored in database.
    2562:      *
    2563:      * @param boolean $overrideExisting If set to true, the method call initializes
    2564:      *                                        the collection even if it is not empty
    2565:      *
    2566:      * @return void
    2567:      */
    2568:     public function initRewritings($overrideExisting = true)
    2569:     {
    2570:         if (null !== $this->collRewritings && !$overrideExisting) {
    2571:             return;
    2572:         }
    2573:         $this->collRewritings = new PropelObjectCollection();
    2574:         $this->collRewritings->setModel('Rewriting');
    2575:     }
    2576:
    2577:     /**
    2578:      * Gets an array of Rewriting objects which contain a foreign key that references this object.
    2579:      *
    2580:      * If the $criteria is not null, it is used to always fetch the results from the database.
    2581:      * Otherwise the results are fetched from the database the first time, then cached.
    2582:      * Next time the same method is called without $criteria, the cached collection is returned.
    2583:      * If this Content is new, it will return
    2584:      * an empty collection or the current collection; the criteria is ignored on a new object.
    2585:      *
    2586:      * @param Criteria $criteria optional Criteria object to narrow the query
    2587:      * @param PropelPDO $con optional connection object
    2588:      * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
    2589:      * @throws PropelException
    2590:      */
    2591:     public function getRewritings($criteria = null, PropelPDO $con = null)
    2592:     {
    2593:         $partial = $this->collRewritingsPartial && !$this->isNew();
    2594:         if (null === $this->collRewritings || null !== $criteria  || $partial) {
    2595:             if ($this->isNew() && null === $this->collRewritings) {
    2596:                 // return empty collection
    2597:                 $this->initRewritings();
    2598:             } else {
    2599:                 $collRewritings = RewritingQuery::create(null, $criteria)
    2600:                     ->filterByContent($this)
    2601:                     ->find($con);
    2602:                 if (null !== $criteria) {
    2603:                     if (false !== $this->collRewritingsPartial && count($collRewritings)) {
    2604:                       $this->initRewritings(false);
    2605:
    2606:                       foreach($collRewritings as $obj) {
    2607:                         if (false == $this->collRewritings->contains($obj)) {
    2608:                           $this->collRewritings->append($obj);
    2609:                         }
    2610:                       }
    2611:
    2612:                       $this->collRewritingsPartial = true;
    2613:                     }
    2614:
    2615:                     $collRewritings->getInternalIterator()->rewind();
    2616:                     return $collRewritings;
    2617:                 }
    2618:
    2619:                 if($partial && $this->collRewritings) {
    2620:                     foreach($this->collRewritings as $obj) {
    2621:                         if($obj->isNew()) {
    2622:                             $collRewritings[] = $obj;
    2623:                         }
    2624:                     }
    2625:                 }
    2626:
    2627:                 $this->collRewritings = $collRewritings;
    2628:                 $this->collRewritingsPartial = false;
    2629:             }
    2630:         }
    2631:
    2632:         return $this->collRewritings;
    2633:     }
    2634:
    2635:     /**
    2636:      * Sets a collection of Rewriting objects related by a one-to-many relationship
    2637:      * to the current object.
    2638:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    2639:      * and new objects from the given Propel collection.
    2640:      *
    2641:      * @param PropelCollection $rewritings A Propel collection.
    2642:      * @param PropelPDO $con Optional connection object
    2643:      * @return Content The current object (for fluent API support)
    2644:      */
    2645:     public function setRewritings(PropelCollection $rewritings, PropelPDO $con = null)
    2646:     {
    2647:         $rewritingsToDelete = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
    2648:
    2649:         $this->rewritingsScheduledForDeletion = unserialize(serialize($rewritingsToDelete));
    2650:
    2651:         foreach ($rewritingsToDelete as $rewritingRemoved) {
    2652:             $rewritingRemoved->setContent(null);
    2653:         }
    2654:
    2655:         $this->collRewritings = null;
    2656:         foreach ($rewritings as $rewriting) {
    2657:             $this->addRewriting($rewriting);
    2658:         }
    2659:
    2660:         $this->collRewritings = $rewritings;
    2661:         $this->collRewritingsPartial = false;
    2662:
    2663:         return $this;
    2664:     }
    2665:
    2666:     /**
    2667:      * Returns the number of related Rewriting objects.
    2668:      *
    2669:      * @param Criteria $criteria
    2670:      * @param boolean $distinct
    2671:      * @param PropelPDO $con
    2672:      * @return int             Count of related Rewriting objects.
    2673:      * @throws PropelException
    2674:      */
    2675:     public function countRewritings(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    2676:     {
    2677:         $partial = $this->collRewritingsPartial && !$this->isNew();
    2678:         if (null === $this->collRewritings || null !== $criteria || $partial) {
    2679:             if ($this->isNew() && null === $this->collRewritings) {
    2680:                 return 0;
    2681:             }
    2682:
    2683:             if($partial && !$criteria) {
    2684:                 return count($this->getRewritings());
    2685:             }
    2686:             $query = RewritingQuery::create(null, $criteria);
    2687:             if ($distinct) {
    2688:                 $query->distinct();
    2689:             }
    2690:
    2691:             return $query
    2692:                 ->filterByContent($this)
    2693:                 ->count($con);
    2694:         }
    2695:
    2696:         return count($this->collRewritings);
    2697:     }
    2698:
    2699:     /**
    2700:      * Method called to associate a Rewriting object to this object
    2701:      * through the Rewriting foreign key attribute.
    2702:      *
    2703:      * @param    Rewriting $l Rewriting
    2704:      * @return Content The current object (for fluent API support)
    2705:      */
    2706:     public function addRewriting(Rewriting $l)
    2707:     {
    2708:         if ($this->collRewritings === null) {
    2709:             $this->initRewritings();
    2710:             $this->collRewritingsPartial = true;
    2711:         }
    2712:         if (!in_array($l, $this->collRewritings->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    2713:             $this->doAddRewriting($l);
    2714:         }
    2715:
    2716:         return $this;
    2717:     }
    2718:
    2719:     /**
    2720:      * @param   Rewriting $rewriting The rewriting object to add.
    2721:      */
    2722:     protected function doAddRewriting($rewriting)
    2723:     {
    2724:         $this->collRewritings[]= $rewriting;
    2725:         $rewriting->setContent($this);
    2726:     }
    2727:
    2728:     /**
    2729:      * @param   Rewriting $rewriting The rewriting object to remove.
    2730:      * @return Content The current object (for fluent API support)
    2731:      */
    2732:     public function removeRewriting($rewriting)
    2733:     {
    2734:         if ($this->getRewritings()->contains($rewriting)) {
    2735:             $this->collRewritings->remove($this->collRewritings->search($rewriting));
    2736:             if (null === $this->rewritingsScheduledForDeletion) {
    2737:                 $this->rewritingsScheduledForDeletion = clone $this->collRewritings;
    2738:                 $this->rewritingsScheduledForDeletion->clear();
    2739:             }
    2740:             $this->rewritingsScheduledForDeletion[]= $rewriting;
    2741:             $rewriting->setContent(null);
    2742:         }
    2743:
    2744:         return $this;
    2745:     }
    2746:
    2747:
    2748:     /**
    2749:      * If this collection has already been initialized with
    2750:      * an identical criteria, it returns the collection.
    2751:      * Otherwise if this Content is new, it will return
    2752:      * an empty collection; or if this Content has previously
    2753:      * been saved, it will retrieve related Rewritings from storage.
    2754:      *
    2755:      * This method is protected by default in order to keep the public
    2756:      * api reasonable.  You can provide public methods for those you
    2757:      * actually need in Content.
    2758:      *
    2759:      * @param Criteria $criteria optional Criteria object to narrow the query
    2760:      * @param PropelPDO $con optional connection object
    2761:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2762:      * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
    2763:      */
    2764:     public function getRewritingsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2765:     {
    2766:         $query = RewritingQuery::create(null, $criteria);
    2767:         $query->joinWith('Product', $join_behavior);
    2768:
    2769:         return $this->getRewritings($query, $con);
    2770:     }
    2771:
    2772:
    2773:     /**
    2774:      * If this collection has already been initialized with
    2775:      * an identical criteria, it returns the collection.
    2776:      * Otherwise if this Content is new, it will return
    2777:      * an empty collection; or if this Content has previously
    2778:      * been saved, it will retrieve related Rewritings from storage.
    2779:      *
    2780:      * This method is protected by default in order to keep the public
    2781:      * api reasonable.  You can provide public methods for those you
    2782:      * actually need in Content.
    2783:      *
    2784:      * @param Criteria $criteria optional Criteria object to narrow the query
    2785:      * @param PropelPDO $con optional connection object
    2786:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2787:      * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
    2788:      */
    2789:     public function getRewritingsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2790:     {
    2791:         $query = RewritingQuery::create(null, $criteria);
    2792:         $query->joinWith('Category', $join_behavior);
    2793:
    2794:         return $this->getRewritings($query, $con);
    2795:     }
    2796:
    2797:
    2798:     /**
    2799:      * If this collection has already been initialized with
    2800:      * an identical criteria, it returns the collection.
    2801:      * Otherwise if this Content is new, it will return
    2802:      * an empty collection; or if this Content has previously
    2803:      * been saved, it will retrieve related Rewritings from storage.
    2804:      *
    2805:      * This method is protected by default in order to keep the public
    2806:      * api reasonable.  You can provide public methods for those you
    2807:      * actually need in Content.
    2808:      *
    2809:      * @param Criteria $criteria optional Criteria object to narrow the query
    2810:      * @param PropelPDO $con optional connection object
    2811:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    2812:      * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
    2813:      */
    2814:     public function getRewritingsJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    2815:     {
    2816:         $query = RewritingQuery::create(null, $criteria);
    2817:         $query->joinWith('Folder', $join_behavior);
    2818:
    2819:         return $this->getRewritings($query, $con);
    2820:     }
    2821:
    2822:     /**
    2823:      * Clears out the collContentFolders collection
    2824:      *
    2825:      * This does not modify the database; however, it will remove any associated objects, causing
    2826:      * them to be refetched by subsequent calls to accessor method.
    2827:      *
    2828:      * @return Content The current object (for fluent API support)
    2829:      * @see        addContentFolders()
    2830:      */
    2831:     public function clearContentFolders()
    2832:     {
    2833:         $this->collContentFolders = null; // important to set this to null since that means it is uninitialized
    2834:         $this->collContentFoldersPartial = null;
    2835:
    2836:         return $this;
    2837:     }
    2838:
    2839:     /**
    2840:      * reset is the collContentFolders collection loaded partially
    2841:      *
    2842:      * @return void
    2843:      */
    2844:     public function resetPartialContentFolders($v = true)
    2845:     {
    2846:         $this->collContentFoldersPartial = $v;
    2847:     }
    2848:
    2849:     /**
    2850:      * Initializes the collContentFolders collection.
    2851:      *
    2852:      * By default this just sets the collContentFolders collection to an empty array (like clearcollContentFolders());
    2853:      * however, you may wish to override this method in your stub class to provide setting appropriate
    2854:      * to your application -- for example, setting the initial array to the values stored in database.
    2855:      *
    2856:      * @param boolean $overrideExisting If set to true, the method call initializes
    2857:      *                                        the collection even if it is not empty
    2858:      *
    2859:      * @return void
    2860:      */
    2861:     public function initContentFolders($overrideExisting = true)
    2862:     {
    2863:         if (null !== $this->collContentFolders && !$overrideExisting) {
    2864:             return;
    2865:         }
    2866:         $this->collContentFolders = new PropelObjectCollection();
    2867:         $this->collContentFolders->setModel('ContentFolder');
    2868:     }
    2869:
    2870:     /**
    2871:      * Gets an array of ContentFolder objects which contain a foreign key that references this object.
    2872:      *
    2873:      * If the $criteria is not null, it is used to always fetch the results from the database.
    2874:      * Otherwise the results are fetched from the database the first time, then cached.
    2875:      * Next time the same method is called without $criteria, the cached collection is returned.
    2876:      * If this Content is new, it will return
    2877:      * an empty collection or the current collection; the criteria is ignored on a new object.
    2878:      *
    2879:      * @param Criteria $criteria optional Criteria object to narrow the query
    2880:      * @param PropelPDO $con optional connection object
    2881:      * @return PropelObjectCollection|ContentFolder[] List of ContentFolder objects
    2882:      * @throws PropelException
    2883:      */
    2884:     public function getContentFolders($criteria = null, PropelPDO $con = null)
    2885:     {
    2886:         $partial = $this->collContentFoldersPartial && !$this->isNew();
    2887:         if (null === $this->collContentFolders || null !== $criteria  || $partial) {
    2888:             if ($this->isNew() && null === $this->collContentFolders) {
    2889:                 // return empty collection
    2890:                 $this->initContentFolders();
    2891:             } else {
    2892:                 $collContentFolders = ContentFolderQuery::create(null, $criteria)
    2893:                     ->filterByContent($this)
    2894:                     ->find($con);
    2895:                 if (null !== $criteria) {
    2896:                     if (false !== $this->collContentFoldersPartial && count($collContentFolders)) {
    2897:                       $this->initContentFolders(false);
    2898:
    2899:                       foreach($collContentFolders as $obj) {
    2900:                         if (false == $this->collContentFolders->contains($obj)) {
    2901:                           $this->collContentFolders->append($obj);
    2902:                         }
    2903:                       }
    2904:
    2905:                       $this->collContentFoldersPartial = true;
    2906:                     }
    2907:
    2908:                     $collContentFolders->getInternalIterator()->rewind();
    2909:                     return $collContentFolders;
    2910:                 }
    2911:
    2912:                 if($partial && $this->collContentFolders) {
    2913:                     foreach($this->collContentFolders as $obj) {
    2914:                         if($obj->isNew()) {
    2915:                             $collContentFolders[] = $obj;
    2916:                         }
    2917:                     }
    2918:                 }
    2919:
    2920:                 $this->collContentFolders = $collContentFolders;
    2921:                 $this->collContentFoldersPartial = false;
    2922:             }
    2923:         }
    2924:
    2925:         return $this->collContentFolders;
    2926:     }
    2927:
    2928:     /**
    2929:      * Sets a collection of ContentFolder objects related by a one-to-many relationship
    2930:      * to the current object.
    2931:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    2932:      * and new objects from the given Propel collection.
    2933:      *
    2934:      * @param PropelCollection $contentFolders A Propel collection.
    2935:      * @param PropelPDO $con Optional connection object
    2936:      * @return Content The current object (for fluent API support)
    2937:      */
    2938:     public function setContentFolders(PropelCollection $contentFolders, PropelPDO $con = null)
    2939:     {
    2940:         $contentFoldersToDelete = $this->getContentFolders(new Criteria(), $con)->diff($contentFolders);
    2941:
    2942:         $this->contentFoldersScheduledForDeletion = unserialize(serialize($contentFoldersToDelete));
    2943:
    2944:         foreach ($contentFoldersToDelete as $contentFolderRemoved) {
    2945:             $contentFolderRemoved->setContent(null);
    2946:         }
    2947:
    2948:         $this->collContentFolders = null;
    2949:         foreach ($contentFolders as $contentFolder) {
    2950:             $this->addContentFolder($contentFolder);
    2951:         }
    2952:
    2953:         $this->collContentFolders = $contentFolders;
    2954:         $this->collContentFoldersPartial = false;
    2955:
    2956:         return $this;
    2957:     }
    2958:
    2959:     /**
    2960:      * Returns the number of related ContentFolder objects.
    2961:      *
    2962:      * @param Criteria $criteria
    2963:      * @param boolean $distinct
    2964:      * @param PropelPDO $con
    2965:      * @return int             Count of related ContentFolder objects.
    2966:      * @throws PropelException
    2967:      */
    2968:     public function countContentFolders(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    2969:     {
    2970:         $partial = $this->collContentFoldersPartial && !$this->isNew();
    2971:         if (null === $this->collContentFolders || null !== $criteria || $partial) {
    2972:             if ($this->isNew() && null === $this->collContentFolders) {
    2973:                 return 0;
    2974:             }
    2975:
    2976:             if($partial && !$criteria) {
    2977:                 return count($this->getContentFolders());
    2978:             }
    2979:             $query = ContentFolderQuery::create(null, $criteria);
    2980:             if ($distinct) {
    2981:                 $query->distinct();
    2982:             }
    2983:
    2984:             return $query
    2985:                 ->filterByContent($this)
    2986:                 ->count($con);
    2987:         }
    2988:
    2989:         return count($this->collContentFolders);
    2990:     }
    2991:
    2992:     /**
    2993:      * Method called to associate a ContentFolder object to this object
    2994:      * through the ContentFolder foreign key attribute.
    2995:      *
    2996:      * @param    ContentFolder $l ContentFolder
    2997:      * @return Content The current object (for fluent API support)
    2998:      */
    2999:     public function addContentFolder(ContentFolder $l)
    3000:     {
    3001:         if ($this->collContentFolders === null) {
    3002:             $this->initContentFolders();
    3003:             $this->collContentFoldersPartial = true;
    3004:         }
    3005:         if (!in_array($l, $this->collContentFolders->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    3006:             $this->doAddContentFolder($l);
    3007:         }
    3008:
    3009:         return $this;
    3010:     }
    3011:
    3012:     /**
    3013:      * @param   ContentFolder $contentFolder The contentFolder object to add.
    3014:      */
    3015:     protected function doAddContentFolder($contentFolder)
    3016:     {
    3017:         $this->collContentFolders[]= $contentFolder;
    3018:         $contentFolder->setContent($this);
    3019:     }
    3020:
    3021:     /**
    3022:      * @param   ContentFolder $contentFolder The contentFolder object to remove.
    3023:      * @return Content The current object (for fluent API support)
    3024:      */
    3025:     public function removeContentFolder($contentFolder)
    3026:     {
    3027:         if ($this->getContentFolders()->contains($contentFolder)) {
    3028:             $this->collContentFolders->remove($this->collContentFolders->search($contentFolder));
    3029:             if (null === $this->contentFoldersScheduledForDeletion) {
    3030:                 $this->contentFoldersScheduledForDeletion = clone $this->collContentFolders;
    3031:                 $this->contentFoldersScheduledForDeletion->clear();
    3032:             }
    3033:             $this->contentFoldersScheduledForDeletion[]= clone $contentFolder;
    3034:             $contentFolder->setContent(null);
    3035:         }
    3036:
    3037:         return $this;
    3038:     }
    3039:
    3040:
    3041:     /**
    3042:      * If this collection has already been initialized with
    3043:      * an identical criteria, it returns the collection.
    3044:      * Otherwise if this Content is new, it will return
    3045:      * an empty collection; or if this Content has previously
    3046:      * been saved, it will retrieve related ContentFolders from storage.
    3047:      *
    3048:      * This method is protected by default in order to keep the public
    3049:      * api reasonable.  You can provide public methods for those you
    3050:      * actually need in Content.
    3051:      *
    3052:      * @param Criteria $criteria optional Criteria object to narrow the query
    3053:      * @param PropelPDO $con optional connection object
    3054:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
    3055:      * @return PropelObjectCollection|ContentFolder[] List of ContentFolder objects
    3056:      */
    3057:     public function getContentFoldersJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
    3058:     {
    3059:         $query = ContentFolderQuery::create(null, $criteria);
    3060:         $query->joinWith('Folder', $join_behavior);
    3061:
    3062:         return $this->getContentFolders($query, $con);
    3063:     }
    3064:
    3065:     /**
    3066:      * Clears out the collContentI18ns collection
    3067:      *
    3068:      * This does not modify the database; however, it will remove any associated objects, causing
    3069:      * them to be refetched by subsequent calls to accessor method.
    3070:      *
    3071:      * @return Content The current object (for fluent API support)
    3072:      * @see        addContentI18ns()
    3073:      */
    3074:     public function clearContentI18ns()
    3075:     {
    3076:         $this->collContentI18ns = null; // important to set this to null since that means it is uninitialized
    3077:         $this->collContentI18nsPartial = null;
    3078:
    3079:         return $this;
    3080:     }
    3081:
    3082:     /**
    3083:      * reset is the collContentI18ns collection loaded partially
    3084:      *
    3085:      * @return void
    3086:      */
    3087:     public function resetPartialContentI18ns($v = true)
    3088:     {
    3089:         $this->collContentI18nsPartial = $v;
    3090:     }
    3091:
    3092:     /**
    3093:      * Initializes the collContentI18ns collection.
    3094:      *
    3095:      * By default this just sets the collContentI18ns collection to an empty array (like clearcollContentI18ns());
    3096:      * however, you may wish to override this method in your stub class to provide setting appropriate
    3097:      * to your application -- for example, setting the initial array to the values stored in database.
    3098:      *
    3099:      * @param boolean $overrideExisting If set to true, the method call initializes
    3100:      *                                        the collection even if it is not empty
    3101:      *
    3102:      * @return void
    3103:      */
    3104:     public function initContentI18ns($overrideExisting = true)
    3105:     {
    3106:         if (null !== $this->collContentI18ns && !$overrideExisting) {
    3107:             return;
    3108:         }
    3109:         $this->collContentI18ns = new PropelObjectCollection();
    3110:         $this->collContentI18ns->setModel('ContentI18n');
    3111:     }
    3112:
    3113:     /**
    3114:      * Gets an array of ContentI18n objects which contain a foreign key that references this object.
    3115:      *
    3116:      * If the $criteria is not null, it is used to always fetch the results from the database.
    3117:      * Otherwise the results are fetched from the database the first time, then cached.
    3118:      * Next time the same method is called without $criteria, the cached collection is returned.
    3119:      * If this Content is new, it will return
    3120:      * an empty collection or the current collection; the criteria is ignored on a new object.
    3121:      *
    3122:      * @param Criteria $criteria optional Criteria object to narrow the query
    3123:      * @param PropelPDO $con optional connection object
    3124:      * @return PropelObjectCollection|ContentI18n[] List of ContentI18n objects
    3125:      * @throws PropelException
    3126:      */
    3127:     public function getContentI18ns($criteria = null, PropelPDO $con = null)
    3128:     {
    3129:         $partial = $this->collContentI18nsPartial && !$this->isNew();
    3130:         if (null === $this->collContentI18ns || null !== $criteria  || $partial) {
    3131:             if ($this->isNew() && null === $this->collContentI18ns) {
    3132:                 // return empty collection
    3133:                 $this->initContentI18ns();
    3134:             } else {
    3135:                 $collContentI18ns = ContentI18nQuery::create(null, $criteria)
    3136:                     ->filterByContent($this)
    3137:                     ->find($con);
    3138:                 if (null !== $criteria) {
    3139:                     if (false !== $this->collContentI18nsPartial && count($collContentI18ns)) {
    3140:                       $this->initContentI18ns(false);
    3141:
    3142:                       foreach($collContentI18ns as $obj) {
    3143:                         if (false == $this->collContentI18ns->contains($obj)) {
    3144:                           $this->collContentI18ns->append($obj);
    3145:                         }
    3146:                       }
    3147:
    3148:                       $this->collContentI18nsPartial = true;
    3149:                     }
    3150:
    3151:                     $collContentI18ns->getInternalIterator()->rewind();
    3152:                     return $collContentI18ns;
    3153:                 }
    3154:
    3155:                 if($partial && $this->collContentI18ns) {
    3156:                     foreach($this->collContentI18ns as $obj) {
    3157:                         if($obj->isNew()) {
    3158:                             $collContentI18ns[] = $obj;
    3159:                         }
    3160:                     }
    3161:                 }
    3162:
    3163:                 $this->collContentI18ns = $collContentI18ns;
    3164:                 $this->collContentI18nsPartial = false;
    3165:             }
    3166:         }
    3167:
    3168:         return $this->collContentI18ns;
    3169:     }
    3170:
    3171:     /**
    3172:      * Sets a collection of ContentI18n objects related by a one-to-many relationship
    3173:      * to the current object.
    3174:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    3175:      * and new objects from the given Propel collection.
    3176:      *
    3177:      * @param PropelCollection $contentI18ns A Propel collection.
    3178:      * @param PropelPDO $con Optional connection object
    3179:      * @return Content The current object (for fluent API support)
    3180:      */
    3181:     public function setContentI18ns(PropelCollection $contentI18ns, PropelPDO $con = null)
    3182:     {
    3183:         $contentI18nsToDelete = $this->getContentI18ns(new Criteria(), $con)->diff($contentI18ns);
    3184:
    3185:         $this->contentI18nsScheduledForDeletion = unserialize(serialize($contentI18nsToDelete));
    3186:
    3187:         foreach ($contentI18nsToDelete as $contentI18nRemoved) {
    3188:             $contentI18nRemoved->setContent(null);
    3189:         }
    3190:
    3191:         $this->collContentI18ns = null;
    3192:         foreach ($contentI18ns as $contentI18n) {
    3193:             $this->addContentI18n($contentI18n);
    3194:         }
    3195:
    3196:         $this->collContentI18ns = $contentI18ns;
    3197:         $this->collContentI18nsPartial = false;
    3198:
    3199:         return $this;
    3200:     }
    3201:
    3202:     /**
    3203:      * Returns the number of related ContentI18n objects.
    3204:      *
    3205:      * @param Criteria $criteria
    3206:      * @param boolean $distinct
    3207:      * @param PropelPDO $con
    3208:      * @return int             Count of related ContentI18n objects.
    3209:      * @throws PropelException
    3210:      */
    3211:     public function countContentI18ns(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    3212:     {
    3213:         $partial = $this->collContentI18nsPartial && !$this->isNew();
    3214:         if (null === $this->collContentI18ns || null !== $criteria || $partial) {
    3215:             if ($this->isNew() && null === $this->collContentI18ns) {
    3216:                 return 0;
    3217:             }
    3218:
    3219:             if($partial && !$criteria) {
    3220:                 return count($this->getContentI18ns());
    3221:             }
    3222:             $query = ContentI18nQuery::create(null, $criteria);
    3223:             if ($distinct) {
    3224:                 $query->distinct();
    3225:             }
    3226:
    3227:             return $query
    3228:                 ->filterByContent($this)
    3229:                 ->count($con);
    3230:         }
    3231:
    3232:         return count($this->collContentI18ns);
    3233:     }
    3234:
    3235:     /**
    3236:      * Method called to associate a ContentI18n object to this object
    3237:      * through the ContentI18n foreign key attribute.
    3238:      *
    3239:      * @param    ContentI18n $l ContentI18n
    3240:      * @return Content The current object (for fluent API support)
    3241:      */
    3242:     public function addContentI18n(ContentI18n $l)
    3243:     {
    3244:         if ($l && $locale = $l->getLocale()) {
    3245:             $this->setLocale($locale);
    3246:             $this->currentTranslations[$locale] = $l;
    3247:         }
    3248:         if ($this->collContentI18ns === null) {
    3249:             $this->initContentI18ns();
    3250:             $this->collContentI18nsPartial = true;
    3251:         }
    3252:         if (!in_array($l, $this->collContentI18ns->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    3253:             $this->doAddContentI18n($l);
    3254:         }
    3255:
    3256:         return $this;
    3257:     }
    3258:
    3259:     /**
    3260:      * @param   ContentI18n $contentI18n The contentI18n object to add.
    3261:      */
    3262:     protected function doAddContentI18n($contentI18n)
    3263:     {
    3264:         $this->collContentI18ns[]= $contentI18n;
    3265:         $contentI18n->setContent($this);
    3266:     }
    3267:
    3268:     /**
    3269:      * @param   ContentI18n $contentI18n The contentI18n object to remove.
    3270:      * @return Content The current object (for fluent API support)
    3271:      */
    3272:     public function removeContentI18n($contentI18n)
    3273:     {
    3274:         if ($this->getContentI18ns()->contains($contentI18n)) {
    3275:             $this->collContentI18ns->remove($this->collContentI18ns->search($contentI18n));
    3276:             if (null === $this->contentI18nsScheduledForDeletion) {
    3277:                 $this->contentI18nsScheduledForDeletion = clone $this->collContentI18ns;
    3278:                 $this->contentI18nsScheduledForDeletion->clear();
    3279:             }
    3280:             $this->contentI18nsScheduledForDeletion[]= clone $contentI18n;
    3281:             $contentI18n->setContent(null);
    3282:         }
    3283:
    3284:         return $this;
    3285:     }
    3286:
    3287:     /**
    3288:      * Clears out the collContentVersions collection
    3289:      *
    3290:      * This does not modify the database; however, it will remove any associated objects, causing
    3291:      * them to be refetched by subsequent calls to accessor method.
    3292:      *
    3293:      * @return Content The current object (for fluent API support)
    3294:      * @see        addContentVersions()
    3295:      */
    3296:     public function clearContentVersions()
    3297:     {
    3298:         $this->collContentVersions = null; // important to set this to null since that means it is uninitialized
    3299:         $this->collContentVersionsPartial = null;
    3300:
    3301:         return $this;
    3302:     }
    3303:
    3304:     /**
    3305:      * reset is the collContentVersions collection loaded partially
    3306:      *
    3307:      * @return void
    3308:      */
    3309:     public function resetPartialContentVersions($v = true)
    3310:     {
    3311:         $this->collContentVersionsPartial = $v;
    3312:     }
    3313:
    3314:     /**
    3315:      * Initializes the collContentVersions collection.
    3316:      *
    3317:      * By default this just sets the collContentVersions collection to an empty array (like clearcollContentVersions());
    3318:      * however, you may wish to override this method in your stub class to provide setting appropriate
    3319:      * to your application -- for example, setting the initial array to the values stored in database.
    3320:      *
    3321:      * @param boolean $overrideExisting If set to true, the method call initializes
    3322:      *                                        the collection even if it is not empty
    3323:      *
    3324:      * @return void
    3325:      */
    3326:     public function initContentVersions($overrideExisting = true)
    3327:     {
    3328:         if (null !== $this->collContentVersions && !$overrideExisting) {
    3329:             return;
    3330:         }
    3331:         $this->collContentVersions = new PropelObjectCollection();
    3332:         $this->collContentVersions->setModel('ContentVersion');
    3333:     }
    3334:
    3335:     /**
    3336:      * Gets an array of ContentVersion objects which contain a foreign key that references this object.
    3337:      *
    3338:      * If the $criteria is not null, it is used to always fetch the results from the database.
    3339:      * Otherwise the results are fetched from the database the first time, then cached.
    3340:      * Next time the same method is called without $criteria, the cached collection is returned.
    3341:      * If this Content is new, it will return
    3342:      * an empty collection or the current collection; the criteria is ignored on a new object.
    3343:      *
    3344:      * @param Criteria $criteria optional Criteria object to narrow the query
    3345:      * @param PropelPDO $con optional connection object
    3346:      * @return PropelObjectCollection|ContentVersion[] List of ContentVersion objects
    3347:      * @throws PropelException
    3348:      */
    3349:     public function getContentVersions($criteria = null, PropelPDO $con = null)
    3350:     {
    3351:         $partial = $this->collContentVersionsPartial && !$this->isNew();
    3352:         if (null === $this->collContentVersions || null !== $criteria  || $partial) {
    3353:             if ($this->isNew() && null === $this->collContentVersions) {
    3354:                 // return empty collection
    3355:                 $this->initContentVersions();
    3356:             } else {
    3357:                 $collContentVersions = ContentVersionQuery::create(null, $criteria)
    3358:                     ->filterByContent($this)
    3359:                     ->find($con);
    3360:                 if (null !== $criteria) {
    3361:                     if (false !== $this->collContentVersionsPartial && count($collContentVersions)) {
    3362:                       $this->initContentVersions(false);
    3363:
    3364:                       foreach($collContentVersions as $obj) {
    3365:                         if (false == $this->collContentVersions->contains($obj)) {
    3366:                           $this->collContentVersions->append($obj);
    3367:                         }
    3368:                       }
    3369:
    3370:                       $this->collContentVersionsPartial = true;
    3371:                     }
    3372:
    3373:                     $collContentVersions->getInternalIterator()->rewind();
    3374:                     return $collContentVersions;
    3375:                 }
    3376:
    3377:                 if($partial && $this->collContentVersions) {
    3378:                     foreach($this->collContentVersions as $obj) {
    3379:                         if($obj->isNew()) {
    3380:                             $collContentVersions[] = $obj;
    3381:                         }
    3382:                     }
    3383:                 }
    3384:
    3385:                 $this->collContentVersions = $collContentVersions;
    3386:                 $this->collContentVersionsPartial = false;
    3387:             }
    3388:         }
    3389:
    3390:         return $this->collContentVersions;
    3391:     }
    3392:
    3393:     /**
    3394:      * Sets a collection of ContentVersion objects related by a one-to-many relationship
    3395:      * to the current object.
    3396:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
    3397:      * and new objects from the given Propel collection.
    3398:      *
    3399:      * @param PropelCollection $contentVersions A Propel collection.
    3400:      * @param PropelPDO $con Optional connection object
    3401:      * @return Content The current object (for fluent API support)
    3402:      */
    3403:     public function setContentVersions(PropelCollection $contentVersions, PropelPDO $con = null)
    3404:     {
    3405:         $contentVersionsToDelete = $this->getContentVersions(new Criteria(), $con)->diff($contentVersions);
    3406:
    3407:         $this->contentVersionsScheduledForDeletion = unserialize(serialize($contentVersionsToDelete));
    3408:
    3409:         foreach ($contentVersionsToDelete as $contentVersionRemoved) {
    3410:             $contentVersionRemoved->setContent(null);
    3411:         }
    3412:
    3413:         $this->collContentVersions = null;
    3414:         foreach ($contentVersions as $contentVersion) {
    3415:             $this->addContentVersion($contentVersion);
    3416:         }
    3417:
    3418:         $this->collContentVersions = $contentVersions;
    3419:         $this->collContentVersionsPartial = false;
    3420:
    3421:         return $this;
    3422:     }
    3423:
    3424:     /**
    3425:      * Returns the number of related ContentVersion objects.
    3426:      *
    3427:      * @param Criteria $criteria
    3428:      * @param boolean $distinct
    3429:      * @param PropelPDO $con
    3430:      * @return int             Count of related ContentVersion objects.
    3431:      * @throws PropelException
    3432:      */
    3433:     public function countContentVersions(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
    3434:     {
    3435:         $partial = $this->collContentVersionsPartial && !$this->isNew();
    3436:         if (null === $this->collContentVersions || null !== $criteria || $partial) {
    3437:             if ($this->isNew() && null === $this->collContentVersions) {
    3438:                 return 0;
    3439:             }
    3440:
    3441:             if($partial && !$criteria) {
    3442:                 return count($this->getContentVersions());
    3443:             }
    3444:             $query = ContentVersionQuery::create(null, $criteria);
    3445:             if ($distinct) {
    3446:                 $query->distinct();
    3447:             }
    3448:
    3449:             return $query
    3450:                 ->filterByContent($this)
    3451:                 ->count($con);
    3452:         }
    3453:
    3454:         return count($this->collContentVersions);
    3455:     }
    3456:
    3457:     /**
    3458:      * Method called to associate a ContentVersion object to this object
    3459:      * through the ContentVersion foreign key attribute.
    3460:      *
    3461:      * @param    ContentVersion $l ContentVersion
    3462:      * @return Content The current object (for fluent API support)
    3463:      */
    3464:     public function addContentVersion(ContentVersion $l)
    3465:     {
    3466:         if ($this->collContentVersions === null) {
    3467:             $this->initContentVersions();
    3468:             $this->collContentVersionsPartial = true;
    3469:         }
    3470:         if (!in_array($l, $this->collContentVersions->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
    3471:             $this->doAddContentVersion($l);
    3472:         }
    3473:
    3474:         return $this;
    3475:     }
    3476:
    3477:     /**
    3478:      * @param   ContentVersion $contentVersion The contentVersion object to add.
    3479:      */
    3480:     protected function doAddContentVersion($contentVersion)
    3481:     {
    3482:         $this->collContentVersions[]= $contentVersion;
    3483:         $contentVersion->setContent($this);
    3484:     }
    3485:
    3486:     /**
    3487:      * @param   ContentVersion $contentVersion The contentVersion object to remove.
    3488:      * @return Content The current object (for fluent API support)
    3489:      */
    3490:     public function removeContentVersion($contentVersion)
    3491:     {
    3492:         if ($this->getContentVersions()->contains($contentVersion)) {
    3493:             $this->collContentVersions->remove($this->collContentVersions->search($contentVersion));
    3494:             if (null === $this->contentVersionsScheduledForDeletion) {
    3495:                 $this->contentVersionsScheduledForDeletion = clone $this->collContentVersions;
    3496:                 $this->contentVersionsScheduledForDeletion->clear();
    3497:             }
    3498:             $this->contentVersionsScheduledForDeletion[]= clone $contentVersion;
    3499:             $contentVersion->setContent(null);
    3500:         }
    3501:
    3502:         return $this;
    3503:     }
    3504:
    3505:     /**
    3506:      * Clears the current object and sets all attributes to their default values
    3507:      */
    3508:     public function clear()
    3509:     {
    3510:         $this->id = null;
    3511:         $this->visible = null;
    3512:         $this->position = null;
    3513:         $this->created_at = null;
    3514:         $this->updated_at = null;
    3515:         $this->version = null;
    3516:         $this->version_created_at = null;
    3517:         $this->version_created_by = null;
    3518:         $this->alreadyInSave = false;
    3519:         $this->alreadyInValidation = false;
    3520:         $this->alreadyInClearAllReferencesDeep = false;
    3521:         $this->clearAllReferences();
    3522:         $this->applyDefaultValues();
    3523:         $this->resetModified();
    3524:         $this->setNew(true);
    3525:         $this->setDeleted(false);
    3526:     }
    3527:
    3528:     /**
    3529:      * Resets all references to other model objects or collections of model objects.
    3530:      *
    3531:      * This method is a user-space workaround for PHP's inability to garbage collect
    3532:      * objects with circular references (even in PHP 5.3). This is currently necessary
    3533:      * when using Propel in certain daemon or large-volumne/high-memory operations.
    3534:      *
    3535:      * @param boolean $deep Whether to also clear the references on all referrer objects.
    3536:      */
    3537:     public function clearAllReferences($deep = false)
    3538:     {
    3539:         if ($deep && !$this->alreadyInClearAllReferencesDeep) {
    3540:             $this->alreadyInClearAllReferencesDeep = true;
    3541:             if ($this->collContentAssocs) {
    3542:                 foreach ($this->collContentAssocs as $o) {
    3543:                     $o->clearAllReferences($deep);
    3544:                 }
    3545:             }
    3546:             if ($this->collImages) {
    3547:                 foreach ($this->collImages as $o) {
    3548:                     $o->clearAllReferences($deep);
    3549:                 }
    3550:             }
    3551:             if ($this->collDocuments) {
    3552:                 foreach ($this->collDocuments as $o) {
    3553:                     $o->clearAllReferences($deep);
    3554:                 }
    3555:             }
    3556:             if ($this->collRewritings) {
    3557:                 foreach ($this->collRewritings as $o) {
    3558:                     $o->clearAllReferences($deep);
    3559:                 }
    3560:             }
    3561:             if ($this->collContentFolders) {
    3562:                 foreach ($this->collContentFolders as $o) {
    3563:                     $o->clearAllReferences($deep);
    3564:                 }
    3565:             }
    3566:             if ($this->collContentI18ns) {
    3567:                 foreach ($this->collContentI18ns as $o) {
    3568:                     $o->clearAllReferences($deep);
    3569:                 }
    3570:             }
    3571:             if ($this->collContentVersions) {
    3572:                 foreach ($this->collContentVersions as $o) {
    3573:                     $o->clearAllReferences($deep);
    3574:                 }
    3575:             }
    3576:
    3577:             $this->alreadyInClearAllReferencesDeep = false;
    3578:         } // if ($deep)
    3579:
    3580:         // i18n behavior
    3581:         $this->currentLocale = 'en_US';
    3582:         $this->currentTranslations = null;
    3583:
    3584:         if ($this->collContentAssocs instanceof PropelCollection) {
    3585:             $this->collContentAssocs->clearIterator();
    3586:         }
    3587:         $this->collContentAssocs = null;
    3588:         if ($this->collImages instanceof PropelCollection) {
    3589:             $this->collImages->clearIterator();
    3590:         }
    3591:         $this->collImages = null;
    3592:         if ($this->collDocuments instanceof PropelCollection) {
    3593:             $this->collDocuments->clearIterator();
    3594:         }
    3595:         $this->collDocuments = null;
    3596:         if ($this->collRewritings instanceof PropelCollection) {
    3597:             $this->collRewritings->clearIterator();
    3598:         }
    3599:         $this->collRewritings = null;
    3600:         if ($this->collContentFolders instanceof PropelCollection) {
    3601:             $this->collContentFolders->clearIterator();
    3602:         }
    3603:         $this->collContentFolders = null;
    3604:         if ($this->collContentI18ns instanceof PropelCollection) {
    3605:             $this->collContentI18ns->clearIterator();
    3606:         }
    3607:         $this->collContentI18ns = null;
    3608:         if ($this->collContentVersions instanceof PropelCollection) {
    3609:             $this->collContentVersions->clearIterator();
    3610:         }
    3611:         $this->collContentVersions = null;
    3612:     }
    3613:
    3614:     /**
    3615:      * return the string representation of this object
    3616:      *
    3617:      * @return string
    3618:      */
    3619:     public function __toString()
    3620:     {
    3621:         return (string) $this->exportTo(ContentPeer::DEFAULT_STRING_FORMAT);
    3622:     }
    3623:
    3624:     /**
    3625:      * return true is the object is in saving state
    3626:      *
    3627:      * @return boolean
    3628:      */
    3629:     public function isAlreadyInSave()
    3630:     {
    3631:         return $this->alreadyInSave;
    3632:     }
    3633:
    3634:     // timestampable behavior
    3635:
    3636:     /**
    3637:      * Mark the current object so that the update date doesn't get updated during next save
    3638:      *
    3639:      * @return     Content The current object (for fluent API support)
    3640:      */
    3641:     public function keepUpdateDateUnchanged()
    3642:     {
    3643:         $this->modifiedColumns[] = ContentPeer::UPDATED_AT;
    3644:
    3645:         return $this;
    3646:     }
    3647:
    3648:     // i18n behavior
    3649:
    3650:     /**
    3651:      * Sets the locale for translations
    3652:      *
    3653:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
    3654:      *
    3655:      * @return    Content The current object (for fluent API support)
    3656:      */
    3657:     public function setLocale($locale = 'en_US')
    3658:     {
    3659:         $this->currentLocale = $locale;
    3660:
    3661:         return $this;
    3662:     }
    3663:
    3664:     /**
    3665:      * Gets the locale for translations
    3666:      *
    3667:      * @return    string $locale Locale to use for the translation, e.g. 'fr_FR'
    3668:      */
    3669:     public function getLocale()
    3670:     {
    3671:         return $this->currentLocale;
    3672:     }
    3673:
    3674:     /**
    3675:      * Returns the current translation for a given locale
    3676:      *
    3677:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
    3678:      * @param     PropelPDO $con an optional connection object
    3679:      *
    3680:      * @return ContentI18n */
    3681:     public function getTranslation($locale = 'en_US', PropelPDO $con = null)
    3682:     {
    3683:         if (!isset($this->currentTranslations[$locale])) {
    3684:             if (null !== $this->collContentI18ns) {
    3685:                 foreach ($this->collContentI18ns as $translation) {
    3686:                     if ($translation->getLocale() == $locale) {
    3687:                         $this->currentTranslations[$locale] = $translation;
    3688:
    3689:                         return $translation;
    3690:                     }
    3691:                 }
    3692:             }
    3693:             if ($this->isNew()) {
    3694:                 $translation = new ContentI18n();
    3695:                 $translation->setLocale($locale);
    3696:             } else {
    3697:                 $translation = ContentI18nQuery::create()
    3698:                     ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
    3699:                     ->findOneOrCreate($con);
    3700:                 $this->currentTranslations[$locale] = $translation;
    3701:             }
    3702:             $this->addContentI18n($translation);
    3703:         }
    3704:
    3705:         return $this->currentTranslations[$locale];
    3706:     }
    3707:
    3708:     /**
    3709:      * Remove the translation for a given locale
    3710:      *
    3711:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
    3712:      * @param     PropelPDO $con an optional connection object
    3713:      *
    3714:      * @return    Content The current object (for fluent API support)
    3715:      */
    3716:     public function removeTranslation($locale = 'en_US', PropelPDO $con = null)
    3717:     {
    3718:         if (!$this->isNew()) {
    3719:             ContentI18nQuery::create()
    3720:                 ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
    3721:                 ->delete($con);
    3722:         }
    3723:         if (isset($this->currentTranslations[$locale])) {
    3724:             unset($this->currentTranslations[$locale]);
    3725:         }
    3726:         foreach ($this->collContentI18ns as $key => $translation) {
    3727:             if ($translation->getLocale() == $locale) {
    3728:                 unset($this->collContentI18ns[$key]);
    3729:                 break;
    3730:             }
    3731:         }
    3732:
    3733:         return $this;
    3734:     }
    3735:
    3736:     /**
    3737:      * Returns the current translation
    3738:      *
    3739:      * @param     PropelPDO $con an optional connection object
    3740:      *
    3741:      * @return ContentI18n */
    3742:     public function getCurrentTranslation(PropelPDO $con = null)
    3743:     {
    3744:         return $this->getTranslation($this->getLocale(), $con);
    3745:     }
    3746:
    3747:
    3748:         /**
    3749:          * Get the [title] column value.
    3750:          *
    3751:          * @return string
    3752:          */
    3753:         public function getTitle()
    3754:         {
    3755:         return $this->getCurrentTranslation()->getTitle();
    3756:     }
    3757:
    3758:
    3759:         /**
    3760:          * Set the value of [title] column.
    3761:          *
    3762:          * @param string $v new value
    3763:          * @return ContentI18n The current object (for fluent API support)
    3764:          */
    3765:         public function setTitle($v)
    3766:         {    $this->getCurrentTranslation()->setTitle($v);
    3767:
    3768:         return $this;
    3769:     }
    3770:
    3771:
    3772:         /**
    3773:          * Get the [description] column value.
    3774:          *
    3775:          * @return string
    3776:          */
    3777:         public function getDescription()
    3778:         {
    3779:         return $this->getCurrentTranslation()->getDescription();
    3780:     }
    3781:
    3782:
    3783:         /**
    3784:          * Set the value of [description] column.
    3785:          *
    3786:          * @param string $v new value
    3787:          * @return ContentI18n The current object (for fluent API support)
    3788:          */
    3789:         public function setDescription($v)
    3790:         {    $this->getCurrentTranslation()->setDescription($v);
    3791:
    3792:         return $this;
    3793:     }
    3794:
    3795:
    3796:         /**
    3797:          * Get the [chapo] column value.
    3798:          *
    3799:          * @return string
    3800:          */
    3801:         public function getChapo()
    3802:         {
    3803:         return $this->getCurrentTranslation()->getChapo();
    3804:     }
    3805:
    3806:
    3807:         /**
    3808:          * Set the value of [chapo] column.
    3809:          *
    3810:          * @param string $v new value
    3811:          * @return ContentI18n The current object (for fluent API support)
    3812:          */
    3813:         public function setChapo($v)
    3814:         {    $this->getCurrentTranslation()->setChapo($v);
    3815:
    3816:         return $this;
    3817:     }
    3818:
    3819:
    3820:         /**
    3821:          * Get the [postscriptum] column value.
    3822:          *
    3823:          * @return string
    3824:          */
    3825:         public function getPostscriptum()
    3826:         {
    3827:         return $this->getCurrentTranslation()->getPostscriptum();
    3828:     }
    3829:
    3830:
    3831:         /**
    3832:          * Set the value of [postscriptum] column.
    3833:          *
    3834:          * @param string $v new value
    3835:          * @return ContentI18n The current object (for fluent API support)
    3836:          */
    3837:         public function setPostscriptum($v)
    3838:         {    $this->getCurrentTranslation()->setPostscriptum($v);
    3839:
    3840:         return $this;
    3841:     }
    3842:
    3843:     // versionable behavior
    3844:
    3845:     /**
    3846:      * Enforce a new Version of this object upon next save.
    3847:      *
    3848:      * @return Content
    3849:      */
    3850:     public function enforceVersioning()
    3851:     {
    3852:         $this->enforceVersion = true;
    3853:
    3854:         return $this;
    3855:     }
    3856:
    3857:     /**
    3858:      * Checks whether the current state must be recorded as a version
    3859:      *
    3860:      * @param PropelPDO $con An optional PropelPDO connection to use.
    3861:      *
    3862:      * @return  boolean
    3863:      */
    3864:     public function isVersioningNecessary($con = null)
    3865:     {
    3866:         if ($this->alreadyInSave) {
    3867:             return false;
    3868:         }
    3869:
    3870:         if ($this->enforceVersion) {
    3871:             return true;
    3872:         }
    3873:
    3874:         if (ContentPeer::isVersioningEnabled() && ($this->isNew() || $this->isModified() || $this->isDeleted())) {
    3875:             return true;
    3876:         }
    3877:
    3878:         return false;
    3879:     }
    3880:
    3881:     /**
    3882:      * Creates a version of the current object and saves it.
    3883:      *
    3884:      * @param   PropelPDO $con the connection to use
    3885:      *
    3886:      * @return  ContentVersion A version object
    3887:      */
    3888:     public function addVersion($con = null)
    3889:     {
    3890:         $this->enforceVersion = false;
    3891:
    3892:         $version = new ContentVersion();
    3893:         $version->setId($this->getId());
    3894:         $version->setVisible($this->getVisible());
    3895:         $version->setPosition($this->getPosition());
    3896:         $version->setCreatedAt($this->getCreatedAt());
    3897:         $version->setUpdatedAt($this->getUpdatedAt());
    3898:         $version->setVersion($this->getVersion());
    3899:         $version->setVersionCreatedAt($this->getVersionCreatedAt());
    3900:         $version->setVersionCreatedBy($this->getVersionCreatedBy());
    3901:         $version->setContent($this);
    3902:         $version->save($con);
    3903:
    3904:         return $version;
    3905:     }
    3906:
    3907:     /**
    3908:      * Sets the properties of the curent object to the value they had at a specific version
    3909:      *
    3910:      * @param   integer $versionNumber The version number to read
    3911:      * @param   PropelPDO $con the connection to use
    3912:      *
    3913:      * @return  Content The current object (for fluent API support)
    3914:      * @throws  PropelException - if no object with the given version can be found.
    3915:      */
    3916:     public function toVersion($versionNumber, $con = null)
    3917:     {
    3918:         $version = $this->getOneVersion($versionNumber, $con);
    3919:         if (!$version) {
    3920:             throw new PropelException(sprintf('No Content object found with version %d', $version));
    3921:         }
    3922:         $this->populateFromVersion($version, $con);
    3923:
    3924:         return $this;
    3925:     }
    3926:
    3927:     /**
    3928:      * Sets the properties of the curent object to the value they had at a specific version
    3929:      *
    3930:      * @param   ContentVersion $version The version object to use
    3931:      * @param   PropelPDO $con the connection to use
    3932:      * @param   array $loadedObjects objects thats been loaded in a chain of populateFromVersion calls on referrer or fk objects.
    3933:      *
    3934:      * @return  Content The current object (for fluent API support)
    3935:      */
    3936:     public function populateFromVersion($version, $con = null, &$loadedObjects = array())
    3937:     {
    3938:
    3939:         $loadedObjects['Content'][$version->getId()][$version->getVersion()] = $this;
    3940:         $this->setId($version->getId());
    3941:         $this->setVisible($version->getVisible());
    3942:         $this->setPosition($version->getPosition());
    3943:         $this->setCreatedAt($version->getCreatedAt());
    3944:         $this->setUpdatedAt($version->getUpdatedAt());
    3945:         $this->setVersion($version->getVersion());
    3946:         $this->setVersionCreatedAt($version->getVersionCreatedAt());
    3947:         $this->setVersionCreatedBy($version->getVersionCreatedBy());
    3948:
    3949:         return $this;
    3950:     }
    3951:
    3952:     /**
    3953:      * Gets the latest persisted version number for the current object
    3954:      *
    3955:      * @param   PropelPDO $con the connection to use
    3956:      *
    3957:      * @return  integer
    3958:      */
    3959:     public function getLastVersionNumber($con = null)
    3960:     {
    3961:         $v = ContentVersionQuery::create()
    3962:             ->filterByContent($this)
    3963:             ->orderByVersion('desc')
    3964:             ->findOne($con);
    3965:         if (!$v) {
    3966:             return 0;
    3967:         }
    3968:
    3969:         return $v->getVersion();
    3970:     }
    3971:
    3972:     /**
    3973:      * Checks whether the current object is the latest one
    3974:      *
    3975:      * @param   PropelPDO $con the connection to use
    3976:      *
    3977:      * @return  boolean
    3978:      */
    3979:     public function isLastVersion($con = null)
    3980:     {
    3981:         return $this->getLastVersionNumber($con) == $this->getVersion();
    3982:     }
    3983:
    3984:     /**
    3985:      * Retrieves a version object for this entity and a version number
    3986:      *
    3987:      * @param   integer $versionNumber The version number to read
    3988:      * @param   PropelPDO $con the connection to use
    3989:      *
    3990:      * @return  ContentVersion A version object
    3991:      */
    3992:     public function getOneVersion($versionNumber, $con = null)
    3993:     {
    3994:         return ContentVersionQuery::create()
    3995:             ->filterByContent($this)
    3996:             ->filterByVersion($versionNumber)
    3997:             ->findOne($con);
    3998:     }
    3999:
    4000:     /**
    4001:      * Gets all the versions of this object, in incremental order
    4002:      *
    4003:      * @param   PropelPDO $con the connection to use
    4004:      *
    4005:      * @return  PropelObjectCollection A list of ContentVersion objects
    4006:      */
    4007:     public function getAllVersions($con = null)
    4008:     {
    4009:         $criteria = new Criteria();
    4010:         $criteria->addAscendingOrderByColumn(ContentVersionPeer::VERSION);
    4011:
    4012:         return $this->getContentVersions($criteria, $con);
    4013:     }
    4014:
    4015:     /**
    4016:      * Compares the current object with another of its version.
    4017:      * <code>
    4018:      * print_r($book->compareVersion(1));
    4019:      * => array(
    4020:      *   '1' => array('Title' => 'Book title at version 1'),
    4021:      *   '2' => array('Title' => 'Book title at version 2')
    4022:      * );
    4023:      * </code>
    4024:      *
    4025:      * @param   integer   $versionNumber
    4026:      * @param   string    $keys Main key used for the result diff (versions|columns)
    4027:      * @param   PropelPDO $con the connection to use
    4028:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
    4029:      *
    4030:      * @return  array A list of differences
    4031:      */
    4032:     public function compareVersion($versionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
    4033:     {
    4034:         $fromVersion = $this->toArray();
    4035:         $toVersion = $this->getOneVersion($versionNumber, $con)->toArray();
    4036:
    4037:         return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
    4038:     }
    4039:
    4040:     /**
    4041:      * Compares two versions of the current object.
    4042:      * <code>
    4043:      * print_r($book->compareVersions(1, 2));
    4044:      * => array(
    4045:      *   '1' => array('Title' => 'Book title at version 1'),
    4046:      *   '2' => array('Title' => 'Book title at version 2')
    4047:      * );
    4048:      * </code>
    4049:      *
    4050:      * @param   integer   $fromVersionNumber
    4051:      * @param   integer   $toVersionNumber
    4052:      * @param   string    $keys Main key used for the result diff (versions|columns)
    4053:      * @param   PropelPDO $con the connection to use
    4054:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
    4055:      *
    4056:      * @return  array A list of differences
    4057:      */
    4058:     public function compareVersions($fromVersionNumber, $toVersionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
    4059:     {
    4060:         $fromVersion = $this->getOneVersion($fromVersionNumber, $con)->toArray();
    4061:         $toVersion = $this->getOneVersion($toVersionNumber, $con)->toArray();
    4062:
    4063:         return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
    4064:     }
    4065:
    4066:     /**
    4067:      * Computes the diff between two versions.
    4068:      * <code>
    4069:      * print_r($this->computeDiff(1, 2));
    4070:      * => array(
    4071:      *   '1' => array('Title' => 'Book title at version 1'),
    4072:      *   '2' => array('Title' => 'Book title at version 2')
    4073:      * );
    4074:      * </code>
    4075:      *
    4076:      * @param   array     $fromVersion     An array representing the original version.
    4077:      * @param   array     $toVersion       An array representing the destination version.
    4078:      * @param   string    $keys            Main key used for the result diff (versions|columns).
    4079:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
    4080:      *
    4081:      * @return  array A list of differences
    4082:      */
    4083:     protected function computeDiff($fromVersion, $toVersion, $keys = 'columns', $ignoredColumns = array())
    4084:     {
    4085:         $fromVersionNumber = $fromVersion['Version'];
    4086:         $toVersionNumber = $toVersion['Version'];
    4087:         $ignoredColumns = array_merge(array(
    4088:             'Version',
    4089:             'VersionCreatedAt',
    4090:             'VersionCreatedBy',
    4091:         ), $ignoredColumns);
    4092:         $diff = array();
    4093:         foreach ($fromVersion as $key => $value) {
    4094:             if (in_array($key, $ignoredColumns)) {
    4095:                 continue;
    4096:             }
    4097:             if ($toVersion[$key] != $value) {
    4098:                 switch ($keys) {
    4099:                     case 'versions':
    4100:                         $diff[$fromVersionNumber][$key] = $value;
    4101:                         $diff[$toVersionNumber][$key] = $toVersion[$key];
    4102:                         break;
    4103:                     default:
    4104:                         $diff[$key] = array(
    4105:                             $fromVersionNumber => $value,
    4106:                             $toVersionNumber => $toVersion[$key],
    4107:                         );
    4108:                         break;
    4109:                 }
    4110:             }
    4111:         }
    4112:
    4113:         return $diff;
    4114:     }
    4115:     /**
    4116:      * retrieve the last $number versions.
    4117:      *
    4118:      * @param integer $number the number of record to return.
    4119:      * @param ContentVersionQuery|Criteria $criteria Additional criteria to filter.
    4120:      * @param PropelPDO $con An optional connection to use.
    4121:      *
    4122:      * @return PropelCollection|ContentVersion[] List of ContentVersion objects
    4123:      */
    4124:     public function getLastVersions($number = 10, $criteria = null, PropelPDO $con = null)
    4125:     {
    4126:         $criteria = ContentVersionQuery::create(null, $criteria);
    4127:         $criteria->addDescendingOrderByColumn(ContentVersionPeer::VERSION);
    4128:         $criteria->limit($number);
    4129:
    4130:         return $this->getContentVersions($criteria, $con);
    4131:     }
    4132: }
    4133: