Returns all registered asset usage strategies

@return array<\Neos\Media\Domain\Strategy\AssetUsageStrategyInterface>
@throws \Neos\Flow\ObjectManagement\Exception\UnknownObjectException
494986
protected function getUsageStrategies()
    {
        if (is_array($this->usageStrategies)) {
            return $this->usageStrategies;
        }

        $this->usageStrategies = [];
        $assetUsageStrategyImplementations = $this->reflectionService->getAllImplementationClassNamesForInterface(AssetUsageStrategyInterface::class);
        foreach ($assetUsageStrategyImplementations as $assetUsageStrategyImplementationClassName) {
            $this->usageStrategies[] = $this->objectManager->get($assetUsageStrategyImplementationClassName);
        }

        return $this->usageStrategies;
    }
420823
protected function getEngagements() {
        if (!$this->_engagements) {
            $this->_engagements = new EngagementList($this->version, $this->solution['sid']);
        }

        return $this->_engagements;
    }
916575
public function getUsage()
    {
        $string = [];

        $string[] = $this->getName();

        foreach ($this->getArguments() as $argument) {
            if ($argument->isRequired()) {
                $string[] = $argument->getName();
            } else {
                $string[] = "[{$argument->getName()}]";
            }
        }

        foreach ($this->getOptions() as $option) {
            $dashes = '-';
            if (!$option->isFlagOption()) {
                $dashes .= '-';
            }
            if ($option->isValueRequired()) {
                $optionString = "{$option->getName()}=value";
            } else {
                $optionString = "{$option->getName()}[=value]";
            }
            $string[] = "[{$dashes}{$optionString}]";
        }

        return implode(' ', $string);
    }
223818
public function getAssetParentAssets($asset)
    {
        $assetId = Utilities::getEntityId(
            $asset,
            'WindowsAzure\MediaServices\Models\Asset'
        );

        $propertyList = $this->_getEntityList("Assets('{$assetId}')/ParentAssets");
        $result = [];

        foreach ($propertyList as $properties) {
            $result[] = Asset::createFromOptions($properties);
        }

        return $result;
    }
614431
public function getUsage()
    {
        if ($this->usage === null) {
            $calculator = new SizeCalculator();
            $calculatedSize = $calculator->calculate($this->volume, $this->volume->findRootFolder());

            $this->usage = $calculatedSize->getSize();
        }

        return $this->usage;
    }
826287
protected function getInformationNeededForInitializeActionMethodValidators()
    {
        return [
            static::getActionValidationGroups($this->objectManager),
            static::getActionMethodParameters($this->objectManager),
            static::getActionValidateAnnotationData($this->objectManager),
            static::getActionIgnoredValidationArguments($this->objectManager)
        ];
    }
590522
public function assets()
    {
        $assets = $this->app->make('assets.collection')->all();

        if (! $this->getOption('all')) {
            $assets = array_filter($assets, function ($asset) {
                return $asset->getArea() !== 'admin';
            });
        }

        $headers = ['Slug', 'Type', 'Path', 'Area', 'Placement', 'Execution', 'Version'];

        $dataset = array_map(function ($asset) {
            return [
                $asset->getSlug(),
                $asset->getType(),
                $asset->getArgument('path'),
                $asset->getArea(),
                $asset->getPlacement(),
                $asset->getExecution(),
                $asset->getArgument('version'),
            ];
        }, $assets);

        $this->table($headers, $dataset);
    }
41422
public function getAll() : array
    {
        $convertedClaims = [];
        $timeFields = ['exp', 'nbf', 'iat'];

        // Convert date times to timestamps
        foreach ($this->claims as $name => $value) {
            if ($value !== null && in_array($name, $timeFields)) {
                /** @var DateTimeImmutable $value */
                $value = $value->getTimestamp();
            }

            $convertedClaims[$name] = $value;
        }

        if (!isset($this->claims['jti'])) {
            $convertedClaims['jti'] = $this->getId();
        }

        return $convertedClaims;
    }
1029804
protected function getStrategy()
	{
		if (is_null($this->strategy))
		{
			$this->strategy = new Strategy\DateTimeStrategy;
		}

		return $this->strategy;
	}
1089773
protected function getAssetsManifest()
    {
        if ($this->assetsManifest === null) {
            $assetsJsonFile = Mage::getDesign()->getSkinBaseDir().'/rev-manifest.json';

            if (file_exists($assetsJsonFile)) {
                $this->assetsManifest = json_decode(file_get_contents($assetsJsonFile), true);
            } else {
                $this->assetsManifest = [];
            }
        }

        return $this->assetsManifest;
    }
