PHP FactoryInterface::createNew方法代码示例

 /**
  * {@inheritdoc}
  */
 public function createWithVariant()
 {
     $variant = $this->variantFactory->createNew();
     $product = $this->factory->createNew();
     $product->addVariant($variant);
     return $product;
 }

 /**
  * {@inheritdoc}
  */
 public function createWithCustomer(CustomerInterface $customer)
 {
     /** @var  AddressInterface $address*/
     $address = $this->decoratedFactory->createNew();
     $address->setCustomer($customer);
     return $address;
 }

 /**
  * {@inheritdoc}
  */
 public function createNew()
 {
     /** @var StaticContent $staticContent */
     $staticContent = $this->decoratedFactory->createNew();
     $staticContent->setParentDocument($this->documentManager->find(null, $this->staticContentParentPath));
     return $staticContent;
 }

 /**
  * {@inheritdoc}
  */
 public function generate(VariableInterface $variable)
 {
     if (!$variable->hasOptions()) {
         throw new \InvalidArgumentException('Cannot generate variants for an object without options.');
     }
     $optionSet = array();
     $optionMap = array();
     foreach ($variable->getOptions() as $k => $option) {
         foreach ($option->getValues() as $value) {
             $optionSet[$k][] = $value->getId();
             $optionMap[$value->getId()] = $value;
         }
     }
     $permutations = $this->setBuilder->build($optionSet);
     foreach ($permutations as $permutation) {
         $variant = $this->variantFactory->createNew();
         $variant->setObject($variable);
         $variant->setDefaults($variable->getMasterVariant());
         if (is_array($permutation)) {
             foreach ($permutation as $id) {
                 $variant->addOption($optionMap[$id]);
             }
         } else {
             $variant->addOption($optionMap[$permutation]);
         }
         $variable->addVariant($variant);
         $this->process($variable, $variant);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function createNew()
 {
     /** @var Route $route */
     $route = $this->decoratedFactory->createNew();
     $route->setParentDocument($this->documentManager->find(null, $this->routeParentPath));
     return $route;
 }

 /**
  * {@inheritdoc}
  */
 public function load($schemaAlias, $namespace = null, $ignoreUnknown = true)
 {
     /** @var SchemaInterface $schema */
     $schema = $this->schemaRegistry->get($schemaAlias);
     /** @var SettingsResolverInterface $resolver */
     $resolver = $this->resolverRegistry->get($schemaAlias);
     // try to resolve settings for schema alias and namespace
     $settings = $resolver->resolve($schemaAlias, $namespace);
     if (!$settings) {
         $settings = $this->settingsFactory->createNew();
         $settings->setSchemaAlias($schemaAlias);
     }
     // We need to get a plain parameters array since we use the options resolver on it
     $parameters = $settings->getParameters();
     $settingsBuilder = new SettingsBuilder();
     $schema->buildSettings($settingsBuilder);
     // Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
     if (true === $ignoreUnknown) {
         foreach ($parameters as $name => $value) {
             if (!$settingsBuilder->isDefined($name)) {
                 unset($parameters[$name]);
             }
         }
     }
     $parameters = $settingsBuilder->resolve($parameters);
     $settings->setParameters($parameters);
     return $settings;
 }

 /**
  * {@inheritdoc}
  */
 public function createForPromotion(PromotionInterface $promotion)
 {
     Assert::true($promotion->isCouponBased(), sprintf('Promotion with name %s is not coupon based.', $promotion->getName()));
     $coupon = $this->factory->createNew();
     $coupon->setPromotion($promotion);
     return $coupon;
 }

 /**
  * @Given the store has disabled locale :localeCode
  */
 public function theStoreHasDisabledLocale($localeCode)
 {
     $locale = $this->localeFactory->createNew();
     $locale->setCode($localeCode);
     $locale->disable();
     $this->saveLocale($locale);
 }

 /**
  * @param string $name
  *
  * @return TaxonInterface
  */
 private function createTaxon($name)
 {
     $taxon = $this->taxonFactory->createNew();
     $taxon->setName($name);
     $taxon->setCode($this->getCodeFromName($name));
     return $taxon;
 }

 /**
  * {@inheritdoc}
  */
 public function createNew()
 {
     $taxon = $this->taxonFactory->createNew();
     $taxonomy = $this->translatableFactory->createNew();
     $taxonomy->setRoot($taxon);
     return $taxonomy;
 }

 /**
  * {@inheritdoc}
  */
 public function create(array $options = [])
 {
     $options = $this->optionsResolver->resolve($options);
     /** @var PromotionInterface $promotion */
     $promotion = $this->promotionFactory->createNew();
     $promotion->setCode($options['code']);
     $promotion->setName($options['name']);
     $promotion->setDescription($options['description']);
     $promotion->setCouponBased($options['coupon_based']);
     $promotion->setUsageLimit($options['usage_limit']);
     $promotion->setExclusive($options['exclusive']);
     $promotion->setPriority($options['priority']);
     if (isset($options['starts_at'])) {
         $promotion->setStartsAt(new \DateTime($options['starts_at']));
     }
     if (isset($options['ends_at'])) {
         $promotion->setEndsAt(new \DateTime($options['ends_at']));
     }
     foreach ($options['channels'] as $channel) {
         $promotion->addChannel($channel);
     }
     foreach ($options['rules'] as $rule) {
         /** @var PromotionRuleInterface $promotionRule */
         $promotionRule = $this->promotionRuleExampleFactory->create($rule);
         $promotion->addRule($promotionRule);
     }
     foreach ($options['actions'] as $action) {
         /** @var PromotionActionInterface $promotionAction */
         $promotionAction = $this->promotionActionExampleFactory->create($action);
         $promotion->addAction($promotionAction);
     }
     return $promotion;
 }

 /**
  * @param string $name
  */
 private function createCountryNamed($name)
 {
     /** @var CountryInterface $country */
     $country = $this->countryFactory->createNew();
     $country->setCode($this->countryNameConverter->convertToCode($name));
     $this->countryRepository->add($country);
 }

 /**
  * @param string $name
  */
 private function createCountryNamed($name)
 {
     /** @var CountryInterface $country */
     $country = $this->countryFactory->createNew();
     $country->setCode($this->getCountryCodeByEnglishCountryName($name));
     $this->countryRepository->add($country);
 }

 /**
  * @param array $options
  *
  * @return FormView
  */
 public function getItemFormView(array $options = array())
 {
     $cartItem = $this->cartItemFactory->createNew();
     $this->orderItemQuantityModifier->modify($cartItem, 1);
     $form = $this->formFactory->create('sylius_cart_item', $cartItem, $options);
     return $form->createView();
 }

 /**
  * @param string $name
  */
 private function createCustomerGroup($name)
 {
     /** @var CustomerGroupInterface $customerGroup */
     $customerGroup = $this->customerGroupFactory->createNew();
     $customerGroup->setName(ucfirst($name));
     $this->sharedStorage->set('customer_group', $customerGroup);
     $this->customerGroupRepository->add($customerGroup);
 }