PHP PackageInterface::getReplaces方法代碼示例

 protected function enableReplaces(PackageInterface $package)
 {
     // we may "replace" any of the packages (e.g. ext-mbstring is bundled with PHP) that have been required
     // figure out which those are so we can decide if they need enabling (because they're built shared)
     $enable = array_intersect_key($package->getReplaces(), $this->allPlatformRequirements);
     foreach (array_keys($enable) as $extension) {
         $this->enableExtension($extension, $package);
     }
 }

 /**
  * Checks if the package matches the given constraint directly or through
  * provided or replaced packages
  *
  * @param  array|PackageInterface $candidate
  * @param  string                 $name       Name of the package to be matched
  * @param  ConstraintInterface    $constraint The constraint to verify
  * @return int                    One of the MATCH* constants of this class or 0 if there is no match
  */
 private function match($candidate, $name, ConstraintInterface $constraint = null)
 {
     $candidateName = $candidate->getName();
     $candidateVersion = $candidate->getVersion();
     $isDev = $candidate->getStability() === 'dev';
     $isAlias = $candidate instanceof AliasPackage;
     if (!$isDev && !$isAlias && isset($this->filterRequires[$name])) {
         $requireFilter = $this->filterRequires[$name];
     } else {
         $requireFilter = new EmptyConstraint();
     }
     if ($candidateName === $name) {
         $pkgConstraint = new Constraint('==', $candidateVersion);
         if ($constraint === null || $constraint->matches($pkgConstraint)) {
             return $requireFilter->matches($pkgConstraint) ? self::MATCH : self::MATCH_FILTERED;
         }
         return self::MATCH_NAME;
     }
     $provides = $candidate->getProvides();
     $replaces = $candidate->getReplaces();
     // aliases create multiple replaces/provides for one target so they can not use the shortcut below
     if (isset($replaces[0]) || isset($provides[0])) {
         foreach ($provides as $link) {
             if ($link->getTarget() === $name && ($constraint === null || $constraint->matches($link->getConstraint()))) {
                 return $requireFilter->matches($link->getConstraint()) ? self::MATCH_PROVIDE : self::MATCH_FILTERED;
             }
         }
         foreach ($replaces as $link) {
             if ($link->getTarget() === $name && ($constraint === null || $constraint->matches($link->getConstraint()))) {
                 return $requireFilter->matches($link->getConstraint()) ? self::MATCH_REPLACE : self::MATCH_FILTERED;
             }
         }
         return self::MATCH_NONE;
     }
     if (isset($provides[$name]) && ($constraint === null || $constraint->matches($provides[$name]->getConstraint()))) {
         return $requireFilter->matches($provides[$name]->getConstraint()) ? self::MATCH_PROVIDE : self::MATCH_FILTERED;
     }
     if (isset($replaces[$name]) && ($constraint === null || $constraint->matches($replaces[$name]->getConstraint()))) {
         return $requireFilter->matches($replaces[$name]->getConstraint()) ? self::MATCH_REPLACE : self::MATCH_FILTERED;
     }
     return self::MATCH_NONE;
 }

 /**
  * Checks if source replaces a package with the same name as target.
  *
  * Replace constraints are ignored. This method should only be used for
  * prioritisation, not for actual constraint verification.
  *
  * @param  PackageInterface $source
  * @param  PackageInterface $target
  * @return bool
  */
 protected function replaces(PackageInterface $source, PackageInterface $target)
 {
     foreach ($source->getReplaces() as $link) {
         if ($link->getTarget() === $target->getName()) {
             return true;
         }
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function getReplaces()
 {
     return $this->package->getReplaces();
 }

 /**
  * Returns the installation path of a package
  *
  * @param  PackageInterface $package
  * @return string           path
  */
 public function getInstallPath(PackageInterface $package)
 {
     $extensionKey = '';
     foreach ($package->getReplaces() as $packageName => $version) {
         if (strpos($packageName, '/') === FALSE) {
             $extensionKey = trim($packageName);
             break;
         }
     }
     if (empty($extensionKey)) {
         list(, $extensionKey) = explode('/', $package->getName(), 2);
         $extensionKey = str_replace('-', '_', $extensionKey);
     }
     return $this->extensionDir . DIRECTORY_SEPARATOR . $extensionKey;
 }