[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Zend Framework (http://framework.zend.com/)
   4   *
   5   * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6   * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7   * @license   http://framework.zend.com/license/new-bsd New BSD License
   8   */
   9  
  10  namespace Zend\Code\Generator;
  11  
  12  use Zend\Code\Reflection\ClassReflection;
  13  
  14  class ClassGenerator extends AbstractGenerator
  15  {
  16      const OBJECT_TYPE = "class";
  17  
  18      const FLAG_ABSTRACT = 0x01;
  19      const FLAG_FINAL    = 0x02;
  20  
  21      /**
  22       * @var FileGenerator
  23       */
  24      protected $containingFileGenerator = null;
  25  
  26      /**
  27       * @var string
  28       */
  29      protected $namespaceName = null;
  30  
  31      /**
  32       * @var DocBlockGenerator
  33       */
  34      protected $docBlock = null;
  35  
  36      /**
  37       * @var string
  38       */
  39      protected $name = null;
  40  
  41      /**
  42       * @var bool
  43       */
  44      protected $flags = 0x00;
  45  
  46      /**
  47       * @var string
  48       */
  49      protected $extendedClass = null;
  50  
  51      /**
  52       * @var array Array of string names
  53       */
  54      protected $implementedInterfaces = array();
  55  
  56      /**
  57       * @var PropertyGenerator[] Array of properties
  58       */
  59      protected $properties = array();
  60  
  61      /**
  62       * @var PropertyGenerator[] Array of constants
  63       */
  64      protected $constants = array();
  65  
  66      /**
  67       * @var MethodGenerator[] Array of methods
  68       */
  69      protected $methods = array();
  70  
  71      /**
  72       * @var TraitUsageGenerator Object to encapsulate trait usage logic
  73       */
  74      protected $traitUsageGenerator;
  75  
  76      /**
  77       * Build a Code Generation Php Object from a Class Reflection
  78       *
  79       * @param  ClassReflection $classReflection
  80       * @return ClassGenerator
  81       */
  82      public static function fromReflection(ClassReflection $classReflection)
  83      {
  84          $cg = new static($classReflection->getName());
  85  
  86          $cg->setSourceContent($cg->getSourceContent());
  87          $cg->setSourceDirty(false);
  88  
  89          if ($classReflection->getDocComment() != '') {
  90              $cg->setDocBlock(DocBlockGenerator::fromReflection($classReflection->getDocBlock()));
  91          }
  92  
  93          $cg->setAbstract($classReflection->isAbstract());
  94  
  95          // set the namespace
  96          if ($classReflection->inNamespace()) {
  97              $cg->setNamespaceName($classReflection->getNamespaceName());
  98          }
  99  
 100          /* @var \Zend\Code\Reflection\ClassReflection $parentClass */
 101          $parentClass = $classReflection->getParentClass();
 102          $interfaces  = $classReflection->getInterfaces();
 103  
 104          if ($parentClass) {
 105              $cg->setExtendedClass($parentClass->getName());
 106  
 107              $interfaces = array_diff($interfaces, $parentClass->getInterfaces());
 108          }
 109  
 110          $interfaceNames = array();
 111          foreach ($interfaces as $interface) {
 112              /* @var \Zend\Code\Reflection\ClassReflection $interface */
 113              $interfaceNames[] = $interface->getName();
 114          }
 115  
 116          $cg->setImplementedInterfaces($interfaceNames);
 117  
 118          $properties = array();
 119  
 120          foreach ($classReflection->getProperties() as $reflectionProperty) {
 121              if ($reflectionProperty->getDeclaringClass()->getName() == $classReflection->getName()) {
 122                  $properties[] = PropertyGenerator::fromReflection($reflectionProperty);
 123              }
 124          }
 125  
 126          $cg->addProperties($properties);
 127  
 128          $constants = array();
 129  
 130          foreach ($classReflection->getConstants() as $name => $value) {
 131              $constants[] = array(
 132                  'name' => $name,
 133                  'value' => $value
 134              );
 135          }
 136  
 137          $cg->addConstants($constants);
 138  
 139          $methods = array();
 140  
 141          foreach ($classReflection->getMethods() as $reflectionMethod) {
 142              $className = ($cg->getNamespaceName()) ? $cg->getNamespaceName() . "\\" . $cg->getName() : $cg->getName();
 143  
 144              if ($reflectionMethod->getDeclaringClass()->getName() == $className) {
 145                  $methods[] = MethodGenerator::fromReflection($reflectionMethod);
 146              }
 147          }
 148  
 149          $cg->addMethods($methods);
 150  
 151          return $cg;
 152      }
 153  
 154      /**
 155       * Generate from array
 156       *
 157       * @configkey name           string        [required] Class Name
 158       * @configkey filegenerator  FileGenerator File generator that holds this class
 159       * @configkey namespacename  string        The namespace for this class
 160       * @configkey docblock       string        The docblock information
 161       * @configkey flags          int           Flags, one of ClassGenerator::FLAG_ABSTRACT ClassGenerator::FLAG_FINAL
 162       * @configkey extendedclass  string        Class which this class is extending
 163       * @configkey implementedinterfaces
 164       * @configkey properties
 165       * @configkey methods
 166       *
 167       * @throws Exception\InvalidArgumentException
 168       * @param  array $array
 169       * @return ClassGenerator
 170       */
 171      public static function fromArray(array $array)
 172      {
 173          if (!isset($array['name'])) {
 174              throw new Exception\InvalidArgumentException(
 175                  'Class generator requires that a name is provided for this object'
 176              );
 177          }
 178  
 179          $cg = new static($array['name']);
 180          foreach ($array as $name => $value) {
 181              // normalize key
 182              switch (strtolower(str_replace(array('.', '-', '_'), '', $name))) {
 183                  case 'containingfile':
 184                      $cg->setContainingFileGenerator($value);
 185                      break;
 186                  case 'namespacename':
 187                      $cg->setNamespaceName($value);
 188                      break;
 189                  case 'docblock':
 190                      $docBlock = ($value instanceof DocBlockGenerator) ? $value : DocBlockGenerator::fromArray($value);
 191                      $cg->setDocBlock($docBlock);
 192                      break;
 193                  case 'flags':
 194                      $cg->setFlags($value);
 195                      break;
 196                  case 'extendedclass':
 197                      $cg->setExtendedClass($value);
 198                      break;
 199                  case 'implementedinterfaces':
 200                      $cg->setImplementedInterfaces($value);
 201                      break;
 202                  case 'properties':
 203                      $cg->addProperties($value);
 204                      break;
 205                  case 'methods':
 206                      $cg->addMethods($value);
 207                      break;
 208              }
 209          }
 210  
 211          return $cg;
 212      }
 213  
 214      /**
 215       * @param  string $name
 216       * @param  string $namespaceName
 217       * @param  array|string $flags
 218       * @param  string $extends
 219       * @param  array $interfaces
 220       * @param  array $properties
 221       * @param  array $methods
 222       * @param  DocBlockGenerator $docBlock
 223       */
 224      public function __construct(
 225          $name = null,
 226          $namespaceName = null,
 227          $flags = null,
 228          $extends = null,
 229          $interfaces = array(),
 230          $properties = array(),
 231          $methods = array(),
 232          $docBlock = null
 233      ) {
 234          $this->traitUsageGenerator = new TraitUsageGenerator($this);
 235  
 236          if ($name !== null) {
 237              $this->setName($name);
 238          }
 239          if ($namespaceName !== null) {
 240              $this->setNamespaceName($namespaceName);
 241          }
 242          if ($flags !== null) {
 243              $this->setFlags($flags);
 244          }
 245          if ($properties !== array()) {
 246              $this->addProperties($properties);
 247          }
 248          if ($extends !== null) {
 249              $this->setExtendedClass($extends);
 250          }
 251          if (is_array($interfaces)) {
 252              $this->setImplementedInterfaces($interfaces);
 253          }
 254          if ($methods !== array()) {
 255              $this->addMethods($methods);
 256          }
 257          if ($docBlock !== null) {
 258              $this->setDocBlock($docBlock);
 259          }
 260      }
 261  
 262      /**
 263       * @param  string $name
 264       * @return ClassGenerator
 265       */
 266      public function setName($name)
 267      {
 268          if (strstr($name, '\\')) {
 269              $namespace = substr($name, 0, strrpos($name, '\\'));
 270              $name      = substr($name, strrpos($name, '\\') + 1);
 271              $this->setNamespaceName($namespace);
 272          }
 273  
 274          $this->name = $name;
 275          return $this;
 276      }
 277  
 278      /**
 279       * @return string
 280       */
 281      public function getName()
 282      {
 283          return $this->name;
 284      }
 285  
 286      /**
 287       * @param  string $namespaceName
 288       * @return ClassGenerator
 289       */
 290      public function setNamespaceName($namespaceName)
 291      {
 292          $this->namespaceName = $namespaceName;
 293          return $this;
 294      }
 295  
 296      /**
 297       * @return string
 298       */
 299      public function getNamespaceName()
 300      {
 301          return $this->namespaceName;
 302      }
 303  
 304      /**
 305       * @param  FileGenerator $fileGenerator
 306       * @return ClassGenerator
 307       */
 308      public function setContainingFileGenerator(FileGenerator $fileGenerator)
 309      {
 310          $this->containingFileGenerator = $fileGenerator;
 311          return $this;
 312      }
 313  
 314      /**
 315       * @return FileGenerator
 316       */
 317      public function getContainingFileGenerator()
 318      {
 319          return $this->containingFileGenerator;
 320      }
 321  
 322      /**
 323       * @param  DocBlockGenerator $docBlock
 324       * @return ClassGenerator
 325       */
 326      public function setDocBlock(DocBlockGenerator $docBlock)
 327      {
 328          $this->docBlock = $docBlock;
 329          return $this;
 330      }
 331  
 332      /**
 333       * @return DocBlockGenerator
 334       */
 335      public function getDocBlock()
 336      {
 337          return $this->docBlock;
 338      }
 339  
 340      /**
 341       * @param  array|string $flags
 342       * @return ClassGenerator
 343       */
 344      public function setFlags($flags)
 345      {
 346          if (is_array($flags)) {
 347              $flagsArray = $flags;
 348              $flags      = 0x00;
 349              foreach ($flagsArray as $flag) {
 350                  $flags |= $flag;
 351              }
 352          }
 353          // check that visibility is one of three
 354          $this->flags = $flags;
 355  
 356          return $this;
 357      }
 358  
 359      /**
 360       * @param  string $flag
 361       * @return ClassGenerator
 362       */
 363      public function addFlag($flag)
 364      {
 365          $this->setFlags($this->flags | $flag);
 366          return $this;
 367      }
 368  
 369      /**
 370       * @param  string $flag
 371       * @return ClassGenerator
 372       */
 373      public function removeFlag($flag)
 374      {
 375          $this->setFlags($this->flags & ~$flag);
 376          return $this;
 377      }
 378  
 379      /**
 380       * @param  bool $isAbstract
 381       * @return ClassGenerator
 382       */
 383      public function setAbstract($isAbstract)
 384      {
 385          return (($isAbstract) ? $this->addFlag(self::FLAG_ABSTRACT) : $this->removeFlag(self::FLAG_ABSTRACT));
 386      }
 387  
 388      /**
 389       * @return bool
 390       */
 391      public function isAbstract()
 392      {
 393          return (bool) ($this->flags & self::FLAG_ABSTRACT);
 394      }
 395  
 396      /**
 397       * @param  bool $isFinal
 398       * @return ClassGenerator
 399       */
 400      public function setFinal($isFinal)
 401      {
 402          return (($isFinal) ? $this->addFlag(self::FLAG_FINAL) : $this->removeFlag(self::FLAG_FINAL));
 403      }
 404  
 405      /**
 406       * @return bool
 407       */
 408      public function isFinal()
 409      {
 410          return ($this->flags & self::FLAG_FINAL);
 411      }
 412  
 413      /**
 414       * @param  string $extendedClass
 415       * @return ClassGenerator
 416       */
 417      public function setExtendedClass($extendedClass)
 418      {
 419          $this->extendedClass = $extendedClass;
 420          return $this;
 421      }
 422  
 423      /**
 424       * @return string
 425       */
 426      public function getExtendedClass()
 427      {
 428          return $this->extendedClass;
 429      }
 430  
 431      /**
 432       * @param  array $implementedInterfaces
 433       * @return ClassGenerator
 434       */
 435      public function setImplementedInterfaces(array $implementedInterfaces)
 436      {
 437          $this->implementedInterfaces = $implementedInterfaces;
 438          return $this;
 439      }
 440  
 441      /**
 442       * @return array
 443       */
 444      public function getImplementedInterfaces()
 445      {
 446          return $this->implementedInterfaces;
 447      }
 448  
 449      /**
 450       * @param  string $constantName
 451       *
 452       * @return PropertyGenerator|false
 453       */
 454      public function getConstant($constantName)
 455      {
 456          if (isset($this->constants[$constantName])) {
 457              return $this->constants[$constantName];
 458          }
 459  
 460          return false;
 461      }
 462  
 463      /**
 464       * @return PropertyGenerator[] indexed by constant name
 465       */
 466      public function getConstants()
 467      {
 468          return $this->constants;
 469      }
 470  
 471      /**
 472       * @param  string $constantName
 473       * @return bool
 474       */
 475      public function hasConstant($constantName)
 476      {
 477          return isset($this->constants[$constantName]);
 478      }
 479  
 480      /**
 481       * Add constant from PropertyGenerator
 482       *
 483       * @param  PropertyGenerator           $constant
 484       * @throws Exception\InvalidArgumentException
 485       * @return ClassGenerator
 486       */
 487      public function addConstantFromGenerator(PropertyGenerator $constant)
 488      {
 489          $constantName = $constant->getName();
 490  
 491          if (isset($this->constants[$constantName])) {
 492              throw new Exception\InvalidArgumentException(sprintf(
 493                  'A constant by name %s already exists in this class.',
 494                  $constantName
 495              ));
 496          }
 497  
 498          if (! $constant->isConst()) {
 499              throw new Exception\InvalidArgumentException(sprintf(
 500                  'The value %s is not defined as a constant.',
 501                  $constantName
 502              ));
 503          }
 504  
 505          $this->constants[$constantName] = $constant;
 506  
 507          return $this;
 508      }
 509  
 510      /**
 511       * Add Constant
 512       *
 513       * @param  string $name
 514       * @param  string $value
 515       * @throws Exception\InvalidArgumentException
 516       * @return ClassGenerator
 517       */
 518      public function addConstant($name, $value)
 519      {
 520          if (!is_string($name)) {
 521              throw new Exception\InvalidArgumentException(sprintf(
 522                  '%s expects string for name',
 523                  __METHOD__
 524              ));
 525          }
 526  
 527          if (empty($value) || !is_string($value)) {
 528              throw new Exception\InvalidArgumentException(sprintf(
 529                  '%s expects value for constant, value must be a string',
 530                  __METHOD__
 531              ));
 532          }
 533  
 534          return $this->addConstantFromGenerator(new PropertyGenerator($name, $value, PropertyGenerator::FLAG_CONSTANT));
 535      }
 536  
 537      /**
 538       * @param  PropertyGenerator[]|array[] $constants
 539       *
 540       * @return ClassGenerator
 541       */
 542      public function addConstants(array $constants)
 543      {
 544          foreach ($constants as $constant) {
 545              if ($constant instanceof PropertyGenerator) {
 546                  $this->addPropertyFromGenerator($constant);
 547              } else {
 548                  if (is_array($constant)) {
 549                      call_user_func_array(array($this, 'addConstant'), $constant);
 550                  }
 551              }
 552          }
 553  
 554          return $this;
 555      }
 556  
 557      /**
 558       * @param  array $properties
 559       * @return ClassGenerator
 560       */
 561      public function addProperties(array $properties)
 562      {
 563          foreach ($properties as $property) {
 564              if ($property instanceof PropertyGenerator) {
 565                  $this->addPropertyFromGenerator($property);
 566              } else {
 567                  if (is_string($property)) {
 568                      $this->addProperty($property);
 569                  } elseif (is_array($property)) {
 570                      call_user_func_array(array($this, 'addProperty'), $property);
 571                  }
 572              }
 573          }
 574  
 575          return $this;
 576      }
 577  
 578      /**
 579       * Add Property from scalars
 580       *
 581       * @param  string $name
 582       * @param  string|array $defaultValue
 583       * @param  int $flags
 584       * @throws Exception\InvalidArgumentException
 585       * @return ClassGenerator
 586       */
 587      public function addProperty($name, $defaultValue = null, $flags = PropertyGenerator::FLAG_PUBLIC)
 588      {
 589          if (!is_string($name)) {
 590              throw new Exception\InvalidArgumentException(sprintf(
 591                  '%s::%s expects string for name',
 592                  get_class($this),
 593                  __FUNCTION__
 594              ));
 595          }
 596  
 597          // backwards compatibility
 598          // @todo remove this on next major version
 599          if ($flags === PropertyGenerator::FLAG_CONSTANT) {
 600              return $this->addConstant($name, $defaultValue);
 601          }
 602  
 603          return $this->addPropertyFromGenerator(new PropertyGenerator($name, $defaultValue, $flags));
 604      }
 605  
 606      /**
 607       * Add property from PropertyGenerator
 608       *
 609       * @param  PropertyGenerator           $property
 610       * @throws Exception\InvalidArgumentException
 611       * @return ClassGenerator
 612       */
 613      public function addPropertyFromGenerator(PropertyGenerator $property)
 614      {
 615          $propertyName = $property->getName();
 616  
 617          if (isset($this->properties[$propertyName])) {
 618              throw new Exception\InvalidArgumentException(sprintf(
 619                  'A property by name %s already exists in this class.',
 620                  $propertyName
 621              ));
 622          }
 623  
 624          // backwards compatibility
 625          // @todo remove this on next major version
 626          if ($property->isConst()) {
 627              return $this->addConstantFromGenerator($property);
 628          }
 629  
 630          $this->properties[$propertyName] = $property;
 631          return $this;
 632      }
 633  
 634      /**
 635       * @return PropertyGenerator[]
 636       */
 637      public function getProperties()
 638      {
 639          return $this->properties;
 640      }
 641  
 642      /**
 643       * @param  string $propertyName
 644       * @return PropertyGenerator|false
 645       */
 646      public function getProperty($propertyName)
 647      {
 648          foreach ($this->getProperties() as $property) {
 649              if ($property->getName() == $propertyName) {
 650                  return $property;
 651              }
 652          }
 653  
 654          return false;
 655      }
 656  
 657      /**
 658       * Add a class to "use" classes
 659       *
 660       * @param  string $use
 661       * @param  string|null $useAlias
 662       * @return ClassGenerator
 663       */
 664      public function addUse($use, $useAlias = null)
 665      {
 666          $this->traitUsageGenerator->addUse($use, $useAlias);
 667          return $this;
 668      }
 669  
 670      /**
 671       * Returns the "use" classes
 672       *
 673       * @return array
 674       */
 675      public function getUses()
 676      {
 677          return $this->traitUsageGenerator->getUses();
 678      }
 679  
 680      /**
 681       * @param  string $propertyName
 682       * @return bool
 683       */
 684      public function hasProperty($propertyName)
 685      {
 686          return isset($this->properties[$propertyName]);
 687      }
 688  
 689      /**
 690       * @param  array $methods
 691       * @return ClassGenerator
 692       */
 693      public function addMethods(array $methods)
 694      {
 695          foreach ($methods as $method) {
 696              if ($method instanceof MethodGenerator) {
 697                  $this->addMethodFromGenerator($method);
 698              } else {
 699                  if (is_string($method)) {
 700                      $this->addMethod($method);
 701                  } elseif (is_array($method)) {
 702                      call_user_func_array(array($this, 'addMethod'), $method);
 703                  }
 704              }
 705          }
 706  
 707          return $this;
 708      }
 709  
 710      /**
 711       * Add Method from scalars
 712       *
 713       * @param  string $name
 714       * @param  array $parameters
 715       * @param  int $flags
 716       * @param  string $body
 717       * @param  string $docBlock
 718       * @throws Exception\InvalidArgumentException
 719       * @return ClassGenerator
 720       */
 721      public function addMethod(
 722          $name = null,
 723          array $parameters = array(),
 724          $flags = MethodGenerator::FLAG_PUBLIC,
 725          $body = null,
 726          $docBlock = null
 727      ) {
 728          if (!is_string($name)) {
 729              throw new Exception\InvalidArgumentException(sprintf(
 730                  '%s::%s expects string for name',
 731                  get_class($this),
 732                  __FUNCTION__
 733              ));
 734          }
 735  
 736          return $this->addMethodFromGenerator(new MethodGenerator($name, $parameters, $flags, $body, $docBlock));
 737      }
 738  
 739      /**
 740       * Add Method from MethodGenerator
 741       *
 742       * @param  MethodGenerator                    $method
 743       * @throws Exception\InvalidArgumentException
 744       * @return ClassGenerator
 745       */
 746      public function addMethodFromGenerator(MethodGenerator $method)
 747      {
 748          $methodName = $method->getName();
 749  
 750          if ($this->hasMethod($methodName)) {
 751              throw new Exception\InvalidArgumentException(sprintf(
 752                  'A method by name %s already exists in this class.',
 753                  $methodName
 754              ));
 755          }
 756  
 757          $this->methods[strtolower($methodName)] = $method;
 758          return $this;
 759      }
 760  
 761      /**
 762       * @return MethodGenerator[]
 763       */
 764      public function getMethods()
 765      {
 766          return $this->methods;
 767      }
 768  
 769      /**
 770       * @param  string $methodName
 771       * @return MethodGenerator|false
 772       */
 773      public function getMethod($methodName)
 774      {
 775          return $this->hasMethod($methodName) ? $this->methods[strtolower($methodName)] : false;
 776      }
 777  
 778      /**
 779       * @param  string $methodName
 780       * @return ClassGenerator
 781       */
 782      public function removeMethod($methodName)
 783      {
 784          if ($this->hasMethod($methodName)) {
 785              unset($this->methods[strtolower($methodName)]);
 786          }
 787  
 788          return $this;
 789      }
 790  
 791      /**
 792       * @param  string $methodName
 793       * @return bool
 794       */
 795      public function hasMethod($methodName)
 796      {
 797          return isset($this->methods[strtolower($methodName)]);
 798      }
 799  
 800      /**
 801       * @inherit Zend\Code\Generator\TraitUsageInterface
 802       */
 803      public function addTrait($trait)
 804      {
 805          $this->traitUsageGenerator->addTrait($trait);
 806          return $this;
 807      }
 808  
 809      /**
 810       * @inherit Zend\Code\Generator\TraitUsageInterface
 811       */
 812      public function addTraits(array $traits)
 813      {
 814          $this->traitUsageGenerator->addTraits($traits);
 815          return $this;
 816      }
 817  
 818      /**
 819       * @inherit Zend\Code\Generator\TraitUsageInterface
 820       */
 821      public function hasTrait($traitName)
 822      {
 823          return $this->traitUsageGenerator->hasTrait($traitName);
 824      }
 825  
 826      /**
 827       * @inherit Zend\Code\Generator\TraitUsageInterface
 828       */
 829      public function getTraits()
 830      {
 831          return $this->traitUsageGenerator->getTraits();
 832      }
 833  
 834      /**
 835       * @inherit Zend\Code\Generator\TraitUsageInterface
 836       */
 837      public function removeTrait($traitName)
 838      {
 839          return $this->traitUsageGenerator->removeTrait($traitName);
 840      }
 841  
 842      /**
 843       * @inherit Zend\Code\Generator\TraitUsageInterface
 844       */
 845      public function addTraitAlias($method, $alias, $visibility = null)
 846      {
 847          $this->traitUsageGenerator->addTraitAlias($method, $alias, $visibility);
 848          return $this;
 849      }
 850  
 851      /**
 852       * @inherit Zend\Code\Generator\TraitUsageInterface
 853       */
 854      public function getTraitAliases()
 855      {
 856          return $this->traitUsageGenerator->getTraitAliases();
 857      }
 858  
 859      /**
 860       * @inherit Zend\Code\Generator\TraitUsageInterface
 861       */
 862      public function addTraitOverride($method, $traitsToReplace)
 863      {
 864          $this->traitUsageGenerator->addTraitOverride($method, $traitsToReplace);
 865          return $this;
 866      }
 867  
 868      /**
 869       * @inherit Zend\Code\Generator\TraitUsageInterface
 870       */
 871      public function removeTraitOverride($method, $overridesToRemove = null)
 872      {
 873          $this->traitUsageGenerator->removeTraitOverride($method, $overridesToRemove);
 874  
 875          return $this;
 876      }
 877  
 878      /**
 879       * @inherit Zend\Code\Generator\TraitUsageInterface
 880       */
 881      public function getTraitOverrides()
 882      {
 883          return $this->traitUsageGenerator->getTraitOverrides();
 884      }
 885  
 886      /**
 887       * @return bool
 888       */
 889      public function isSourceDirty()
 890      {
 891          if (($docBlock = $this->getDocBlock()) && $docBlock->isSourceDirty()) {
 892              return true;
 893          }
 894  
 895          foreach ($this->getProperties() as $property) {
 896              if ($property->isSourceDirty()) {
 897                  return true;
 898              }
 899          }
 900  
 901          foreach ($this->getMethods() as $method) {
 902              if ($method->isSourceDirty()) {
 903                  return true;
 904              }
 905          }
 906  
 907          return parent::isSourceDirty();
 908      }
 909  
 910      /**
 911       * @inherit Zend\Code\Generator\GeneratorInterface
 912       */
 913      public function generate()
 914      {
 915          if (!$this->isSourceDirty()) {
 916              $output = $this->getSourceContent();
 917              if (!empty($output)) {
 918                  return $output;
 919              }
 920          }
 921  
 922          $indent = $this->getIndentation();
 923          $output = '';
 924  
 925          if (null !== ($namespace = $this->getNamespaceName())) {
 926              $output .= 'namespace ' . $namespace . ';' . self::LINE_FEED . self::LINE_FEED;
 927          }
 928  
 929          $uses = $this->getUses();
 930  
 931          if (!empty($uses)) {
 932              foreach ($uses as $use) {
 933                  $output .= 'use ' . $use . ';' . self::LINE_FEED;
 934              }
 935  
 936              $output .= self::LINE_FEED;
 937          }
 938  
 939          if (null !== ($docBlock = $this->getDocBlock())) {
 940              $docBlock->setIndentation('');
 941              $output .= $docBlock->generate();
 942          }
 943  
 944          if ($this->isAbstract()) {
 945              $output .= 'abstract ';
 946          } elseif ($this->isFinal()) {
 947              $output .= 'final ';
 948          }
 949  
 950          $output .= static::OBJECT_TYPE . ' ' . $this->getName();
 951  
 952          if (!empty($this->extendedClass)) {
 953              $output .= ' extends ' . $this->extendedClass;
 954          }
 955  
 956          $implemented = $this->getImplementedInterfaces();
 957  
 958          if (!empty($implemented)) {
 959              $output .= ' implements ' . implode(', ', $implemented);
 960          }
 961  
 962          $output .= self::LINE_FEED . '{' . self::LINE_FEED . self::LINE_FEED;
 963          $output .= $this->traitUsageGenerator->generate();
 964  
 965          $constants = $this->getConstants();
 966  
 967          foreach ($constants as $constant) {
 968              $output .= $constant->generate() . self::LINE_FEED . self::LINE_FEED;
 969          }
 970  
 971          $properties = $this->getProperties();
 972  
 973          foreach ($properties as $property) {
 974              $output .= $property->generate() . self::LINE_FEED . self::LINE_FEED;
 975          }
 976  
 977          $methods = $this->getMethods();
 978  
 979          foreach ($methods as $method) {
 980              $output .= $method->generate() . self::LINE_FEED;
 981          }
 982  
 983          $output .= self::LINE_FEED . '}' . self::LINE_FEED;
 984  
 985          return $output;
 986      }
 987  }