return any cache relevant parameters to the list class here.

@return array
439323
public function _GetCacheParameters()
    {
        $aParams = array();
        $oShop = TdbShop::GetInstance();

        $oActiveCategory = $oShop->GetActiveCategory();
        if (!is_null($oActiveCategory)) {
            $aParams['activecategoryid'] = $oActiveCategory->id;
        }
        $oActiveManufacturer = TdbShop::GetActiveManufacturer();
        if ($oActiveManufacturer) {
            $aParams['activemanufacturerid'] = $oActiveManufacturer->id;
        }

        return $aParams;
    }
964967
protected static function getParams()
    {
        $adapter  = app(FilterAdapter::class)->add(ActivityTypeWidgetFilter::class);
        $request  = app('request');
        $priority = $request->get('priority');
        $search   = $request->get('search');
        $logs     = self::filter($priority, $search);
        return [
            'select_url'        => self::getBaseUrl(['page' => 1, 'per_page' => self::perPage, 'search' => '']),
            'search_url'        => self::getBaseUrl(['page' => 1, 'per_page' => self::perPage, 'priority' => null]),
            'url'               => self::getBaseUrl(),
            'selected_priority' => $priority,
            'search'            => $search,
            'types'             => app(LogTypes::class)->all(),
            'logs'              => $logs,
            'pagination'        => $logs->links('antares/foundation::layouts.antares.partials.pagination._pagination'),
            'priorites'         => app(LogPriorities::class)->all(),
            'filters'           => $adapter->getFilters('antares/logger::admin.widgets.log_filter')
        ];
    }
1090617
public function getParameters()
    {
        $params = [];
        foreach (self::$languageConstructs[$this->keyword] as $parameter => $opts) {
            \array_push($params, new ReflectionLanguageConstructParameter($this->keyword, $parameter, $opts));
        }

        return $params;
    }
1113000
private static function constants(): array
    {
        $class = get_called_class();

        if (isset(self::$constants[$class])) {
            return self::$constants[$class];
        }

        $reflection = new \ReflectionClass($class);

        return self::$constants[$class] = $reflection->getConstants();
    }
828241
public static function toList()
    {
        $class = static::class;
        if (!array_key_exists($class, self::$cache)) {
            $reflection = new \ReflectionClass($class);
            self::$cache[$class] = $reflection->getConstants();
        }

        return self::$cache[$class];
    }
507826
protected function getKernelParameters()
    {
        $bundles = [];
        $bundlesMetadata = [];

        foreach ($this->bundles as $name => $bundle) {
            $bundles[$name] = \get_class($bundle);
            $bundlesMetadata[$name] = [
                'path' => $bundle->getPath(),
                'namespace' => $bundle->getNamespace(),
            ];
        }

        return [
            /*
             * @deprecated since Symfony 4.2, use kernel.project_dir instead
             */
            'kernel.root_dir' => realpath($this->rootDir) ?: $this->rootDir,
            'kernel.project_dir' => realpath($this->getProjectDir()) ?: $this->getProjectDir(),
            'kernel.environment' => $this->environment,
            'kernel.debug' => $this->debug,
            /*
             * @deprecated since Symfony 4.2
             */
            'kernel.name' => $this->name,
            'kernel.cache_dir' => realpath($cacheDir = $this->warmupDir ?: $this->getCacheDir()) ?: $cacheDir,
            'kernel.logs_dir' => realpath($this->getLogDir()) ?: $this->getLogDir(),
            'kernel.bundles' => $bundles,
            'kernel.bundles_metadata' => $bundlesMetadata,
            'kernel.charset' => $this->getCharset(),
            'kernel.container_class' => $this->getContainerClass(),
        ];
    }
272329
protected function getSettingsConfig(): array
    {
        if (!$this->cache instanceof Cache) {
            $this->items = $this->model->getSettings();
        } else {
            $cacheItems = $this->cache->get($this->cacheKey);
            if (!empty($cacheItems)) {
                $this->items = $cacheItems;
            } else {
                $this->items = $this->model->getSettings();
                $this->cache->set($this->cacheKey, $this->items);
            }
        }

        return $this->items;
    }