668010
public function getAssets()
    {
        $assets = [];
        $resources = $this->config()->getItem('meliscore/ressources');
        $useBuildAssets = (bool) $resources['build']['use_build_assets'];

        $cssBuild = $resources['build']['css'];
        $jsBuild = $resources['build']['js'];
        $webpack = file_get_contents($this->getWebPackMixFile());
        $webpackStatic = '';

        if (file_exists($this->getWebPackMixStaticFile())) {
            $webpackStatic = file_get_contents($this->getWebPackMixStaticFile());
        }

        $webpack .= $webpackStatic;

        $scripts = $this->getMergedAssets($useBuildAssets)['js'];
        $stylesheets = $this->getMergedAssets($useBuildAssets)['css'];

        $assets = [
            'css' => $stylesheets,
            'js' => $scripts,
        ];

        $nonBundledCss = $this->getMergedAssets()['css'];
        $nonBundledJs = $this->getMergedAssets()['js'];


        if ($useBuildAssets) {

            $nonBundledJs = array_map(function ($a) {
                // remove the URI query
                $a = str_replace('/', '\/', $a);

                return preg_replace('/\?(.+?)*/', '', $a);
            }, $nonBundledJs);

            $nonBundledCss = array_map(function ($a) {
                // remove the URI query
                $a = str_replace('/', '\/', $a);

                return preg_replace('/\?(.+?)*/', '', $a);
            }, $nonBundledCss);


            // check each file if it has been included in the build assets, if not then stack it
            // to the the assets
            foreach ($nonBundledJs as $key => $script) {
                if (!preg_match("/$script/", $webpack)) {
                    $jsBuild[$script] = $script;
                }
            }

            foreach ($nonBundledCss as $style) {
                if (!preg_match("/$style/", $webpack)) {
                    $cssBuild[$style] = $style;
                }
            }

            $cssBuild = array_map(function ($a) {
                return str_replace('\/', '/', $a);
            }, $cssBuild);

            $jsBuild = array_map(function ($a) {
                return str_replace('\/', '/', $a);
            }, $jsBuild);

        }

        return $assets;
    }
60532
public function getAssets()
    {
        $assets = $this->assets;

        // Spin through each directory and recursively merge the current directories assets
        // on to the directories assets. This maintains the order of adding in the array
        // structure.
        $this->directories->each(function($directory) use (&$assets)
        {
            $assets = $directory->getAssets()->merge($assets);
        });

        // Spin through each of the filters and apply them to each of the assets. Every filter
        // is applied and then later during the build will be removed if it does not apply
        // to a given asset.
        $this->filters->each(function($filter) use (&$assets)
        {
            $assets->each(function($asset) use ($filter) { $asset->apply($filter); });
        });

        return $assets;
    }
457345
protected static function useStatic()
	{
		if(isset(self::$_useStatic)) {
			return self::$_useStatic;
		}

		self::$_useStatic = AssetsSettings::assetsUseStatic();

		return self::$_useStatic;
	}
206511
public function analyticsAction()
    {
        $lastMonthActions = $this->analyticsManager->getDailyActionNumberForDateRange();
        $mostViewedWS = $this->analyticsManager->topWSByAction(null, 'ws_tool_read', 5);
        $mostViewedMedia = $this->analyticsManager->topMediaByAction(null, 'resource_read', 5);
        $mostDownloadedResources = $this->analyticsManager->topResourcesByAction(null, 'resource_export', 5);
        $usersCount = $this->userManager->countUsersForPlatformRoles();

        return array(
            'barChartData' => $lastMonthActions,
            'usersCount' => $usersCount,
            'mostViewedWS' => $mostViewedWS,
            'mostViewedMedia' => $mostViewedMedia,
            'mostDownloadedResources' => $mostDownloadedResources
        );
    }
148323
public function getUsedFields()
    {
        if (empty($this->usedFields)) {
            $this->usedFields = [];
            foreach (AddressField::getAll() as $field) {
                if (strpos($this->format, '%' . $field) !== false) {
                    $this->usedFields[] = $field;
                }
            }
        }

        return $this->usedFields;
    }
792127
protected function getUsings()
    {
        $usings = array();

        for ($i=0; $i<count($this->values); $i++) {
            $using = '"-" using 1:2 with '.$this->mode;
            if (isset($this->titles[$i])) {
                $using .= ' title "'.$this->titles[$i].'"';
            }
            $usings[] = $using;
        }

        return implode(', ', $usings);
    }
540415
protected function getActions() {
		$actions = new FieldList();
		foreach($this->getStrategies() as $strategyClass) {
			$strategyMethod = 'handleStrategy' . $strategyClass;
			$fa = new FormAction($strategyMethod, $strategyClass);
			$fa->setUseButtonTag(true);
			$actions->push($fa);
		}
		return $actions;
	}