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