Installer\Repository\RepositoryCollection::add PHP Method

add() public method

public add ( $repository )
    public function add($repository)
    {
        $this->collection[] = $repository;
    }

Usage Example

    /**
     * Generate Repository collection
     *
     * @param $input
     */
    private function getRepositoriesCollection($input, $config)
    {
        $repos = $config->repositories->installer;
        $reposCollection = new RepositoryCollection();
        $reposCollection->add(new Repository(
                                                $repos->symfony->source,
                                                $repos->symfony->target,
                                                $this->typeOfElement($repos->symfony->revision),
                                                $repos->symfony->revision
                                            ));
        $reposCollection->add(new Repository(
                                                $repos->monolog->source,
                                                $repos->monolog->target,
                                                $this->typeOfElement($repos->monolog->revision),
                                                $repos->monolog->revision
                                            ));
        if ($input->getOption('swiftmailer')) {
            $reposCollection->add(new Repository(
                                                    $repos->swiftmailer->source,
                                                    $repos->swiftmailer->target,
                                                    $this->typeOfElement($repos->swiftmailer->revision),
                                                    $repos->swiftmailer->revision
                                                ));
        }
        if ($input->getOption('assetic')) {
            $reposCollection->add(new Repository(
                                                    $repos->assetic->source,
                                                    $repos->assetic->target,
                                                    $this->typeOfElement($repos->assetic->revision),
                                                    $repos->assetic->revision
                                                ));
        }
        if ('twig' === $input->getOption('template-engine')) {
            $reposCollection->add(new Repository(
                                                    $repos->twig->source,
                                                    $repos->twig->target,
                                                    $this->typeOfElement($repos->twig->revision),
                                                    $repos->twig->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->twigextensions->source,
                                                    $repos->twigextensions->target,
                                                    $this->typeOfElement($repos->twigextensions->revision),
                                                    $repos->twigextensions->revision
                                                ));
        }
        if ('doctrine' === $input->getOption('orm')) {
            $reposCollection->add(new Repository(
                                                    $repos->doctrine->source,
                                                    $repos->doctrine->target,
                                                    $this->typeOfElement($repos->doctrine->revision),
                                                    $repos->doctrine->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->doctrinedbal->source,
                                                    $repos->doctrinedbal->target,
                                                    $this->typeOfElement($repos->doctrinedbal->revision),
                                                    $repos->doctrinedbal->revision
                                                ));
            if ($input->getOption('doctrine-fixtures')) {
                $reposCollection->add(new Repository(
                                                    $repos->doctrinedatafixtures->source,
                                                    $repos->doctrinedatafixtures->target,
                                                    $this->typeOfElement($repos->doctrinedatafixtures->revision),
                                                    $repos->doctrinedatafixtures->revision
                                                    ));
                $reposCollection->add(new Repository(
                                                    $repos->doctrinedatafixturesbundle->source,
                                                    $repos->doctrinedatafixturesbundle->target,
                                                    $this->typeOfElement($repos->doctrinedatafixturesbundle->revision),
                                                    $repos->doctrinedatafixturesbundle->revision
                                                    ));
            }
            if ($input->getOption('doctrine-migration')) {
                $reposCollection->add(new Repository(
                                                    $repos->doctrinemigrations->source,
                                                    $repos->doctrinemigrations->target,
                                                    $this->typeOfElement($repos->doctrinemigrations->revision),
                                                    $repos->doctrinemigrations->revision
                                                    ));
                $reposCollection->add(new Repository(
                                                    $repos->doctrinemigrationsbundle->source,
                                                    $repos->doctrinemigrationsbundle->target,
                                                    $this->typeOfElement($repos->doctrinemigrationsbundle->revision),
                                                    $repos->doctrinemigrationsbundle->revision
                                                    ));
            }
        }
        if (('doctrine' === $input->getOption('orm')) || ('mongodb' === $input->getOption('odm'))) {
            $reposCollection->add(new Repository(
                                                    $repos->doctrinecommon->source,
                                                    $repos->doctrinecommon->target,
                                                    $this->typeOfElement($repos->doctrinecommon->revision),
                                                    $repos->doctrinecommon->revision
                                                ));
        }
        if ('mongodb' === $input->getOption('odm')) {
            $reposCollection->add(new Repository(
                                                    $repos->doctrinemongodb->source,
                                                    $repos->doctrinemongodb->target,
                                                    $this->typeOfElement($repos->doctrinemongodb->revision),
                                                    $repos->doctrinemongodb->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->doctrinemongodbodm->source,
                                                    $repos->doctrinemongodbodm->target,
                                                    $this->typeOfElement($repos->doctrinemongodbodm->revision),
                                                    $repos->doctrinemongodbodm->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->doctrinemongodbbundle->source,
                                                    $repos->doctrinemongodbbundle->target,
                                                    $this->typeOfElement($repos->doctrinemongodbbundle->revision),
                                                    $repos->doctrinemongodbbundle->revision
                                                ));
        }
        if ('mandango' === $input->getOption('odm')) {
            $reposCollection->add(new Repository(
                                                    $repos->mandango->source,
                                                    $repos->mandango->target,
                                                    $this->typeOfElement($repos->mandango->revision),
                                                    $repos->mandango->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->mondator->source,
                                                    $repos->mondator->target,
                                                    $this->typeOfElement($repos->mondator->revision),
                                                    $repos->mondator->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->mandangobundle->source,
                                                    $repos->mandangobundle->target,
                                                    $this->typeOfElement($repos->mandangobundle->revision),
                                                    $repos->mandangobundle->revision
                                                ));
        }
        if ('propel' === $input->getOption('orm')) {
            $reposCollection->add(new Repository(
                                                    $repos->propelbundle->source,
                                                    $repos->propelbundle->target,
                                                    $this->typeOfElement($repos->propelbundle->revision),
                                                    $repos->propelbundle->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->phing->source,
                                                    $repos->phing->target,
                                                    $this->typeOfElement($repos->phing->revision),
                                                    $repos->phing->revision
                                                ));
            $reposCollection->add(new Repository(
                                                    $repos->propel->source,
                                                    $repos->propel->target,
                                                    $this->typeOfElement($repos->propel->revision),
                                                    $repos->propel->revision
                                                ));
        }

        if ($config_user = $config->repositories->user) {
            $reposCollection = $this->addCustomRepositoriesToCollection($reposCollection, $config_user);
        }

        return $reposCollection->get();
    }
RepositoryCollection