Overview

---

   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\Message;
  19: use Thelia\Model\MessageI18n;
  20: use Thelia\Model\MessageI18nQuery;
  21: use Thelia\Model\MessagePeer;
  22: use Thelia\Model\MessageQuery;
  23: use Thelia\Model\MessageVersion;
  24: use Thelia\Model\MessageVersionPeer;
  25: use Thelia\Model\MessageVersionQuery;
  26: 
  27: /**
  28:  * Base class that represents a row from the 'message' table.
  29:  *
  30:  *
  31:  *
  32:  * @package    propel.generator.Thelia.Model.om
  33:  */
  34: abstract class BaseMessage extends BaseObject implements Persistent
  35: {
  36:     /**
  37:      * Peer class name
  38:      */
  39:     const PEER = 'Thelia\\Model\\MessagePeer';
  40: 
  41:     /**
  42:      * The Peer class.
  43:      * Instance provides a convenient way of calling static methods on a class
  44:      * that calling code may not be able to identify.
  45:      * @var        MessagePeer
  46:      */
  47:     protected static $peer;
  48: 
  49:     /**
  50:      * The flag var to prevent infinit loop in deep copy
  51:      * @var       boolean
  52:      */
  53:     protected $startCopy = false;
  54: 
  55:     /**
  56:      * The value for the id field.
  57:      * @var        int
  58:      */
  59:     protected $id;
  60: 
  61:     /**
  62:      * The value for the code field.
  63:      * @var        string
  64:      */
  65:     protected $code;
  66: 
  67:     /**
  68:      * The value for the secured field.
  69:      * @var        int
  70:      */
  71:     protected $secured;
  72: 
  73:     /**
  74:      * The value for the ref field.
  75:      * @var        string
  76:      */
  77:     protected $ref;
  78: 
  79:     /**
  80:      * The value for the created_at field.
  81:      * @var        string
  82:      */
  83:     protected $created_at;
  84: 
  85:     /**
  86:      * The value for the updated_at field.
  87:      * @var        string
  88:      */
  89:     protected $updated_at;
  90: 
  91:     /**
  92:      * The value for the version field.
  93:      * Note: this column has a database default value of: 0
  94:      * @var        int
  95:      */
  96:     protected $version;
  97: 
  98:     /**
  99:      * The value for the version_created_at field.
 100:      * @var        string
 101:      */
 102:     protected $version_created_at;
 103: 
 104:     /**
 105:      * The value for the version_created_by field.
 106:      * @var        string
 107:      */
 108:     protected $version_created_by;
 109: 
 110:     /**
 111:      * @var        PropelObjectCollection|MessageI18n[] Collection to store aggregation of MessageI18n objects.
 112:      */
 113:     protected $collMessageI18ns;
 114:     protected $collMessageI18nsPartial;
 115: 
 116:     /**
 117:      * @var        PropelObjectCollection|MessageVersion[] Collection to store aggregation of MessageVersion objects.
 118:      */
 119:     protected $collMessageVersions;
 120:     protected $collMessageVersionsPartial;
 121: 
 122:     /**
 123:      * Flag to prevent endless save loop, if this object is referenced
 124:      * by another object which falls in this transaction.
 125:      * @var        boolean
 126:      */
 127:     protected $alreadyInSave = false;
 128: 
 129:     /**
 130:      * Flag to prevent endless validation loop, if this object is referenced
 131:      * by another object which falls in this transaction.
 132:      * @var        boolean
 133:      */
 134:     protected $alreadyInValidation = false;
 135: 
 136:     /**
 137:      * Flag to prevent endless clearAllReferences($deep=true) loop, if this object is referenced
 138:      * @var        boolean
 139:      */
 140:     protected $alreadyInClearAllReferencesDeep = false;
 141: 
 142:     // i18n behavior
 143: 
 144:     /**
 145:      * Current locale
 146:      * @var        string
 147:      */
 148:     protected $currentLocale = 'en_US';
 149: 
 150:     /**
 151:      * Current translation objects
 152:      * @var        array[MessageI18n]
 153:      */
 154:     protected $currentTranslations;
 155: 
 156:     // versionable behavior
 157: 
 158: 
 159:     /**
 160:      * @var bool
 161:      */
 162:     protected $enforceVersion = false;
 163: 
 164:     /**
 165:      * An array of objects scheduled for deletion.
 166:      * @var     PropelObjectCollection
 167:      */
 168:     protected $messageI18nsScheduledForDeletion = null;
 169: 
 170:     /**
 171:      * An array of objects scheduled for deletion.
 172:      * @var     PropelObjectCollection
 173:      */
 174:     protected $messageVersionsScheduledForDeletion = null;
 175: 
 176:     /**
 177:      * Applies default values to this object.
 178:      * This method should be called from the object's constructor (or
 179:      * equivalent initialization method).
 180:      * @see        __construct()
 181:      */
 182:     public function applyDefaultValues()
 183:     {
 184:         $this->version = 0;
 185:     }
 186: 
 187:     /**
 188:      * Initializes internal state of BaseMessage object.
 189:      * @see        applyDefaults()
 190:      */
 191:     public function __construct()
 192:     {
 193:         parent::__construct();
 194:         $this->applyDefaultValues();
 195:     }
 196: 
 197:     /**
 198:      * Get the [id] column value.
 199:      *
 200:      * @return int
 201:      */
 202:     public function getId()
 203:     {
 204:         return $this->id;
 205:     }
 206: 
 207:     /**
 208:      * Get the [code] column value.
 209:      *
 210:      * @return string
 211:      */
 212:     public function getCode()
 213:     {
 214:         return $this->code;
 215:     }
 216: 
 217:     /**
 218:      * Get the [secured] column value.
 219:      *
 220:      * @return int
 221:      */
 222:     public function getSecured()
 223:     {
 224:         return $this->secured;
 225:     }
 226: 
 227:     /**
 228:      * Get the [ref] column value.
 229:      *
 230:      * @return string
 231:      */
 232:     public function getRef()
 233:     {
 234:         return $this->ref;
 235:     }
 236: 
 237:     /**
 238:      * Get the [optionally formatted] temporal [created_at] column value.
 239:      *
 240:      *
 241:      * @param string $format The date/time format string (either date()-style or strftime()-style).
 242:      *               If format is null, then the raw DateTime object will be returned.
 243:      * @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
 244:      * @throws PropelException - if unable to parse/validate the date/time value.
 245:      */
 246:     public function getCreatedAt($format = 'Y-m-d H:i:s')
 247:     {
 248:         if ($this->created_at === null) {
 249:             return null;
 250:         }
 251: 
 252:         if ($this->created_at === '0000-00-00 00:00:00') {
 253:             // while technically this is not a default value of null,
 254:             // this seems to be closest in meaning.
 255:             return null;
 256:         }
 257: 
 258:         try {
 259:             $dt = new DateTime($this->created_at);
 260:         } catch (Exception $x) {
 261:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
 262:         }
 263: 
 264:         if ($format === null) {
 265:             // Because propel.useDateTimeClass is true, we return a DateTime object.
 266:             return $dt;
 267:         }
 268: 
 269:         if (strpos($format, '%') !== false) {
 270:             return strftime($format, $dt->format('U'));
 271:         }
 272: 
 273:         return $dt->format($format);
 274: 
 275:     }
 276: 
 277:     /**
 278:      * Get the [optionally formatted] temporal [updated_at] column value.
 279:      *
 280:      *
 281:      * @param string $format The date/time format string (either date()-style or strftime()-style).
 282:      *               If format is null, then the raw DateTime object will be returned.
 283:      * @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
 284:      * @throws PropelException - if unable to parse/validate the date/time value.
 285:      */
 286:     public function getUpdatedAt($format = 'Y-m-d H:i:s')
 287:     {
 288:         if ($this->updated_at === null) {
 289:             return null;
 290:         }
 291: 
 292:         if ($this->updated_at === '0000-00-00 00:00:00') {
 293:             // while technically this is not a default value of null,
 294:             // this seems to be closest in meaning.
 295:             return null;
 296:         }
 297: 
 298:         try {
 299:             $dt = new DateTime($this->updated_at);
 300:         } catch (Exception $x) {
 301:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
 302:         }
 303: 
 304:         if ($format === null) {
 305:             // Because propel.useDateTimeClass is true, we return a DateTime object.
 306:             return $dt;
 307:         }
 308: 
 309:         if (strpos($format, '%') !== false) {
 310:             return strftime($format, $dt->format('U'));
 311:         }
 312: 
 313:         return $dt->format($format);
 314: 
 315:     }
 316: 
 317:     /**
 318:      * Get the [version] column value.
 319:      *
 320:      * @return int
 321:      */
 322:     public function getVersion()
 323:     {
 324:         return $this->version;
 325:     }
 326: 
 327:     /**
 328:      * Get the [optionally formatted] temporal [version_created_at] column value.
 329:      *
 330:      *
 331:      * @param string $format The date/time format string (either date()-style or strftime()-style).
 332:      *               If format is null, then the raw DateTime object will be returned.
 333:      * @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
 334:      * @throws PropelException - if unable to parse/validate the date/time value.
 335:      */
 336:     public function getVersionCreatedAt($format = 'Y-m-d H:i:s')
 337:     {
 338:         if ($this->version_created_at === null) {
 339:             return null;
 340:         }
 341: 
 342:         if ($this->version_created_at === '0000-00-00 00:00:00') {
 343:             // while technically this is not a default value of null,
 344:             // this seems to be closest in meaning.
 345:             return null;
 346:         }
 347: 
 348:         try {
 349:             $dt = new DateTime($this->version_created_at);
 350:         } catch (Exception $x) {
 351:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->version_created_at, true), $x);
 352:         }
 353: 
 354:         if ($format === null) {
 355:             // Because propel.useDateTimeClass is true, we return a DateTime object.
 356:             return $dt;
 357:         }
 358: 
 359:         if (strpos($format, '%') !== false) {
 360:             return strftime($format, $dt->format('U'));
 361:         }
 362: 
 363:         return $dt->format($format);
 364: 
 365:     }
 366: 
 367:     /**
 368:      * Get the [version_created_by] column value.
 369:      *
 370:      * @return string
 371:      */
 372:     public function getVersionCreatedBy()
 373:     {
 374:         return $this->version_created_by;
 375:     }
 376: 
 377:     /**
 378:      * Set the value of [id] column.
 379:      *
 380:      * @param int $v new value
 381:      * @return Message The current object (for fluent API support)
 382:      */
 383:     public function setId($v)
 384:     {
 385:         if ($v !== null && is_numeric($v)) {
 386:             $v = (int) $v;
 387:         }
 388: 
 389:         if ($this->id !== $v) {
 390:             $this->id = $v;
 391:             $this->modifiedColumns[] = MessagePeer::ID;
 392:         }
 393: 
 394: 
 395:         return $this;
 396:     } // setId()
 397: 
 398:     /**
 399:      * Set the value of [code] column.
 400:      *
 401:      * @param string $v new value
 402:      * @return Message The current object (for fluent API support)
 403:      */
 404:     public function setCode($v)
 405:     {
 406:         if ($v !== null && is_numeric($v)) {
 407:             $v = (string) $v;
 408:         }
 409: 
 410:         if ($this->code !== $v) {
 411:             $this->code = $v;
 412:             $this->modifiedColumns[] = MessagePeer::CODE;
 413:         }
 414: 
 415: 
 416:         return $this;
 417:     } // setCode()
 418: 
 419:     /**
 420:      * Set the value of [secured] column.
 421:      *
 422:      * @param int $v new value
 423:      * @return Message The current object (for fluent API support)
 424:      */
 425:     public function setSecured($v)
 426:     {
 427:         if ($v !== null && is_numeric($v)) {
 428:             $v = (int) $v;
 429:         }
 430: 
 431:         if ($this->secured !== $v) {
 432:             $this->secured = $v;
 433:             $this->modifiedColumns[] = MessagePeer::SECURED;
 434:         }
 435: 
 436: 
 437:         return $this;
 438:     } // setSecured()
 439: 
 440:     /**
 441:      * Set the value of [ref] column.
 442:      *
 443:      * @param string $v new value
 444:      * @return Message The current object (for fluent API support)
 445:      */
 446:     public function setRef($v)
 447:     {
 448:         if ($v !== null && is_numeric($v)) {
 449:             $v = (string) $v;
 450:         }
 451: 
 452:         if ($this->ref !== $v) {
 453:             $this->ref = $v;
 454:             $this->modifiedColumns[] = MessagePeer::REF;
 455:         }
 456: 
 457: 
 458:         return $this;
 459:     } // setRef()
 460: 
 461:     /**
 462:      * Sets the value of [created_at] column to a normalized version of the date/time value specified.
 463:      *
 464:      * @param mixed $v string, integer (timestamp), or DateTime value.
 465:      *               Empty strings are treated as null.
 466:      * @return Message The current object (for fluent API support)
 467:      */
 468:     public function setCreatedAt($v)
 469:     {
 470:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
 471:         if ($this->created_at !== null || $dt !== null) {
 472:             $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
 473:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
 474:             if ($currentDateAsString !== $newDateAsString) {
 475:                 $this->created_at = $newDateAsString;
 476:                 $this->modifiedColumns[] = MessagePeer::CREATED_AT;
 477:             }
 478:         } // if either are not null
 479: 
 480: 
 481:         return $this;
 482:     } // setCreatedAt()
 483: 
 484:     /**
 485:      * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
 486:      *
 487:      * @param mixed $v string, integer (timestamp), or DateTime value.
 488:      *               Empty strings are treated as null.
 489:      * @return Message The current object (for fluent API support)
 490:      */
 491:     public function setUpdatedAt($v)
 492:     {
 493:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
 494:         if ($this->updated_at !== null || $dt !== null) {
 495:             $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
 496:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
 497:             if ($currentDateAsString !== $newDateAsString) {
 498:                 $this->updated_at = $newDateAsString;
 499:                 $this->modifiedColumns[] = MessagePeer::UPDATED_AT;
 500:             }
 501:         } // if either are not null
 502: 
 503: 
 504:         return $this;
 505:     } // setUpdatedAt()
 506: 
 507:     /**
 508:      * Set the value of [version] column.
 509:      *
 510:      * @param int $v new value
 511:      * @return Message The current object (for fluent API support)
 512:      */
 513:     public function setVersion($v)
 514:     {
 515:         if ($v !== null && is_numeric($v)) {
 516:             $v = (int) $v;
 517:         }
 518: 
 519:         if ($this->version !== $v) {
 520:             $this->version = $v;
 521:             $this->modifiedColumns[] = MessagePeer::VERSION;
 522:         }
 523: 
 524: 
 525:         return $this;
 526:     } // setVersion()
 527: 
 528:     /**
 529:      * Sets the value of [version_created_at] column to a normalized version of the date/time value specified.
 530:      *
 531:      * @param mixed $v string, integer (timestamp), or DateTime value.
 532:      *               Empty strings are treated as null.
 533:      * @return Message The current object (for fluent API support)
 534:      */
 535:     public function setVersionCreatedAt($v)
 536:     {
 537:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
 538:         if ($this->version_created_at !== null || $dt !== null) {
 539:             $currentDateAsString = ($this->version_created_at !== null && $tmpDt = new DateTime($this->version_created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
 540:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
 541:             if ($currentDateAsString !== $newDateAsString) {
 542:                 $this->version_created_at = $newDateAsString;
 543:                 $this->modifiedColumns[] = MessagePeer::VERSION_CREATED_AT;
 544:             }
 545:         } // if either are not null
 546: 
 547: 
 548:         return $this;
 549:     } // setVersionCreatedAt()
 550: 
 551:     /**
 552:      * Set the value of [version_created_by] column.
 553:      *
 554:      * @param string $v new value
 555:      * @return Message The current object (for fluent API support)
 556:      */
 557:     public function setVersionCreatedBy($v)
 558:     {
 559:         if ($v !== null && is_numeric($v)) {
 560:             $v = (string) $v;
 561:         }
 562: 
 563:         if ($this->version_created_by !== $v) {
 564:             $this->version_created_by = $v;
 565:             $this->modifiedColumns[] = MessagePeer::VERSION_CREATED_BY;
 566:         }
 567: 
 568: 
 569:         return $this;
 570:     } // setVersionCreatedBy()
 571: 
 572:     /**
 573:      * Indicates whether the columns in this object are only set to default values.
 574:      *
 575:      * This method can be used in conjunction with isModified() to indicate whether an object is both
 576:      * modified _and_ has some values set which are non-default.
 577:      *
 578:      * @return boolean Whether the columns in this object are only been set with default values.
 579:      */
 580:     public function hasOnlyDefaultValues()
 581:     {
 582:             if ($this->version !== 0) {
 583:                 return false;
 584:             }
 585: 
 586:         // otherwise, everything was equal, so return true
 587:         return true;
 588:     } // hasOnlyDefaultValues()
 589: 
 590:     /**
 591:      * Hydrates (populates) the object variables with values from the database resultset.
 592:      *
 593:      * An offset (0-based "start column") is specified so that objects can be hydrated
 594:      * with a subset of the columns in the resultset rows.  This is needed, for example,
 595:      * for results of JOIN queries where the resultset row includes columns from two or
 596:      * more tables.
 597:      *
 598:      * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
 599:      * @param int $startcol 0-based offset column which indicates which restultset column to start with.
 600:      * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
 601:      * @return int             next starting column
 602:      * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
 603:      */
 604:     public function hydrate($row, $startcol = 0, $rehydrate = false)
 605:     {
 606:         try {
 607: 
 608:             $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
 609:             $this->code = ($row[$startcol + 1] !== null) ? (string) $row[$startcol + 1] : null;
 610:             $this->secured = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
 611:             $this->ref = ($row[$startcol + 3] !== null) ? (string) $row[$startcol + 3] : null;
 612:             $this->created_at = ($row[$startcol + 4] !== null) ? (string) $row[$startcol + 4] : null;
 613:             $this->updated_at = ($row[$startcol + 5] !== null) ? (string) $row[$startcol + 5] : null;
 614:             $this->version = ($row[$startcol + 6] !== null) ? (int) $row[$startcol + 6] : null;
 615:             $this->version_created_at = ($row[$startcol + 7] !== null) ? (string) $row[$startcol + 7] : null;
 616:             $this->version_created_by = ($row[$startcol + 8] !== null) ? (string) $row[$startcol + 8] : null;
 617:             $this->resetModified();
 618: 
 619:             $this->setNew(false);
 620: 
 621:             if ($rehydrate) {
 622:                 $this->ensureConsistency();
 623:             }
 624:             $this->postHydrate($row, $startcol, $rehydrate);
 625:             return $startcol + 9; // 9 = MessagePeer::NUM_HYDRATE_COLUMNS.
 626: 
 627:         } catch (Exception $e) {
 628:             throw new PropelException("Error populating Message object", $e);
 629:         }
 630:     }
 631: 
 632:     /**
 633:      * Checks and repairs the internal consistency of the object.
 634:      *
 635:      * This method is executed after an already-instantiated object is re-hydrated
 636:      * from the database.  It exists to check any foreign keys to make sure that
 637:      * the objects related to the current object are correct based on foreign key.
 638:      *
 639:      * You can override this method in the stub class, but you should always invoke
 640:      * the base method from the overridden method (i.e. parent::ensureConsistency()),
 641:      * in case your model changes.
 642:      *
 643:      * @throws PropelException
 644:      */
 645:     public function ensureConsistency()
 646:     {
 647: 
 648:     } // ensureConsistency
 649: 
 650:     /**
 651:      * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
 652:      *
 653:      * This will only work if the object has been saved and has a valid primary key set.
 654:      *
 655:      * @param boolean $deep (optional) Whether to also de-associated any related objects.
 656:      * @param PropelPDO $con (optional) The PropelPDO connection to use.
 657:      * @return void
 658:      * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
 659:      */
 660:     public function reload($deep = false, PropelPDO $con = null)
 661:     {
 662:         if ($this->isDeleted()) {
 663:             throw new PropelException("Cannot reload a deleted object.");
 664:         }
 665: 
 666:         if ($this->isNew()) {
 667:             throw new PropelException("Cannot reload an unsaved object.");
 668:         }
 669: 
 670:         if ($con === null) {
 671:             $con = Propel::getConnection(MessagePeer::DATABASE_NAME, Propel::CONNECTION_READ);
 672:         }
 673: 
 674:         // We don't need to alter the object instance pool; we're just modifying this instance
 675:         // already in the pool.
 676: 
 677:         $stmt = MessagePeer::doSelectStmt($this->buildPkeyCriteria(), $con);
 678:         $row = $stmt->fetch(PDO::FETCH_NUM);
 679:         $stmt->closeCursor();
 680:         if (!$row) {
 681:             throw new PropelException('Cannot find matching row in the database to reload object values.');
 682:         }
 683:         $this->hydrate($row, 0, true); // rehydrate
 684: 
 685:         if ($deep) {  // also de-associate any related objects?
 686: 
 687:             $this->collMessageI18ns = null;
 688: 
 689:             $this->collMessageVersions = null;
 690: 
 691:         } // if (deep)
 692:     }
 693: 
 694:     /**
 695:      * Removes this object from datastore and sets delete attribute.
 696:      *
 697:      * @param PropelPDO $con
 698:      * @return void
 699:      * @throws PropelException
 700:      * @throws Exception
 701:      * @see        BaseObject::setDeleted()
 702:      * @see        BaseObject::isDeleted()
 703:      */
 704:     public function delete(PropelPDO $con = null)
 705:     {
 706:         if ($this->isDeleted()) {
 707:             throw new PropelException("This object has already been deleted.");
 708:         }
 709: 
 710:         if ($con === null) {
 711:             $con = Propel::getConnection(MessagePeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
 712:         }
 713: 
 714:         $con->beginTransaction();
 715:         try {
 716:             $deleteQuery = MessageQuery::create()
 717:                 ->filterByPrimaryKey($this->getPrimaryKey());
 718:             $ret = $this->preDelete($con);
 719:             if ($ret) {
 720:                 $deleteQuery->delete($con);
 721:                 $this->postDelete($con);
 722:                 $con->commit();
 723:                 $this->setDeleted(true);
 724:             } else {
 725:                 $con->commit();
 726:             }
 727:         } catch (Exception $e) {
 728:             $con->rollBack();
 729:             throw $e;
 730:         }
 731:     }
 732: 
 733:     /**
 734:      * Persists this object to the database.
 735:      *
 736:      * If the object is new, it inserts it; otherwise an update is performed.
 737:      * All modified related objects will also be persisted in the doSave()
 738:      * method.  This method wraps all precipitate database operations in a
 739:      * single transaction.
 740:      *
 741:      * @param PropelPDO $con
 742:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
 743:      * @throws PropelException
 744:      * @throws Exception
 745:      * @see        doSave()
 746:      */
 747:     public function save(PropelPDO $con = null)
 748:     {
 749:         if ($this->isDeleted()) {
 750:             throw new PropelException("You cannot save an object that has been deleted.");
 751:         }
 752: 
 753:         if ($con === null) {
 754:             $con = Propel::getConnection(MessagePeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
 755:         }
 756: 
 757:         $con->beginTransaction();
 758:         $isInsert = $this->isNew();
 759:         try {
 760:             $ret = $this->preSave($con);
 761:             // versionable behavior
 762:             if ($this->isVersioningNecessary()) {
 763:                 $this->setVersion($this->isNew() ? 1 : $this->getLastVersionNumber($con) + 1);
 764:                 if (!$this->isColumnModified(MessagePeer::VERSION_CREATED_AT)) {
 765:                     $this->setVersionCreatedAt(time());
 766:                 }
 767:                 $createVersion = true; // for postSave hook
 768:             }
 769:             if ($isInsert) {
 770:                 $ret = $ret && $this->preInsert($con);
 771:                 // timestampable behavior
 772:                 if (!$this->isColumnModified(MessagePeer::CREATED_AT)) {
 773:                     $this->setCreatedAt(time());
 774:                 }
 775:                 if (!$this->isColumnModified(MessagePeer::UPDATED_AT)) {
 776:                     $this->setUpdatedAt(time());
 777:                 }
 778:             } else {
 779:                 $ret = $ret && $this->preUpdate($con);
 780:                 // timestampable behavior
 781:                 if ($this->isModified() && !$this->isColumnModified(MessagePeer::UPDATED_AT)) {
 782:                     $this->setUpdatedAt(time());
 783:                 }
 784:             }
 785:             if ($ret) {
 786:                 $affectedRows = $this->doSave($con);
 787:                 if ($isInsert) {
 788:                     $this->postInsert($con);
 789:                 } else {
 790:                     $this->postUpdate($con);
 791:                 }
 792:                 $this->postSave($con);
 793:                 // versionable behavior
 794:                 if (isset($createVersion)) {
 795:                     $this->addVersion($con);
 796:                 }
 797:                 MessagePeer::addInstanceToPool($this);
 798:             } else {
 799:                 $affectedRows = 0;
 800:             }
 801:             $con->commit();
 802: 
 803:             return $affectedRows;
 804:         } catch (Exception $e) {
 805:             $con->rollBack();
 806:             throw $e;
 807:         }
 808:     }
 809: 
 810:     /**
 811:      * Performs the work of inserting or updating the row in the database.
 812:      *
 813:      * If the object is new, it inserts it; otherwise an update is performed.
 814:      * All related objects are also updated in this method.
 815:      *
 816:      * @param PropelPDO $con
 817:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
 818:      * @throws PropelException
 819:      * @see        save()
 820:      */
 821:     protected function doSave(PropelPDO $con)
 822:     {
 823:         $affectedRows = 0; // initialize var to track total num of affected rows
 824:         if (!$this->alreadyInSave) {
 825:             $this->alreadyInSave = true;
 826: 
 827:             if ($this->isNew() || $this->isModified()) {
 828:                 // persist changes
 829:                 if ($this->isNew()) {
 830:                     $this->doInsert($con);
 831:                 } else {
 832:                     $this->doUpdate($con);
 833:                 }
 834:                 $affectedRows += 1;
 835:                 $this->resetModified();
 836:             }
 837: 
 838:             if ($this->messageI18nsScheduledForDeletion !== null) {
 839:                 if (!$this->messageI18nsScheduledForDeletion->isEmpty()) {
 840:                     MessageI18nQuery::create()
 841:                         ->filterByPrimaryKeys($this->messageI18nsScheduledForDeletion->getPrimaryKeys(false))
 842:                         ->delete($con);
 843:                     $this->messageI18nsScheduledForDeletion = null;
 844:                 }
 845:             }
 846: 
 847:             if ($this->collMessageI18ns !== null) {
 848:                 foreach ($this->collMessageI18ns as $referrerFK) {
 849:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
 850:                         $affectedRows += $referrerFK->save($con);
 851:                     }
 852:                 }
 853:             }
 854: 
 855:             if ($this->messageVersionsScheduledForDeletion !== null) {
 856:                 if (!$this->messageVersionsScheduledForDeletion->isEmpty()) {
 857:                     MessageVersionQuery::create()
 858:                         ->filterByPrimaryKeys($this->messageVersionsScheduledForDeletion->getPrimaryKeys(false))
 859:                         ->delete($con);
 860:                     $this->messageVersionsScheduledForDeletion = null;
 861:                 }
 862:             }
 863: 
 864:             if ($this->collMessageVersions !== null) {
 865:                 foreach ($this->collMessageVersions as $referrerFK) {
 866:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
 867:                         $affectedRows += $referrerFK->save($con);
 868:                     }
 869:                 }
 870:             }
 871: 
 872:             $this->alreadyInSave = false;
 873: 
 874:         }
 875: 
 876:         return $affectedRows;
 877:     } // doSave()
 878: 
 879:     /**
 880:      * Insert the row in the database.
 881:      *
 882:      * @param PropelPDO $con
 883:      *
 884:      * @throws PropelException
 885:      * @see        doSave()
 886:      */
 887:     protected function doInsert(PropelPDO $con)
 888:     {
 889:         $modifiedColumns = array();
 890:         $index = 0;
 891: 
 892:         $this->modifiedColumns[] = MessagePeer::ID;
 893:         if (null !== $this->id) {
 894:             throw new PropelException('Cannot insert a value for auto-increment primary key (' . MessagePeer::ID . ')');
 895:         }
 896: 
 897:          // check the columns in natural order for more readable SQL queries
 898:         if ($this->isColumnModified(MessagePeer::ID)) {
 899:             $modifiedColumns[':p' . $index++]  = '`id`';
 900:         }
 901:         if ($this->isColumnModified(MessagePeer::CODE)) {
 902:             $modifiedColumns[':p' . $index++]  = '`code`';
 903:         }
 904:         if ($this->isColumnModified(MessagePeer::SECURED)) {
 905:             $modifiedColumns[':p' . $index++]  = '`secured`';
 906:         }
 907:         if ($this->isColumnModified(MessagePeer::REF)) {
 908:             $modifiedColumns[':p' . $index++]  = '`ref`';
 909:         }
 910:         if ($this->isColumnModified(MessagePeer::CREATED_AT)) {
 911:             $modifiedColumns[':p' . $index++]  = '`created_at`';
 912:         }
 913:         if ($this->isColumnModified(MessagePeer::UPDATED_AT)) {
 914:             $modifiedColumns[':p' . $index++]  = '`updated_at`';
 915:         }
 916:         if ($this->isColumnModified(MessagePeer::VERSION)) {
 917:             $modifiedColumns[':p' . $index++]  = '`version`';
 918:         }
 919:         if ($this->isColumnModified(MessagePeer::VERSION_CREATED_AT)) {
 920:             $modifiedColumns[':p' . $index++]  = '`version_created_at`';
 921:         }
 922:         if ($this->isColumnModified(MessagePeer::VERSION_CREATED_BY)) {
 923:             $modifiedColumns[':p' . $index++]  = '`version_created_by`';
 924:         }
 925: 
 926:         $sql = sprintf(
 927:             'INSERT INTO `message` (%s) VALUES (%s)',
 928:             implode(', ', $modifiedColumns),
 929:             implode(', ', array_keys($modifiedColumns))
 930:         );
 931: 
 932:         try {
 933:             $stmt = $con->prepare($sql);
 934:             foreach ($modifiedColumns as $identifier => $columnName) {
 935:                 switch ($columnName) {
 936:                     case '`id`':
 937:                         $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
 938:                         break;
 939:                     case '`code`':
 940:                         $stmt->bindValue($identifier, $this->code, PDO::PARAM_STR);
 941:                         break;
 942:                     case '`secured`':
 943:                         $stmt->bindValue($identifier, $this->secured, PDO::PARAM_INT);
 944:                         break;
 945:                     case '`ref`':
 946:                         $stmt->bindValue($identifier, $this->ref, PDO::PARAM_STR);
 947:                         break;
 948:                     case '`created_at`':
 949:                         $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
 950:                         break;
 951:                     case '`updated_at`':
 952:                         $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
 953:                         break;
 954:                     case '`version`':
 955:                         $stmt->bindValue($identifier, $this->version, PDO::PARAM_INT);
 956:                         break;
 957:                     case '`version_created_at`':
 958:                         $stmt->bindValue($identifier, $this->version_created_at, PDO::PARAM_STR);
 959:                         break;
 960:                     case '`version_created_by`':
 961:                         $stmt->bindValue($identifier, $this->version_created_by, PDO::PARAM_STR);
 962:                         break;
 963:                 }
 964:             }
 965:             $stmt->execute();
 966:         } catch (Exception $e) {
 967:             Propel::log($e->getMessage(), Propel::LOG_ERR);
 968:             throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
 969:         }
 970: 
 971:         try {
 972:             $pk = $con->lastInsertId();
 973:         } catch (Exception $e) {
 974:             throw new PropelException('Unable to get autoincrement id.', $e);
 975:         }
 976:         $this->setId($pk);
 977: 
 978:         $this->setNew(false);
 979:     }
 980: 
 981:     /**
 982:      * Update the row in the database.
 983:      *
 984:      * @param PropelPDO $con
 985:      *
 986:      * @see        doSave()
 987:      */
 988:     protected function doUpdate(PropelPDO $con)
 989:     {
 990:         $selectCriteria = $this->buildPkeyCriteria();
 991:         $valuesCriteria = $this->buildCriteria();
 992:         BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
 993:     }
 994: 
 995:     /**
 996:      * Array of ValidationFailed objects.
 997:      * @var        array ValidationFailed[]
 998:      */
 999:     protected $validationFailures = array();
1000: 
1001:     /**
1002:      * Gets any ValidationFailed objects that resulted from last call to validate().
1003:      *
1004:      *
1005:      * @return array ValidationFailed[]
1006:      * @see        validate()
1007:      */
1008:     public function getValidationFailures()
1009:     {
1010:         return $this->validationFailures;
1011:     }
1012: 
1013:     /**
1014:      * Validates the objects modified field values and all objects related to this table.
1015:      *
1016:      * If $columns is either a column name or an array of column names
1017:      * only those columns are validated.
1018:      *
1019:      * @param mixed $columns Column name or an array of column names.
1020:      * @return boolean Whether all columns pass validation.
1021:      * @see        doValidate()
1022:      * @see        getValidationFailures()
1023:      */
1024:     public function validate($columns = null)
1025:     {
1026:         $res = $this->doValidate($columns);
1027:         if ($res === true) {
1028:             $this->validationFailures = array();
1029: 
1030:             return true;
1031:         }
1032: 
1033:         $this->validationFailures = $res;
1034: 
1035:         return false;
1036:     }
1037: 
1038:     /**
1039:      * This function performs the validation work for complex object models.
1040:      *
1041:      * In addition to checking the current object, all related objects will
1042:      * also be validated.  If all pass then <code>true</code> is returned; otherwise
1043:      * an aggreagated array of ValidationFailed objects will be returned.
1044:      *
1045:      * @param array $columns Array of column names to validate.
1046:      * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
1047:      */
1048:     protected function doValidate($columns = null)
1049:     {
1050:         if (!$this->alreadyInValidation) {
1051:             $this->alreadyInValidation = true;
1052:             $retval = null;
1053: 
1054:             $failureMap = array();
1055: 
1056: 
1057:             if (($retval = MessagePeer::doValidate($this, $columns)) !== true) {
1058:                 $failureMap = array_merge($failureMap, $retval);
1059:             }
1060: 
1061: 
1062:                 if ($this->collMessageI18ns !== null) {
1063:                     foreach ($this->collMessageI18ns as $referrerFK) {
1064:                         if (!$referrerFK->validate($columns)) {
1065:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1066:                         }
1067:                     }
1068:                 }
1069: 
1070:                 if ($this->collMessageVersions !== null) {
1071:                     foreach ($this->collMessageVersions as $referrerFK) {
1072:                         if (!$referrerFK->validate($columns)) {
1073:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1074:                         }
1075:                     }
1076:                 }
1077: 
1078: 
1079:             $this->alreadyInValidation = false;
1080:         }
1081: 
1082:         return (!empty($failureMap) ? $failureMap : true);
1083:     }
1084: 
1085:     /**
1086:      * Retrieves a field from the object by name passed in as a string.
1087:      *
1088:      * @param string $name name
1089:      * @param string $type The type of fieldname the $name is of:
1090:      *               one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1091:      *               BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1092:      *               Defaults to BasePeer::TYPE_PHPNAME
1093:      * @return mixed Value of field.
1094:      */
1095:     public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
1096:     {
1097:         $pos = MessagePeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1098:         $field = $this->getByPosition($pos);
1099: 
1100:         return $field;
1101:     }
1102: 
1103:     /**
1104:      * Retrieves a field from the object by Position as specified in the xml schema.
1105:      * Zero-based.
1106:      *
1107:      * @param int $pos position in xml schema
1108:      * @return mixed Value of field at $pos
1109:      */
1110:     public function getByPosition($pos)
1111:     {
1112:         switch ($pos) {
1113:             case 0:
1114:                 return $this->getId();
1115:                 break;
1116:             case 1:
1117:                 return $this->getCode();
1118:                 break;
1119:             case 2:
1120:                 return $this->getSecured();
1121:                 break;
1122:             case 3:
1123:                 return $this->getRef();
1124:                 break;
1125:             case 4:
1126:                 return $this->getCreatedAt();
1127:                 break;
1128:             case 5:
1129:                 return $this->getUpdatedAt();
1130:                 break;
1131:             case 6:
1132:                 return $this->getVersion();
1133:                 break;
1134:             case 7:
1135:                 return $this->getVersionCreatedAt();
1136:                 break;
1137:             case 8:
1138:                 return $this->getVersionCreatedBy();
1139:                 break;
1140:             default:
1141:                 return null;
1142:                 break;
1143:         } // switch()
1144:     }
1145: 
1146:     /**
1147:      * Exports the object as an array.
1148:      *
1149:      * You can specify the key type of the array by passing one of the class
1150:      * type constants.
1151:      *
1152:      * @param     string  $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1153:      *                    BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1154:      *                    Defaults to BasePeer::TYPE_PHPNAME.
1155:      * @param     boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
1156:      * @param     array $alreadyDumpedObjects List of objects to skip to avoid recursion
1157:      * @param     boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
1158:      *
1159:      * @return array an associative array containing the field names (as keys) and field values
1160:      */
1161:     public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
1162:     {
1163:         if (isset($alreadyDumpedObjects['Message'][$this->getPrimaryKey()])) {
1164:             return '*RECURSION*';
1165:         }
1166:         $alreadyDumpedObjects['Message'][$this->getPrimaryKey()] = true;
1167:         $keys = MessagePeer::getFieldNames($keyType);
1168:         $result = array(
1169:             $keys[0] => $this->getId(),
1170:             $keys[1] => $this->getCode(),
1171:             $keys[2] => $this->getSecured(),
1172:             $keys[3] => $this->getRef(),
1173:             $keys[4] => $this->getCreatedAt(),
1174:             $keys[5] => $this->getUpdatedAt(),
1175:             $keys[6] => $this->getVersion(),
1176:             $keys[7] => $this->getVersionCreatedAt(),
1177:             $keys[8] => $this->getVersionCreatedBy(),
1178:         );
1179:         if ($includeForeignObjects) {
1180:             if (null !== $this->collMessageI18ns) {
1181:                 $result['MessageI18ns'] = $this->collMessageI18ns->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1182:             }
1183:             if (null !== $this->collMessageVersions) {
1184:                 $result['MessageVersions'] = $this->collMessageVersions->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1185:             }
1186:         }
1187: 
1188:         return $result;
1189:     }
1190: 
1191:     /**
1192:      * Sets a field from the object by name passed in as a string.
1193:      *
1194:      * @param string $name peer name
1195:      * @param mixed $value field value
1196:      * @param string $type The type of fieldname the $name is of:
1197:      *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1198:      *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1199:      *                     Defaults to BasePeer::TYPE_PHPNAME
1200:      * @return void
1201:      */
1202:     public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
1203:     {
1204:         $pos = MessagePeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1205: 
1206:         $this->setByPosition($pos, $value);
1207:     }
1208: 
1209:     /**
1210:      * Sets a field from the object by Position as specified in the xml schema.
1211:      * Zero-based.
1212:      *
1213:      * @param int $pos position in xml schema
1214:      * @param mixed $value field value
1215:      * @return void
1216:      */
1217:     public function setByPosition($pos, $value)
1218:     {
1219:         switch ($pos) {
1220:             case 0:
1221:                 $this->setId($value);
1222:                 break;
1223:             case 1:
1224:                 $this->setCode($value);
1225:                 break;
1226:             case 2:
1227:                 $this->setSecured($value);
1228:                 break;
1229:             case 3:
1230:                 $this->setRef($value);
1231:                 break;
1232:             case 4:
1233:                 $this->setCreatedAt($value);
1234:                 break;
1235:             case 5:
1236:                 $this->setUpdatedAt($value);
1237:                 break;
1238:             case 6:
1239:                 $this->setVersion($value);
1240:                 break;
1241:             case 7:
1242:                 $this->setVersionCreatedAt($value);
1243:                 break;
1244:             case 8:
1245:                 $this->setVersionCreatedBy($value);
1246:                 break;
1247:         } // switch()
1248:     }
1249: 
1250:     /**
1251:      * Populates the object using an array.
1252:      *
1253:      * This is particularly useful when populating an object from one of the
1254:      * request arrays (e.g. $_POST).  This method goes through the column
1255:      * names, checking to see whether a matching key exists in populated
1256:      * array. If so the setByName() method is called for that column.
1257:      *
1258:      * You can specify the key type of the array by additionally passing one
1259:      * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1260:      * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1261:      * The default key type is the column's BasePeer::TYPE_PHPNAME
1262:      *
1263:      * @param array  $arr     An array to populate the object from.
1264:      * @param string $keyType The type of keys the array uses.
1265:      * @return void
1266:      */
1267:     public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
1268:     {
1269:         $keys = MessagePeer::getFieldNames($keyType);
1270: 
1271:         if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
1272:         if (array_key_exists($keys[1], $arr)) $this->setCode($arr[$keys[1]]);
1273:         if (array_key_exists($keys[2], $arr)) $this->setSecured($arr[$keys[2]]);
1274:         if (array_key_exists($keys[3], $arr)) $this->setRef($arr[$keys[3]]);
1275:         if (array_key_exists($keys[4], $arr)) $this->setCreatedAt($arr[$keys[4]]);
1276:         if (array_key_exists($keys[5], $arr)) $this->setUpdatedAt($arr[$keys[5]]);
1277:         if (array_key_exists($keys[6], $arr)) $this->setVersion($arr[$keys[6]]);
1278:         if (array_key_exists($keys[7], $arr)) $this->setVersionCreatedAt($arr[$keys[7]]);
1279:         if (array_key_exists($keys[8], $arr)) $this->setVersionCreatedBy($arr[$keys[8]]);
1280:     }
1281: 
1282:     /**
1283:      * Build a Criteria object containing the values of all modified columns in this object.
1284:      *
1285:      * @return Criteria The Criteria object containing all modified values.
1286:      */
1287:     public function buildCriteria()
1288:     {
1289:         $criteria = new Criteria(MessagePeer::DATABASE_NAME);
1290: 
1291:         if ($this->isColumnModified(MessagePeer::ID)) $criteria->add(MessagePeer::ID, $this->id);
1292:         if ($this->isColumnModified(MessagePeer::CODE)) $criteria->add(MessagePeer::CODE, $this->code);
1293:         if ($this->isColumnModified(MessagePeer::SECURED)) $criteria->add(MessagePeer::SECURED, $this->secured);
1294:         if ($this->isColumnModified(MessagePeer::REF)) $criteria->add(MessagePeer::REF, $this->ref);
1295:         if ($this->isColumnModified(MessagePeer::CREATED_AT)) $criteria->add(MessagePeer::CREATED_AT, $this->created_at);
1296:         if ($this->isColumnModified(MessagePeer::UPDATED_AT)) $criteria->add(MessagePeer::UPDATED_AT, $this->updated_at);
1297:         if ($this->isColumnModified(MessagePeer::VERSION)) $criteria->add(MessagePeer::VERSION, $this->version);
1298:         if ($this->isColumnModified(MessagePeer::VERSION_CREATED_AT)) $criteria->add(MessagePeer::VERSION_CREATED_AT, $this->version_created_at);
1299:         if ($this->isColumnModified(MessagePeer::VERSION_CREATED_BY)) $criteria->add(MessagePeer::VERSION_CREATED_BY, $this->version_created_by);
1300: 
1301:         return $criteria;
1302:     }
1303: 
1304:     /**
1305:      * Builds a Criteria object containing the primary key for this object.
1306:      *
1307:      * Unlike buildCriteria() this method includes the primary key values regardless
1308:      * of whether or not they have been modified.
1309:      *
1310:      * @return Criteria The Criteria object containing value(s) for primary key(s).
1311:      */
1312:     public function buildPkeyCriteria()
1313:     {
1314:         $criteria = new Criteria(MessagePeer::DATABASE_NAME);
1315:         $criteria->add(MessagePeer::ID, $this->id);
1316: 
1317:         return $criteria;
1318:     }
1319: 
1320:     /**
1321:      * Returns the primary key for this object (row).
1322:      * @return int
1323:      */
1324:     public function getPrimaryKey()
1325:     {
1326:         return $this->getId();
1327:     }
1328: 
1329:     /**
1330:      * Generic method to set the primary key (id column).
1331:      *
1332:      * @param  int $key Primary key.
1333:      * @return void
1334:      */
1335:     public function setPrimaryKey($key)
1336:     {
1337:         $this->setId($key);
1338:     }
1339: 
1340:     /**
1341:      * Returns true if the primary key for this object is null.
1342:      * @return boolean
1343:      */
1344:     public function isPrimaryKeyNull()
1345:     {
1346: 
1347:         return null === $this->getId();
1348:     }
1349: 
1350:     /**
1351:      * Sets contents of passed object to values from current object.
1352:      *
1353:      * If desired, this method can also make copies of all associated (fkey referrers)
1354:      * objects.
1355:      *
1356:      * @param object $copyObj An object of Message (or compatible) type.
1357:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1358:      * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
1359:      * @throws PropelException
1360:      */
1361:     public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
1362:     {
1363:         $copyObj->setCode($this->getCode());
1364:         $copyObj->setSecured($this->getSecured());
1365:         $copyObj->setRef($this->getRef());
1366:         $copyObj->setCreatedAt($this->getCreatedAt());
1367:         $copyObj->setUpdatedAt($this->getUpdatedAt());
1368:         $copyObj->setVersion($this->getVersion());
1369:         $copyObj->setVersionCreatedAt($this->getVersionCreatedAt());
1370:         $copyObj->setVersionCreatedBy($this->getVersionCreatedBy());
1371: 
1372:         if ($deepCopy && !$this->startCopy) {
1373:             // important: temporarily setNew(false) because this affects the behavior of
1374:             // the getter/setter methods for fkey referrer objects.
1375:             $copyObj->setNew(false);
1376:             // store object hash to prevent cycle
1377:             $this->startCopy = true;
1378: 
1379:             foreach ($this->getMessageI18ns() as $relObj) {
1380:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
1381:                     $copyObj->addMessageI18n($relObj->copy($deepCopy));
1382:                 }
1383:             }
1384: 
1385:             foreach ($this->getMessageVersions() as $relObj) {
1386:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
1387:                     $copyObj->addMessageVersion($relObj->copy($deepCopy));
1388:                 }
1389:             }
1390: 
1391:             //unflag object copy
1392:             $this->startCopy = false;
1393:         } // if ($deepCopy)
1394: 
1395:         if ($makeNew) {
1396:             $copyObj->setNew(true);
1397:             $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
1398:         }
1399:     }
1400: 
1401:     /**
1402:      * Makes a copy of this object that will be inserted as a new row in table when saved.
1403:      * It creates a new object filling in the simple attributes, but skipping any primary
1404:      * keys that are defined for the table.
1405:      *
1406:      * If desired, this method can also make copies of all associated (fkey referrers)
1407:      * objects.
1408:      *
1409:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1410:      * @return Message Clone of current object.
1411:      * @throws PropelException
1412:      */
1413:     public function copy($deepCopy = false)
1414:     {
1415:         // we use get_class(), because this might be a subclass
1416:         $clazz = get_class($this);
1417:         $copyObj = new $clazz();
1418:         $this->copyInto($copyObj, $deepCopy);
1419: 
1420:         return $copyObj;
1421:     }
1422: 
1423:     /**
1424:      * Returns a peer instance associated with this om.
1425:      *
1426:      * Since Peer classes are not to have any instance attributes, this method returns the
1427:      * same instance for all member of this class. The method could therefore
1428:      * be static, but this would prevent one from overriding the behavior.
1429:      *
1430:      * @return MessagePeer
1431:      */
1432:     public function getPeer()
1433:     {
1434:         if (self::$peer === null) {
1435:             self::$peer = new MessagePeer();
1436:         }
1437: 
1438:         return self::$peer;
1439:     }
1440: 
1441: 
1442:     /**
1443:      * Initializes a collection based on the name of a relation.
1444:      * Avoids crafting an 'init[$relationName]s' method name
1445:      * that wouldn't work when StandardEnglishPluralizer is used.
1446:      *
1447:      * @param string $relationName The name of the relation to initialize
1448:      * @return void
1449:      */
1450:     public function initRelation($relationName)
1451:     {
1452:         if ('MessageI18n' == $relationName) {
1453:             $this->initMessageI18ns();
1454:         }
1455:         if ('MessageVersion' == $relationName) {
1456:             $this->initMessageVersions();
1457:         }
1458:     }
1459: 
1460:     /**
1461:      * Clears out the collMessageI18ns collection
1462:      *
1463:      * This does not modify the database; however, it will remove any associated objects, causing
1464:      * them to be refetched by subsequent calls to accessor method.
1465:      *
1466:      * @return Message The current object (for fluent API support)
1467:      * @see        addMessageI18ns()
1468:      */
1469:     public function clearMessageI18ns()
1470:     {
1471:         $this->collMessageI18ns = null; // important to set this to null since that means it is uninitialized
1472:         $this->collMessageI18nsPartial = null;
1473: 
1474:         return $this;
1475:     }
1476: 
1477:     /**
1478:      * reset is the collMessageI18ns collection loaded partially
1479:      *
1480:      * @return void
1481:      */
1482:     public function resetPartialMessageI18ns($v = true)
1483:     {
1484:         $this->collMessageI18nsPartial = $v;
1485:     }
1486: 
1487:     /**
1488:      * Initializes the collMessageI18ns collection.
1489:      *
1490:      * By default this just sets the collMessageI18ns collection to an empty array (like clearcollMessageI18ns());
1491:      * however, you may wish to override this method in your stub class to provide setting appropriate
1492:      * to your application -- for example, setting the initial array to the values stored in database.
1493:      *
1494:      * @param boolean $overrideExisting If set to true, the method call initializes
1495:      *                                        the collection even if it is not empty
1496:      *
1497:      * @return void
1498:      */
1499:     public function initMessageI18ns($overrideExisting = true)
1500:     {
1501:         if (null !== $this->collMessageI18ns && !$overrideExisting) {
1502:             return;
1503:         }
1504:         $this->collMessageI18ns = new PropelObjectCollection();
1505:         $this->collMessageI18ns->setModel('MessageI18n');
1506:     }
1507: 
1508:     /**
1509:      * Gets an array of MessageI18n objects which contain a foreign key that references this object.
1510:      *
1511:      * If the $criteria is not null, it is used to always fetch the results from the database.
1512:      * Otherwise the results are fetched from the database the first time, then cached.
1513:      * Next time the same method is called without $criteria, the cached collection is returned.
1514:      * If this Message is new, it will return
1515:      * an empty collection or the current collection; the criteria is ignored on a new object.
1516:      *
1517:      * @param Criteria $criteria optional Criteria object to narrow the query
1518:      * @param PropelPDO $con optional connection object
1519:      * @return PropelObjectCollection|MessageI18n[] List of MessageI18n objects
1520:      * @throws PropelException
1521:      */
1522:     public function getMessageI18ns($criteria = null, PropelPDO $con = null)
1523:     {
1524:         $partial = $this->collMessageI18nsPartial && !$this->isNew();
1525:         if (null === $this->collMessageI18ns || null !== $criteria  || $partial) {
1526:             if ($this->isNew() && null === $this->collMessageI18ns) {
1527:                 // return empty collection
1528:                 $this->initMessageI18ns();
1529:             } else {
1530:                 $collMessageI18ns = MessageI18nQuery::create(null, $criteria)
1531:                     ->filterByMessage($this)
1532:                     ->find($con);
1533:                 if (null !== $criteria) {
1534:                     if (false !== $this->collMessageI18nsPartial && count($collMessageI18ns)) {
1535:                       $this->initMessageI18ns(false);
1536: 
1537:                       foreach($collMessageI18ns as $obj) {
1538:                         if (false == $this->collMessageI18ns->contains($obj)) {
1539:                           $this->collMessageI18ns->append($obj);
1540:                         }
1541:                       }
1542: 
1543:                       $this->collMessageI18nsPartial = true;
1544:                     }
1545: 
1546:                     $collMessageI18ns->getInternalIterator()->rewind();
1547:                     return $collMessageI18ns;
1548:                 }
1549: 
1550:                 if($partial && $this->collMessageI18ns) {
1551:                     foreach($this->collMessageI18ns as $obj) {
1552:                         if($obj->isNew()) {
1553:                             $collMessageI18ns[] = $obj;
1554:                         }
1555:                     }
1556:                 }
1557: 
1558:                 $this->collMessageI18ns = $collMessageI18ns;
1559:                 $this->collMessageI18nsPartial = false;
1560:             }
1561:         }
1562: 
1563:         return $this->collMessageI18ns;
1564:     }
1565: 
1566:     /**
1567:      * Sets a collection of MessageI18n objects related by a one-to-many relationship
1568:      * to the current object.
1569:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
1570:      * and new objects from the given Propel collection.
1571:      *
1572:      * @param PropelCollection $messageI18ns A Propel collection.
1573:      * @param PropelPDO $con Optional connection object
1574:      * @return Message The current object (for fluent API support)
1575:      */
1576:     public function setMessageI18ns(PropelCollection $messageI18ns, PropelPDO $con = null)
1577:     {
1578:         $messageI18nsToDelete = $this->getMessageI18ns(new Criteria(), $con)->diff($messageI18ns);
1579: 
1580:         $this->messageI18nsScheduledForDeletion = unserialize(serialize($messageI18nsToDelete));
1581: 
1582:         foreach ($messageI18nsToDelete as $messageI18nRemoved) {
1583:             $messageI18nRemoved->setMessage(null);
1584:         }
1585: 
1586:         $this->collMessageI18ns = null;
1587:         foreach ($messageI18ns as $messageI18n) {
1588:             $this->addMessageI18n($messageI18n);
1589:         }
1590: 
1591:         $this->collMessageI18ns = $messageI18ns;
1592:         $this->collMessageI18nsPartial = false;
1593: 
1594:         return $this;
1595:     }
1596: 
1597:     /**
1598:      * Returns the number of related MessageI18n objects.
1599:      *
1600:      * @param Criteria $criteria
1601:      * @param boolean $distinct
1602:      * @param PropelPDO $con
1603:      * @return int             Count of related MessageI18n objects.
1604:      * @throws PropelException
1605:      */
1606:     public function countMessageI18ns(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
1607:     {
1608:         $partial = $this->collMessageI18nsPartial && !$this->isNew();
1609:         if (null === $this->collMessageI18ns || null !== $criteria || $partial) {
1610:             if ($this->isNew() && null === $this->collMessageI18ns) {
1611:                 return 0;
1612:             }
1613: 
1614:             if($partial && !$criteria) {
1615:                 return count($this->getMessageI18ns());
1616:             }
1617:             $query = MessageI18nQuery::create(null, $criteria);
1618:             if ($distinct) {
1619:                 $query->distinct();
1620:             }
1621: 
1622:             return $query
1623:                 ->filterByMessage($this)
1624:                 ->count($con);
1625:         }
1626: 
1627:         return count($this->collMessageI18ns);
1628:     }
1629: 
1630:     /**
1631:      * Method called to associate a MessageI18n object to this object
1632:      * through the MessageI18n foreign key attribute.
1633:      *
1634:      * @param    MessageI18n $l MessageI18n
1635:      * @return Message The current object (for fluent API support)
1636:      */
1637:     public function addMessageI18n(MessageI18n $l)
1638:     {
1639:         if ($l && $locale = $l->getLocale()) {
1640:             $this->setLocale($locale);
1641:             $this->currentTranslations[$locale] = $l;
1642:         }
1643:         if ($this->collMessageI18ns === null) {
1644:             $this->initMessageI18ns();
1645:             $this->collMessageI18nsPartial = true;
1646:         }
1647:         if (!in_array($l, $this->collMessageI18ns->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
1648:             $this->doAddMessageI18n($l);
1649:         }
1650: 
1651:         return $this;
1652:     }
1653: 
1654:     /**
1655:      * @param   MessageI18n $messageI18n The messageI18n object to add.
1656:      */
1657:     protected function doAddMessageI18n($messageI18n)
1658:     {
1659:         $this->collMessageI18ns[]= $messageI18n;
1660:         $messageI18n->setMessage($this);
1661:     }
1662: 
1663:     /**
1664:      * @param   MessageI18n $messageI18n The messageI18n object to remove.
1665:      * @return Message The current object (for fluent API support)
1666:      */
1667:     public function removeMessageI18n($messageI18n)
1668:     {
1669:         if ($this->getMessageI18ns()->contains($messageI18n)) {
1670:             $this->collMessageI18ns->remove($this->collMessageI18ns->search($messageI18n));
1671:             if (null === $this->messageI18nsScheduledForDeletion) {
1672:                 $this->messageI18nsScheduledForDeletion = clone $this->collMessageI18ns;
1673:                 $this->messageI18nsScheduledForDeletion->clear();
1674:             }
1675:             $this->messageI18nsScheduledForDeletion[]= clone $messageI18n;
1676:             $messageI18n->setMessage(null);
1677:         }
1678: 
1679:         return $this;
1680:     }
1681: 
1682:     /**
1683:      * Clears out the collMessageVersions collection
1684:      *
1685:      * This does not modify the database; however, it will remove any associated objects, causing
1686:      * them to be refetched by subsequent calls to accessor method.
1687:      *
1688:      * @return Message The current object (for fluent API support)
1689:      * @see        addMessageVersions()
1690:      */
1691:     public function clearMessageVersions()
1692:     {
1693:         $this->collMessageVersions = null; // important to set this to null since that means it is uninitialized
1694:         $this->collMessageVersionsPartial = null;
1695: 
1696:         return $this;
1697:     }
1698: 
1699:     /**
1700:      * reset is the collMessageVersions collection loaded partially
1701:      *
1702:      * @return void
1703:      */
1704:     public function resetPartialMessageVersions($v = true)
1705:     {
1706:         $this->collMessageVersionsPartial = $v;
1707:     }
1708: 
1709:     /**
1710:      * Initializes the collMessageVersions collection.
1711:      *
1712:      * By default this just sets the collMessageVersions collection to an empty array (like clearcollMessageVersions());
1713:      * however, you may wish to override this method in your stub class to provide setting appropriate
1714:      * to your application -- for example, setting the initial array to the values stored in database.
1715:      *
1716:      * @param boolean $overrideExisting If set to true, the method call initializes
1717:      *                                        the collection even if it is not empty
1718:      *
1719:      * @return void
1720:      */
1721:     public function initMessageVersions($overrideExisting = true)
1722:     {
1723:         if (null !== $this->collMessageVersions && !$overrideExisting) {
1724:             return;
1725:         }
1726:         $this->collMessageVersions = new PropelObjectCollection();
1727:         $this->collMessageVersions->setModel('MessageVersion');
1728:     }
1729: 
1730:     /**
1731:      * Gets an array of MessageVersion objects which contain a foreign key that references this object.
1732:      *
1733:      * If the $criteria is not null, it is used to always fetch the results from the database.
1734:      * Otherwise the results are fetched from the database the first time, then cached.
1735:      * Next time the same method is called without $criteria, the cached collection is returned.
1736:      * If this Message is new, it will return
1737:      * an empty collection or the current collection; the criteria is ignored on a new object.
1738:      *
1739:      * @param Criteria $criteria optional Criteria object to narrow the query
1740:      * @param PropelPDO $con optional connection object
1741:      * @return PropelObjectCollection|MessageVersion[] List of MessageVersion objects
1742:      * @throws PropelException
1743:      */
1744:     public function getMessageVersions($criteria = null, PropelPDO $con = null)
1745:     {
1746:         $partial = $this->collMessageVersionsPartial && !$this->isNew();
1747:         if (null === $this->collMessageVersions || null !== $criteria  || $partial) {
1748:             if ($this->isNew() && null === $this->collMessageVersions) {
1749:                 // return empty collection
1750:                 $this->initMessageVersions();
1751:             } else {
1752:                 $collMessageVersions = MessageVersionQuery::create(null, $criteria)
1753:                     ->filterByMessage($this)
1754:                     ->find($con);
1755:                 if (null !== $criteria) {
1756:                     if (false !== $this->collMessageVersionsPartial && count($collMessageVersions)) {
1757:                       $this->initMessageVersions(false);
1758: 
1759:                       foreach($collMessageVersions as $obj) {
1760:                         if (false == $this->collMessageVersions->contains($obj)) {
1761:                           $this->collMessageVersions->append($obj);
1762:                         }
1763:                       }
1764: 
1765:                       $this->collMessageVersionsPartial = true;
1766:                     }
1767: 
1768:                     $collMessageVersions->getInternalIterator()->rewind();
1769:                     return $collMessageVersions;
1770:                 }
1771: 
1772:                 if($partial && $this->collMessageVersions) {
1773:                     foreach($this->collMessageVersions as $obj) {
1774:                         if($obj->isNew()) {
1775:                             $collMessageVersions[] = $obj;
1776:                         }
1777:                     }
1778:                 }
1779: 
1780:                 $this->collMessageVersions = $collMessageVersions;
1781:                 $this->collMessageVersionsPartial = false;
1782:             }
1783:         }
1784: 
1785:         return $this->collMessageVersions;
1786:     }
1787: 
1788:     /**
1789:      * Sets a collection of MessageVersion objects related by a one-to-many relationship
1790:      * to the current object.
1791:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
1792:      * and new objects from the given Propel collection.
1793:      *
1794:      * @param PropelCollection $messageVersions A Propel collection.
1795:      * @param PropelPDO $con Optional connection object
1796:      * @return Message The current object (for fluent API support)
1797:      */
1798:     public function setMessageVersions(PropelCollection $messageVersions, PropelPDO $con = null)
1799:     {
1800:         $messageVersionsToDelete = $this->getMessageVersions(new Criteria(), $con)->diff($messageVersions);
1801: 
1802:         $this->messageVersionsScheduledForDeletion = unserialize(serialize($messageVersionsToDelete));
1803: 
1804:         foreach ($messageVersionsToDelete as $messageVersionRemoved) {
1805:             $messageVersionRemoved->setMessage(null);
1806:         }
1807: 
1808:         $this->collMessageVersions = null;
1809:         foreach ($messageVersions as $messageVersion) {
1810:             $this->addMessageVersion($messageVersion);
1811:         }
1812: 
1813:         $this->collMessageVersions = $messageVersions;
1814:         $this->collMessageVersionsPartial = false;
1815: 
1816:         return $this;
1817:     }
1818: 
1819:     /**
1820:      * Returns the number of related MessageVersion objects.
1821:      *
1822:      * @param Criteria $criteria
1823:      * @param boolean $distinct
1824:      * @param PropelPDO $con
1825:      * @return int             Count of related MessageVersion objects.
1826:      * @throws PropelException
1827:      */
1828:     public function countMessageVersions(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
1829:     {
1830:         $partial = $this->collMessageVersionsPartial && !$this->isNew();
1831:         if (null === $this->collMessageVersions || null !== $criteria || $partial) {
1832:             if ($this->isNew() && null === $this->collMessageVersions) {
1833:                 return 0;
1834:             }
1835: 
1836:             if($partial && !$criteria) {
1837:                 return count($this->getMessageVersions());
1838:             }
1839:             $query = MessageVersionQuery::create(null, $criteria);
1840:             if ($distinct) {
1841:                 $query->distinct();
1842:             }
1843: 
1844:             return $query
1845:                 ->filterByMessage($this)
1846:                 ->count($con);
1847:         }
1848: 
1849:         return count($this->collMessageVersions);
1850:     }
1851: 
1852:     /**
1853:      * Method called to associate a MessageVersion object to this object
1854:      * through the MessageVersion foreign key attribute.
1855:      *
1856:      * @param    MessageVersion $l MessageVersion
1857:      * @return Message The current object (for fluent API support)
1858:      */
1859:     public function addMessageVersion(MessageVersion $l)
1860:     {
1861:         if ($this->collMessageVersions === null) {
1862:             $this->initMessageVersions();
1863:             $this->collMessageVersionsPartial = true;
1864:         }
1865:         if (!in_array($l, $this->collMessageVersions->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
1866:             $this->doAddMessageVersion($l);
1867:         }
1868: 
1869:         return $this;
1870:     }
1871: 
1872:     /**
1873:      * @param   MessageVersion $messageVersion The messageVersion object to add.
1874:      */
1875:     protected function doAddMessageVersion($messageVersion)
1876:     {
1877:         $this->collMessageVersions[]= $messageVersion;
1878:         $messageVersion->setMessage($this);
1879:     }
1880: 
1881:     /**
1882:      * @param   MessageVersion $messageVersion The messageVersion object to remove.
1883:      * @return Message The current object (for fluent API support)
1884:      */
1885:     public function removeMessageVersion($messageVersion)
1886:     {
1887:         if ($this->getMessageVersions()->contains($messageVersion)) {
1888:             $this->collMessageVersions->remove($this->collMessageVersions->search($messageVersion));
1889:             if (null === $this->messageVersionsScheduledForDeletion) {
1890:                 $this->messageVersionsScheduledForDeletion = clone $this->collMessageVersions;
1891:                 $this->messageVersionsScheduledForDeletion->clear();
1892:             }
1893:             $this->messageVersionsScheduledForDeletion[]= clone $messageVersion;
1894:             $messageVersion->setMessage(null);
1895:         }
1896: 
1897:         return $this;
1898:     }
1899: 
1900:     /**
1901:      * Clears the current object and sets all attributes to their default values
1902:      */
1903:     public function clear()
1904:     {
1905:         $this->id = null;
1906:         $this->code = null;
1907:         $this->secured = null;
1908:         $this->ref = null;
1909:         $this->created_at = null;
1910:         $this->updated_at = null;
1911:         $this->version = null;
1912:         $this->version_created_at = null;
1913:         $this->version_created_by = null;
1914:         $this->alreadyInSave = false;
1915:         $this->alreadyInValidation = false;
1916:         $this->alreadyInClearAllReferencesDeep = false;
1917:         $this->clearAllReferences();
1918:         $this->applyDefaultValues();
1919:         $this->resetModified();
1920:         $this->setNew(true);
1921:         $this->setDeleted(false);
1922:     }
1923: 
1924:     /**
1925:      * Resets all references to other model objects or collections of model objects.
1926:      *
1927:      * This method is a user-space workaround for PHP's inability to garbage collect
1928:      * objects with circular references (even in PHP 5.3). This is currently necessary
1929:      * when using Propel in certain daemon or large-volumne/high-memory operations.
1930:      *
1931:      * @param boolean $deep Whether to also clear the references on all referrer objects.
1932:      */
1933:     public function clearAllReferences($deep = false)
1934:     {
1935:         if ($deep && !$this->alreadyInClearAllReferencesDeep) {
1936:             $this->alreadyInClearAllReferencesDeep = true;
1937:             if ($this->collMessageI18ns) {
1938:                 foreach ($this->collMessageI18ns as $o) {
1939:                     $o->clearAllReferences($deep);
1940:                 }
1941:             }
1942:             if ($this->collMessageVersions) {
1943:                 foreach ($this->collMessageVersions as $o) {
1944:                     $o->clearAllReferences($deep);
1945:                 }
1946:             }
1947: 
1948:             $this->alreadyInClearAllReferencesDeep = false;
1949:         } // if ($deep)
1950: 
1951:         // i18n behavior
1952:         $this->currentLocale = 'en_US';
1953:         $this->currentTranslations = null;
1954: 
1955:         if ($this->collMessageI18ns instanceof PropelCollection) {
1956:             $this->collMessageI18ns->clearIterator();
1957:         }
1958:         $this->collMessageI18ns = null;
1959:         if ($this->collMessageVersions instanceof PropelCollection) {
1960:             $this->collMessageVersions->clearIterator();
1961:         }
1962:         $this->collMessageVersions = null;
1963:     }
1964: 
1965:     /**
1966:      * return the string representation of this object
1967:      *
1968:      * @return string
1969:      */
1970:     public function __toString()
1971:     {
1972:         return (string) $this->exportTo(MessagePeer::DEFAULT_STRING_FORMAT);
1973:     }
1974: 
1975:     /**
1976:      * return true is the object is in saving state
1977:      *
1978:      * @return boolean
1979:      */
1980:     public function isAlreadyInSave()
1981:     {
1982:         return $this->alreadyInSave;
1983:     }
1984: 
1985:     // timestampable behavior
1986: 
1987:     /**
1988:      * Mark the current object so that the update date doesn't get updated during next save
1989:      *
1990:      * @return     Message The current object (for fluent API support)
1991:      */
1992:     public function keepUpdateDateUnchanged()
1993:     {
1994:         $this->modifiedColumns[] = MessagePeer::UPDATED_AT;
1995: 
1996:         return $this;
1997:     }
1998: 
1999:     // i18n behavior
2000: 
2001:     /**
2002:      * Sets the locale for translations
2003:      *
2004:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
2005:      *
2006:      * @return    Message The current object (for fluent API support)
2007:      */
2008:     public function setLocale($locale = 'en_US')
2009:     {
2010:         $this->currentLocale = $locale;
2011: 
2012:         return $this;
2013:     }
2014: 
2015:     /**
2016:      * Gets the locale for translations
2017:      *
2018:      * @return    string $locale Locale to use for the translation, e.g. 'fr_FR'
2019:      */
2020:     public function getLocale()
2021:     {
2022:         return $this->currentLocale;
2023:     }
2024: 
2025:     /**
2026:      * Returns the current translation for a given locale
2027:      *
2028:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
2029:      * @param     PropelPDO $con an optional connection object
2030:      *
2031:      * @return MessageI18n */
2032:     public function getTranslation($locale = 'en_US', PropelPDO $con = null)
2033:     {
2034:         if (!isset($this->currentTranslations[$locale])) {
2035:             if (null !== $this->collMessageI18ns) {
2036:                 foreach ($this->collMessageI18ns as $translation) {
2037:                     if ($translation->getLocale() == $locale) {
2038:                         $this->currentTranslations[$locale] = $translation;
2039: 
2040:                         return $translation;
2041:                     }
2042:                 }
2043:             }
2044:             if ($this->isNew()) {
2045:                 $translation = new MessageI18n();
2046:                 $translation->setLocale($locale);
2047:             } else {
2048:                 $translation = MessageI18nQuery::create()
2049:                     ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
2050:                     ->findOneOrCreate($con);
2051:                 $this->currentTranslations[$locale] = $translation;
2052:             }
2053:             $this->addMessageI18n($translation);
2054:         }
2055: 
2056:         return $this->currentTranslations[$locale];
2057:     }
2058: 
2059:     /**
2060:      * Remove the translation for a given locale
2061:      *
2062:      * @param     string $locale Locale to use for the translation, e.g. 'fr_FR'
2063:      * @param     PropelPDO $con an optional connection object
2064:      *
2065:      * @return    Message The current object (for fluent API support)
2066:      */
2067:     public function removeTranslation($locale = 'en_US', PropelPDO $con = null)
2068:     {
2069:         if (!$this->isNew()) {
2070:             MessageI18nQuery::create()
2071:                 ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
2072:                 ->delete($con);
2073:         }
2074:         if (isset($this->currentTranslations[$locale])) {
2075:             unset($this->currentTranslations[$locale]);
2076:         }
2077:         foreach ($this->collMessageI18ns as $key => $translation) {
2078:             if ($translation->getLocale() == $locale) {
2079:                 unset($this->collMessageI18ns[$key]);
2080:                 break;
2081:             }
2082:         }
2083: 
2084:         return $this;
2085:     }
2086: 
2087:     /**
2088:      * Returns the current translation
2089:      *
2090:      * @param     PropelPDO $con an optional connection object
2091:      *
2092:      * @return MessageI18n */
2093:     public function getCurrentTranslation(PropelPDO $con = null)
2094:     {
2095:         return $this->getTranslation($this->getLocale(), $con);
2096:     }
2097: 
2098: 
2099:         /**
2100:          * Get the [title] column value.
2101:          *
2102:          * @return string
2103:          */
2104:         public function getTitle()
2105:         {
2106:         return $this->getCurrentTranslation()->getTitle();
2107:     }
2108: 
2109: 
2110:         /**
2111:          * Set the value of [title] column.
2112:          *
2113:          * @param string $v new value
2114:          * @return MessageI18n The current object (for fluent API support)
2115:          */
2116:         public function setTitle($v)
2117:         {    $this->getCurrentTranslation()->setTitle($v);
2118: 
2119:         return $this;
2120:     }
2121: 
2122: 
2123:         /**
2124:          * Get the [description] column value.
2125:          *
2126:          * @return string
2127:          */
2128:         public function getDescription()
2129:         {
2130:         return $this->getCurrentTranslation()->getDescription();
2131:     }
2132: 
2133: 
2134:         /**
2135:          * Set the value of [description] column.
2136:          *
2137:          * @param string $v new value
2138:          * @return MessageI18n The current object (for fluent API support)
2139:          */
2140:         public function setDescription($v)
2141:         {    $this->getCurrentTranslation()->setDescription($v);
2142: 
2143:         return $this;
2144:     }
2145: 
2146: 
2147:         /**
2148:          * Get the [description_html] column value.
2149:          *
2150:          * @return string
2151:          */
2152:         public function getDescriptionHtml()
2153:         {
2154:         return $this->getCurrentTranslation()->getDescriptionHtml();
2155:     }
2156: 
2157: 
2158:         /**
2159:          * Set the value of [description_html] column.
2160:          *
2161:          * @param string $v new value
2162:          * @return MessageI18n The current object (for fluent API support)
2163:          */
2164:         public function setDescriptionHtml($v)
2165:         {    $this->getCurrentTranslation()->setDescriptionHtml($v);
2166: 
2167:         return $this;
2168:     }
2169: 
2170:     // versionable behavior
2171: 
2172:     /**
2173:      * Enforce a new Version of this object upon next save.
2174:      *
2175:      * @return Message
2176:      */
2177:     public function enforceVersioning()
2178:     {
2179:         $this->enforceVersion = true;
2180: 
2181:         return $this;
2182:     }
2183: 
2184:     /**
2185:      * Checks whether the current state must be recorded as a version
2186:      *
2187:      * @param PropelPDO $con An optional PropelPDO connection to use.
2188:      *
2189:      * @return  boolean
2190:      */
2191:     public function isVersioningNecessary($con = null)
2192:     {
2193:         if ($this->alreadyInSave) {
2194:             return false;
2195:         }
2196: 
2197:         if ($this->enforceVersion) {
2198:             return true;
2199:         }
2200: 
2201:         if (MessagePeer::isVersioningEnabled() && ($this->isNew() || $this->isModified() || $this->isDeleted())) {
2202:             return true;
2203:         }
2204: 
2205:         return false;
2206:     }
2207: 
2208:     /**
2209:      * Creates a version of the current object and saves it.
2210:      *
2211:      * @param   PropelPDO $con the connection to use
2212:      *
2213:      * @return  MessageVersion A version object
2214:      */
2215:     public function addVersion($con = null)
2216:     {
2217:         $this->enforceVersion = false;
2218: 
2219:         $version = new MessageVersion();
2220:         $version->setId($this->getId());
2221:         $version->setCode($this->getCode());
2222:         $version->setSecured($this->getSecured());
2223:         $version->setRef($this->getRef());
2224:         $version->setCreatedAt($this->getCreatedAt());
2225:         $version->setUpdatedAt($this->getUpdatedAt());
2226:         $version->setVersion($this->getVersion());
2227:         $version->setVersionCreatedAt($this->getVersionCreatedAt());
2228:         $version->setVersionCreatedBy($this->getVersionCreatedBy());
2229:         $version->setMessage($this);
2230:         $version->save($con);
2231: 
2232:         return $version;
2233:     }
2234: 
2235:     /**
2236:      * Sets the properties of the curent object to the value they had at a specific version
2237:      *
2238:      * @param   integer $versionNumber The version number to read
2239:      * @param   PropelPDO $con the connection to use
2240:      *
2241:      * @return  Message The current object (for fluent API support)
2242:      * @throws  PropelException - if no object with the given version can be found.
2243:      */
2244:     public function toVersion($versionNumber, $con = null)
2245:     {
2246:         $version = $this->getOneVersion($versionNumber, $con);
2247:         if (!$version) {
2248:             throw new PropelException(sprintf('No Message object found with version %d', $version));
2249:         }
2250:         $this->populateFromVersion($version, $con);
2251: 
2252:         return $this;
2253:     }
2254: 
2255:     /**
2256:      * Sets the properties of the curent object to the value they had at a specific version
2257:      *
2258:      * @param   MessageVersion $version The version object to use
2259:      * @param   PropelPDO $con the connection to use
2260:      * @param   array $loadedObjects objects thats been loaded in a chain of populateFromVersion calls on referrer or fk objects.
2261:      *
2262:      * @return  Message The current object (for fluent API support)
2263:      */
2264:     public function populateFromVersion($version, $con = null, &$loadedObjects = array())
2265:     {
2266: 
2267:         $loadedObjects['Message'][$version->getId()][$version->getVersion()] = $this;
2268:         $this->setId($version->getId());
2269:         $this->setCode($version->getCode());
2270:         $this->setSecured($version->getSecured());
2271:         $this->setRef($version->getRef());
2272:         $this->setCreatedAt($version->getCreatedAt());
2273:         $this->setUpdatedAt($version->getUpdatedAt());
2274:         $this->setVersion($version->getVersion());
2275:         $this->setVersionCreatedAt($version->getVersionCreatedAt());
2276:         $this->setVersionCreatedBy($version->getVersionCreatedBy());
2277: 
2278:         return $this;
2279:     }
2280: 
2281:     /**
2282:      * Gets the latest persisted version number for the current object
2283:      *
2284:      * @param   PropelPDO $con the connection to use
2285:      *
2286:      * @return  integer
2287:      */
2288:     public function getLastVersionNumber($con = null)
2289:     {
2290:         $v = MessageVersionQuery::create()
2291:             ->filterByMessage($this)
2292:             ->orderByVersion('desc')
2293:             ->findOne($con);
2294:         if (!$v) {
2295:             return 0;
2296:         }
2297: 
2298:         return $v->getVersion();
2299:     }
2300: 
2301:     /**
2302:      * Checks whether the current object is the latest one
2303:      *
2304:      * @param   PropelPDO $con the connection to use
2305:      *
2306:      * @return  boolean
2307:      */
2308:     public function isLastVersion($con = null)
2309:     {
2310:         return $this->getLastVersionNumber($con) == $this->getVersion();
2311:     }
2312: 
2313:     /**
2314:      * Retrieves a version object for this entity and a version number
2315:      *
2316:      * @param   integer $versionNumber The version number to read
2317:      * @param   PropelPDO $con the connection to use
2318:      *
2319:      * @return  MessageVersion A version object
2320:      */
2321:     public function getOneVersion($versionNumber, $con = null)
2322:     {
2323:         return MessageVersionQuery::create()
2324:             ->filterByMessage($this)
2325:             ->filterByVersion($versionNumber)
2326:             ->findOne($con);
2327:     }
2328: 
2329:     /**
2330:      * Gets all the versions of this object, in incremental order
2331:      *
2332:      * @param   PropelPDO $con the connection to use
2333:      *
2334:      * @return  PropelObjectCollection A list of MessageVersion objects
2335:      */
2336:     public function getAllVersions($con = null)
2337:     {
2338:         $criteria = new Criteria();
2339:         $criteria->addAscendingOrderByColumn(MessageVersionPeer::VERSION);
2340: 
2341:         return $this->getMessageVersions($criteria, $con);
2342:     }
2343: 
2344:     /**
2345:      * Compares the current object with another of its version.
2346:      * <code>
2347:      * print_r($book->compareVersion(1));
2348:      * => array(
2349:      *   '1' => array('Title' => 'Book title at version 1'),
2350:      *   '2' => array('Title' => 'Book title at version 2')
2351:      * );
2352:      * </code>
2353:      *
2354:      * @param   integer   $versionNumber
2355:      * @param   string    $keys Main key used for the result diff (versions|columns)
2356:      * @param   PropelPDO $con the connection to use
2357:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
2358:      *
2359:      * @return  array A list of differences
2360:      */
2361:     public function compareVersion($versionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
2362:     {
2363:         $fromVersion = $this->toArray();
2364:         $toVersion = $this->getOneVersion($versionNumber, $con)->toArray();
2365: 
2366:         return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
2367:     }
2368: 
2369:     /**
2370:      * Compares two versions of the current object.
2371:      * <code>
2372:      * print_r($book->compareVersions(1, 2));
2373:      * => array(
2374:      *   '1' => array('Title' => 'Book title at version 1'),
2375:      *   '2' => array('Title' => 'Book title at version 2')
2376:      * );
2377:      * </code>
2378:      *
2379:      * @param   integer   $fromVersionNumber
2380:      * @param   integer   $toVersionNumber
2381:      * @param   string    $keys Main key used for the result diff (versions|columns)
2382:      * @param   PropelPDO $con the connection to use
2383:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
2384:      *
2385:      * @return  array A list of differences
2386:      */
2387:     public function compareVersions($fromVersionNumber, $toVersionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
2388:     {
2389:         $fromVersion = $this->getOneVersion($fromVersionNumber, $con)->toArray();
2390:         $toVersion = $this->getOneVersion($toVersionNumber, $con)->toArray();
2391: 
2392:         return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
2393:     }
2394: 
2395:     /**
2396:      * Computes the diff between two versions.
2397:      * <code>
2398:      * print_r($this->computeDiff(1, 2));
2399:      * => array(
2400:      *   '1' => array('Title' => 'Book title at version 1'),
2401:      *   '2' => array('Title' => 'Book title at version 2')
2402:      * );
2403:      * </code>
2404:      *
2405:      * @param   array     $fromVersion     An array representing the original version.
2406:      * @param   array     $toVersion       An array representing the destination version.
2407:      * @param   string    $keys            Main key used for the result diff (versions|columns).
2408:      * @param   array     $ignoredColumns  The columns to exclude from the diff.
2409:      *
2410:      * @return  array A list of differences
2411:      */
2412:     protected function computeDiff($fromVersion, $toVersion, $keys = 'columns', $ignoredColumns = array())
2413:     {
2414:         $fromVersionNumber = $fromVersion['Version'];
2415:         $toVersionNumber = $toVersion['Version'];
2416:         $ignoredColumns = array_merge(array(
2417:             'Version',
2418:             'VersionCreatedAt',
2419:             'VersionCreatedBy',
2420:         ), $ignoredColumns);
2421:         $diff = array();
2422:         foreach ($fromVersion as $key => $value) {
2423:             if (in_array($key, $ignoredColumns)) {
2424:                 continue;
2425:             }
2426:             if ($toVersion[$key] != $value) {
2427:                 switch ($keys) {
2428:                     case 'versions':
2429:                         $diff[$fromVersionNumber][$key] = $value;
2430:                         $diff[$toVersionNumber][$key] = $toVersion[$key];
2431:                         break;
2432:                     default:
2433:                         $diff[$key] = array(
2434:                             $fromVersionNumber => $value,
2435:                             $toVersionNumber => $toVersion[$key],
2436:                         );
2437:                         break;
2438:                 }
2439:             }
2440:         }
2441: 
2442:         return $diff;
2443:     }
2444:     /**
2445:      * retrieve the last $number versions.
2446:      *
2447:      * @param integer $number the number of record to return.
2448:      * @param MessageVersionQuery|Criteria $criteria Additional criteria to filter.
2449:      * @param PropelPDO $con An optional connection to use.
2450:      *
2451:      * @return PropelCollection|MessageVersion[] List of MessageVersion objects
2452:      */
2453:     public function getLastVersions($number = 10, $criteria = null, PropelPDO $con = null)
2454:     {
2455:         $criteria = MessageVersionQuery::create(null, $criteria);
2456:         $criteria->addDescendingOrderByColumn(MessageVersionPeer::VERSION);
2457:         $criteria->limit($number);
2458: 
2459:         return $this->getMessageVersions($criteria, $con);
2460:     }
2461: }
2462: