Returns a map of render method tag values.

@param \TYPO3\Flow\Object\ObjectManagerInterface $objectManager
@return array An array of tags and their values or an empty array if no tags were found
@Flow\CompileStatic
481422
public static function getRenderMethodTagsValues($objectManager)
    {
        $className = get_called_class();
        if (!is_callable(array($className, 'render'))) {
            return array();
        }

        $reflectionService = $objectManager->get(\TYPO3\Flow\Reflection\ReflectionService::class);
        return $reflectionService->getMethodTagsValues($className, 'render');
    }
776833
public function load(ObjectManager $manager)
    {
        /**
         * Carts.
         *
         * @var CartInterface     $emptyCart
         * @var CartInterface     $fullCart
         * @var CustomerInterface $customer1
         * @var CustomerInterface $customer2
         * @var ProductInterface  $product
         * @var ProductInterface  $productReduced
         * @var CartLineInterface $cartLine1
         * @var CartLineInterface $cartLine2
         * @var ObjectDirector    $cartDirector
         * @var ObjectDirector    $cartLineDirector
         * @var AddressInterface  $address1
         * @var AddressInterface  $address2
         */
        $cartDirector = $this->getDirector('cart');
        $cartLineDirector = $this->getDirector('cart_line');

        $customer1 = $this->getReference('customer-1');
        $customer2 = $this->getReference('customer-2');
        $product = $this->getReference('product');
        $productReduced = $this->getReference('product-reduced');

        $address1 = $this->getReference('address-sant-celoni');
        $address2 = $this->getReference('address-viladecavalls');

        /**
         * Empty cart.
         */
        $emptyCart = $cartDirector
            ->create()
            ->setCustomer($customer1);

        $cartDirector->save($emptyCart);
        $this->addReference('empty-cart', $emptyCart);

        /**
         * Full cart.
         */
        $fullCart = $cartDirector
            ->create()
            ->setCustomer($customer2);

        $cartLine1 = $cartLineDirector
            ->create()
            ->setPurchasable($product)
            ->setPurchasableAmount($product->getPrice())
            ->setAmount($product->getPrice())
            ->setQuantity(2)
            ->setCart($fullCart);

        $cartLine2 = $cartLineDirector
            ->create()
            ->setPurchasable($productReduced)
            ->setPurchasableAmount($productReduced->getPrice())
            ->setAmount($productReduced->getPrice())
            ->setQuantity(2)
            ->setCart($fullCart);

        $fullCart
            ->addCartLine($cartLine1)
            ->addCartLine($cartLine2);

        $fullCart->setBillingAddress($address1);
        $fullCart->setDeliveryAddress($address2);

        $cartDirector->save($fullCart);
        $this->addReference('full-cart', $fullCart);
    }
278865
protected function getObjectManagerService(ServiceLocatorInterface $serviceLocator, $objectManagerServiceName)
    {
        $config = $serviceLocator->get('config');

        if (! $objectManagerServiceName && isset($config['thorr_persistence_dmm']['doctrine']['object_manager'])) {
            $objectManagerServiceName = $config['thorr_persistence_dmm']['doctrine']['object_manager'];
        }

        $objectManager = $objectManagerServiceName && $serviceLocator->has($objectManagerServiceName) ?
            $serviceLocator->get($objectManagerServiceName)
            : null;

        if (! $objectManager instanceof ObjectManager) {
            throw new Exception\InvalidServiceNameException(sprintf(
                'Invalid object manager type: "%s" is not a subtype of "%s"',
                is_object($objectManager) ? get_class($objectManager) : gettype($objectManager),
                ObjectManager::class
            ));
        }

        return $objectManager;
    }
95430
public function getObjectManager()
    {
        if (!$this->objectManager instanceof ObjectManager) {
            $this->setObjectManager($this->getServiceManager()->get('doctrine.entitymanager.orm_default'));
        }
        return $this->objectManager;
    }
18909
public function load(ObjectManager $manager)
    {
        $em = $this->container->get('doctrine.orm.entity_manager');

        $pageCreator = $this->container->get('kunstmaan_node.page_creator_service');

        $nodeRepo = $em->getRepository('KunstmaanNodeBundle:Node');
        $homePage = $nodeRepo->findOneBy(array('internalName' => 'homepage'));

        $sitemapPage = new SitemapPage();
        $sitemapPage->setTitle('Sitemap');

	$locales = explode('|', $this->container->getParameter('requiredlocales'));
        $translations = array();
	foreach ($locales as $locale) {
	    $translations[] = array('language' => $locale, 'callback' => function($page, $translation, $seo) {
		$translation->setTitle('Sitemap');
		$translation->setSlug('sitemap');
		$translation->setWeight(100);
	    });
	}

        $options = array(
            'parent' => $homePage,
            'page_internal_name' => 'sitemap',
            'set_online' => true,
            'hidden_from_nav' => true,
            'creator' => 'admin'
        );

        $pageCreator->createPage($sitemapPage, $translations, $options);
    }
1367960
private function registerRenderMethodArguments()
    {
        $methodParameters = static::getRenderMethodParameters($this->objectManager);
        if (count($methodParameters) === 0) {
            return;
        }

        if (Fluid::$debugMode) {
            $methodTags = static::getRenderMethodTagsValues($this->objectManager);

            $paramAnnotations = array();
            if (isset($methodTags['param'])) {
                $paramAnnotations = $methodTags['param'];
            }
        }

        $i = 0;
        foreach ($methodParameters as $parameterName => $parameterInfo) {
            $dataType = null;
            if (isset($parameterInfo['type'])) {
                $dataType = $parameterInfo['type'];
            } elseif ($parameterInfo['array']) {
                $dataType = 'array';
            }
            if ($dataType === null) {
                throw new Parser\Exception('could not determine type of argument "' . $parameterName . '" of the render-method in ViewHelper "' . get_class($this) . '". Either the methods docComment is invalid or some PHP optimizer strips off comments.', 1242292003);
            }

            $description = '';
            if (Fluid::$debugMode && isset($paramAnnotations[$i])) {
                $explodedAnnotation = explode(' ', $paramAnnotations[$i]);
                array_shift($explodedAnnotation);
                array_shift($explodedAnnotation);
                $description = implode(' ', $explodedAnnotation);
            }
            $defaultValue = null;
            if (isset($parameterInfo['defaultValue'])) {
                $defaultValue = $parameterInfo['defaultValue'];
            }
            $this->argumentDefinitions[$parameterName] = new ArgumentDefinition($parameterName, $dataType, $description, ($parameterInfo['optional'] === false), $defaultValue, true);
            $i++;
        }
    }
1374897
public function getObjectManager(): ObjectManagerInterface
    {
        if (!isset($this->earlyInstances[ObjectManagerInterface::class])) {
            debug_print_backtrace();
            throw new FlowException('The Object Manager is not available at this stage of the bootstrap run.', 1301120788);
        }
        return $this->earlyInstances[ObjectManagerInterface::class];
    }
1101426
public function GetPrimaryKeyMap($objectclass)
	{
		$fms = $this->GetFieldMaps($objectclass);
		foreach ($fms as $fm)
		{
			if ($fm->IsPrimaryKey)
			{
				return $fm;
			}
		}
	}
826287
protected function getInformationNeededForInitializeActionMethodValidators()
    {
        return [
            static::getActionValidationGroups($this->objectManager),
            static::getActionMethodParameters($this->objectManager),
            static::getActionValidateAnnotationData($this->objectManager),
            static::getActionIgnoredValidationArguments($this->objectManager)
        ];
    }
776452
public function loadEntityMap($objectManagerName)
    {
        $key = $this->getCacheKeyForObjectManagerName($objectManagerName);

        $cache = $this->getCache();

        if (false === $cache->contains($key)) {
            return false;
        }

        return $cache->fetch($key);
    }
1222962
public function getTagTree($objectId)
    {
        $tagRepo = $this->getDoctrine()->getRepository('NetworkingInitCmsBundle:Tag');
        $tags = $tagRepo->findBy(['level' => 1], ['path' => 'ASC']);

        return $this->renderView('@NetworkingInitCms/TagAdmin/tags.html.twig', [
            'noSort' => false,
            'tags' => $tags,
            'tagAdmin' => $this->admin,
            'lastItem' => $objectId, ]);
    }
46361
public function renderTags($subjectOrTags, array $options = [])
    {
        if (null === $this->tagRenderer) {
            $this->tagRenderer = new TagRenderer();
        }

        return $this->tagRenderer->renderTags($subjectOrTags, $options);
    }
1311004
private function findSubclassMappings(IObjectMapper $mapper, NestedMember $member) : array
    {
        /** @var ObjectType $type */
        $type  = $member->getParts()[0]->getSourceType();
        $class = $type->getClass();

        $subclassMappings = [];

        $this->walkSubclassMappings($subclassMappings, $mapper->getMapping(), $class);

        return $subclassMappings;
    }
345896
public function load(ObjectManager $manager)
    {
        $theme = new Theme();
        $theme->setTitle('Theme 1');
        $theme->setImage('/theme/images/screenshots/1-Penguins.jpg');
        $theme->setArea('admin');
        $theme->setPackage('default');
        $theme->setTheme('base');
        $manager->persist($theme);

        $theme = new Theme();
        $theme->setTitle('Theme 2');
        $theme->setImage('/theme/images/screenshots/2-Desert.jpg');
        $theme->setArea('admin');
        $theme->setPackage('default');
        $theme->setTheme('demo');
        $manager->persist($theme);
        $theme->setIsActive(1);
        $manager->persist($theme);

        $theme = new Theme();
        $theme->setTitle('Theme 3');
        $theme->setImage('/theme/images/screenshots/3-Tulips.jpg');
        $theme->setArea('frontend');
        $theme->setPackage('default');
        $theme->setTheme('base');
        $manager->persist($theme);

        $theme = new Theme();
        $theme->setTitle('Theme 4');
        $theme->setImage('/theme/images/screenshots/4-Koala.jpg');
        $theme->setArea('frontend');
        $theme->setPackage('default');
        $theme->setTheme('demo');
        $manager->persist($theme);
        $theme->setIsActive(1);
        $manager->persist($theme);

        $manager->flush();
    }
931068
public static function getActionValidationGroups($objectManager)
    {
        $reflectionService = $objectManager->get(ReflectionService::class);

        $result = [];

        $className = get_called_class();
        $methodNames = get_class_methods($className);
        foreach ($methodNames as $methodName) {
            if (strlen($methodName) > 6 && strpos($methodName, 'Action', strlen($methodName) - 6) !== false) {
                $validationGroupsAnnotation = $reflectionService->getMethodAnnotation($className, $methodName, Flow\ValidationGroups::class);
                if ($validationGroupsAnnotation !== null) {
                    $result[$methodName] = $validationGroupsAnnotation->validationGroups;
                }
            }
        }

        return $result;
    }
1296385
public function getObjectAttributeMappingMapper()
    {
        if (null === $this->objectAttributeMappingMapper) {
            $this->objectAttributeMappingMapper = $this->serviceLocator->get('playgroundflow_objectattributemapping_mapper');
        }
    
        return $this->objectAttributeMappingMapper;
    }
869340
public function getEntityClassNamesByObjectManagerName($objectManagerName)
    {
        /** @var ObjectManager $objectManager */
        $objectManager = $this->getDoctrineObjectManager()->get($objectManagerName);

        $allMetadata = $objectManager->getMetadataFactory()->getAllMetadata();

        $entityClassNames = [];
        foreach ($allMetadata as $classMetadata) {
            if ($classMetadata instanceof ClassMetadata) {
                $entityClassName = $classMetadata->getName();
                $entityClassNames[$entityClassName] = $entityClassName;
            }
        }

        return $entityClassNames;
    }