205629
public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }
509025
final public static function all() : array
    {
        static $all = null;

        if ($all === null) {
            foreach ((new \ReflectionClass(get_called_class()))->getConstants() as $constant) {
                $all[] = new static($constant);
            }
        }

        return $all;
    }
486288
public function get()
    {
        $parameters = [];
        foreach ($this->parameters as $parameter) {
            $parameters[] = $parameter->get();
        }

        return [
            'type' => 'new',
            'class' => $this->className,
            'parameters' => $parameters,
            'dynamic' => $this->dynamic,
            'file' => $this->file,
            'line' => $this->line,
            'char' => $this->char,
        ];
    }
69998
public static function getConstList() : array
    {
        if (static::$constList === null) {
            $reflection        = new ReflectionClass(get_called_class());
            static::$constList = array_values($reflection->getConstants());
        }

        return static::$constList;
    }
798871
public function _GetCacheParameters()
    {
        $aParameters = parent::_GetCacheParameters();

        $oShop = TdbShop::GetInstance();
        $oActiveCategory = $oShop->GetActiveCategory();
        $oActiveItem = $oShop->GetActiveItem();

        if (!is_null($oActiveCategory)) {
            $aParameters['activecategoryid'] = $oActiveCategory->id;
        }
        if (!is_null($oActiveItem)) {
            $aParameters['activeitemid'] = $oActiveItem->id;
        }

        return $aParameters;
    }
796655
public function getAll()
	{
		$keys = eaccelerator_list_keys();

		$hash = $this->options['hash'];

		$data = array();

		foreach ($keys as $key)
		{
			// Trim leading ":" to work around list_keys namespace bug in eAcc.
			// This will still work when bug is fixed.
			$name    = ltrim($key['name'], ':');
			$namearr = explode('-', $name);

			if ($namearr !== false && $namearr[0] == $hash && $namearr[1] == 'cache')
			{
				$group = $namearr[2];

				if (!isset($data[$group]))
				{
					$item = new Auditor($group);
				}
				else
				{
					$item = $data[$group];
				}

				$item->tally($key['size'] / 1024);

				$data[$group] = $item;
			}
		}

		return $data;
	}
979206
public static function getList()
    {
        $calledClass = get_called_class();
        if (!isset(static::$list[$calledClass])) {
            $refClass = new \ReflectionClass($calledClass);
            $labels   = static::getLabels();
            foreach ($refClass->getConstants() as $constName => $constValue) {
                if (isset($labels[$constValue])) {
                    $label = $labels[$constValue];
                } else {
                    $label = lcfirst(strtolower($constName));
                }
                static::$list[$calledClass][$constValue] = $label;
            }
        }
        return static::$list[$calledClass];
    }
764351
public function getFilterParameters()
    {
        $http = eZHTTPTool::instance();
        $filterList = array();
        if ( $http->hasGetVariable( 'filter' ) )
        {
            foreach ( $http->getVariable( 'filter' ) as $filterCond )
            {
                list( $name, $value ) = explode( ':', $filterCond, 2 );
                $filterList[$name] = $value;
            }
        }

        return array( 'result' => $filterList );
    }
580993
public static final function values() {
		$calledClass = get_called_class();

		// let's check the cache so we don't have to call reflection constantly
		if (empty(self::$cachedValues[$calledClass])) {
			$class = new \ReflectionClass($calledClass);
			self::$cachedValues[$calledClass] = $class->getConstants();
		}

		return self::$cachedValues[$calledClass];
	}
600531
public static function getConstants() : array
    {
        if (self::$constCacheArray == null) {
            self::$constCacheArray = [];
        }
        $calledClass = get_called_class();
        if (!array_key_exists($calledClass, self::$constCacheArray)) {
            $reflect = new ReflectionClass($calledClass);
            self::$constCacheArray[$calledClass] = $reflect->getConstants();
        }
        return self::$constCacheArray[$calledClass];
    }