1 <?php

     2 

     3 /*

     4  * This file is part of the Symfony package.

     5  *

     6  * (c) Fabien Potencier <fabien@symfony.com>

     7  *

     8  * For the full copyright and license information, please view the LICENSE

     9  * file that was distributed with this source code.

    10  */

    11 

    12 namespace Symfony\Component\DependencyInjection\Compiler;

    13 

    14 /**

    15  * Compiler Pass Configuration

    16  *

    17  * This class has a default configuration embedded.

    18  *

    19  * @author Johannes M. Schmitt <schmittjoh@gmail.com>

    20  *

    21  * @api

    22  */

    23 class PassConfig

    24 {

    25     const TYPE_AFTER_REMOVING = 'afterRemoving';

    26     const TYPE_BEFORE_OPTIMIZATION = 'beforeOptimization';

    27     const TYPE_BEFORE_REMOVING = 'beforeRemoving';

    28     const TYPE_OPTIMIZE = 'optimization';

    29     const TYPE_REMOVE = 'removing';

    30 

    31     private $mergePass;

    32     private $afterRemovingPasses;

    33     private $beforeOptimizationPasses;

    34     private $beforeRemovingPasses;

    35     private $optimizationPasses;

    36     private $removingPasses;

    37 

    38     /**

    39      * Constructor.

    40      */

    41     public function __construct()

    42     {

    43         $this->mergePass = new MergeExtensionConfigurationPass();

    44 

    45         $this->afterRemovingPasses = array();

    46         $this->beforeOptimizationPasses = array();

    47         $this->beforeRemovingPasses = array();

    48 

    49         $this->optimizationPasses = array(

    50             new ResolveDefinitionTemplatesPass(),

    51             new ResolveParameterPlaceHoldersPass(),

    52             new CheckDefinitionValidityPass(),

    53             new ResolveReferencesToAliasesPass(),

    54             new ResolveInvalidReferencesPass(),

    55             new AnalyzeServiceReferencesPass(true),

    56             new CheckCircularReferencesPass(),

    57             new CheckReferenceValidityPass(),

    58         );

    59 

    60         $this->removingPasses = array(

    61             new RemovePrivateAliasesPass(),

    62             new RemoveAbstractDefinitionsPass(),

    63             new ReplaceAliasByActualDefinitionPass(),

    64             new RepeatedPass(array(

    65                 new AnalyzeServiceReferencesPass(),

    66                 new InlineServiceDefinitionsPass(),

    67                 new AnalyzeServiceReferencesPass(),

    68                 new RemoveUnusedDefinitionsPass(),

    69             )),

    70             new CheckExceptionOnInvalidReferenceBehaviorPass(),

    71         );

    72     }

    73 

    74     /**

    75      * Returns all passes in order to be processed.

    76      *

    77      * @return array An array of all passes to process

    78      *

    79      * @api

    80      */

    81     public function getPasses()

    82     {

    83         return array_merge(

    84             array($this->mergePass),

    85             $this->beforeOptimizationPasses,

    86             $this->optimizationPasses,

    87             $this->beforeRemovingPasses,

    88             $this->removingPasses,

    89             $this->afterRemovingPasses

    90         );

    91     }

    92 

    93     /**

    94      * Adds a pass.

    95      *

    96      * @param CompilerPassInterface $pass A Compiler pass

    97      * @param string $type The pass type

    98      * @throws \InvalidArgumentException when a pass type doesn't exist

    99      *

   100      * @api

   101      */

   102     public function addPass(CompilerPassInterface $pass, $type = self::TYPE_BEFORE_OPTIMIZATION)

   103     {

   104         $property = $type.'Passes';

   105         if (!isset($this->$property)) {

   106             throw new \InvalidArgumentException(sprintf('Invalid type "%s".', $type));

   107         }

   108 

   109         $passes = &$this->$property;

   110         $passes[] = $pass;

   111     }

   112 

   113     /**

   114      * Gets all passes for the AfterRemoving pass.

   115      *

   116      * @return array An array of passes

   117      *

   118      * @api

   119      */

   120     public function getAfterRemovingPasses()

   121     {

   122         return $this->afterRemovingPasses;

   123     }

   124 

   125     /**

   126      * Gets all passes for the BeforeOptimization pass.

   127      *

   128      * @return array An array of passes

   129      *

   130      * @api

   131      */

   132     public function getBeforeOptimizationPasses()

   133     {

   134         return $this->beforeOptimizationPasses;

   135     }

   136 

   137     /**

   138      * Gets all passes for the BeforeRemoving pass.

   139      *

   140      * @return array An array of passes

   141      *

   142      * @api

   143      */

   144     public function getBeforeRemovingPasses()

   145     {

   146         return $this->beforeRemovingPasses;

   147     }

   148 

   149     /**

   150      * Gets all passes for the Optimization pass.

   151      *

   152      * @return array An array of passes

   153      *

   154      * @api

   155      */

   156     public function getOptimizationPasses()

   157     {

   158         return $this->optimizationPasses;

   159     }

   160 

   161     /**

   162      * Gets all passes for the Removing pass.

   163      *

   164      * @return array An array of passes

   165      *

   166      * @api

   167      */

   168     public function getRemovingPasses()

   169     {

   170         return $this->removingPasses;

   171     }

   172 

   173     /**

   174      * Gets all passes for the Merge pass.

   175      *

   176      * @return array An array of passes

   177      *

   178      * @api

   179      */

   180     public function getMergePass()

   181     {

   182         return $this->mergePass;

   183     }

   184 

   185     /**

   186      * Sets the Merge Pass.

   187      *

   188      * @param CompilerPassInterface $pass The merge pass

   189      *

   190      * @api

   191      */

   192     public function setMergePass(CompilerPassInterface $pass)

   193     {

   194         $this->mergePass = $pass;

   195     }

   196 

   197     /**

   198      * Sets the AfterRemoving passes.

   199      *

   200      * @param array $passes An array of passes

   201      *

   202      * @api

   203      */

   204     public function setAfterRemovingPasses(array $passes)

   205     {

   206         $this->afterRemovingPasses = $passes;

   207     }

   208 

   209     /**

   210      * Sets the BeforeOptimization passes.

   211      *

   212      * @param array $passes An array of passes

   213      *

   214      * @api

   215      */

   216     public function setBeforeOptimizationPasses(array $passes)

   217     {

   218         $this->beforeOptimizationPasses = $passes;

   219     }

   220 

   221     /**

   222      * Sets the BeforeRemoving passes.

   223      *

   224      * @param array $passes An array of passes

   225      *

   226      * @api

   227      */

   228     public function setBeforeRemovingPasses(array $passes)

   229     {

   230         $this->beforeRemovingPasses = $passes;

   231     }

   232 

   233     /**

   234      * Sets the Optimization passes.

   235      *

   236      * @param array $passes An array of passes

   237      *

   238      * @api

   239      */

   240     public function setOptimizationPasses(array $passes)

   241     {

   242         $this->optimizationPasses = $passes;

   243     }

   244 

   245     /**

   246      * Sets the Removing passes.

   247      *

   248      * @param array $passes An array of passes

   249      *

   250      * @api

   251      */

   252     public function setRemovingPasses(array $passes)

   253     {

   254         $this->removingPasses = $passes;

   255     }

   256 }