Run the search for the complex attribute geolocation.

@param Container $container The container with all information.
@param IFilter   $filter    The filter container.

@return void

@see https://www.movable-type.co.uk/scripts/latlong.html
969456
protected function doSearchForAttGeolocation($container, $filter)
    {
        // Calculate distance, bearing and more between Latitude/Longitude points
        $distanceCalculation = HaversineSphericalDistance::getFormulaAsQueryPart(
            $container->getLatitude(),
            $container->getLongitude(),
            $this->connection->quoteIdentifier('latitude'),
            $this->connection->quoteIdentifier('longitude')
        );

        $builder = $this->connection->createQueryBuilder();
        $builder
            ->select($this->connection->quoteIdentifier('item_id'))
            ->from('tl_metamodel_geolocation')
            ->where($builder->expr()->lte($distanceCalculation, ':distance'))
            ->andWhere($builder->expr()->eq($this->connection->quoteIdentifier('att_id'), ':attributeID'))
            ->orderBy($distanceCalculation)
            ->setParameter('distance', $container->getDistance())
            ->setParameter('attributeID', $this->getMetaModel()->getAttribute($this->get('single_attr_id'))->get('id'));

        $statement = $builder->execute();

        if (!$statement->rowCount()) {
            $filter->addFilterRule(new StaticIdList([]));
        } else {
            $filter->addFilterRule(new StaticIdList($statement->fetchAll(\PDO::FETCH_COLUMN)));
        }
    }
26976
private void searchAtLocation(Coordinate location, boolean isShift) {
		Geometry point = new Geometry(Geometry.POINT, 0, -1);
		point.setCoordinates(new Coordinate[] { location });

		GeomajasServerExtension
				.getInstance()
				.getServerFeatureService()
				.search(mapPresenter, point, pixelsToUnits(pixelTolerance), QueryType.INTERSECTS, searchLayerType, -1,
						new SelectionCallback(isShift, false));
	}
1074552
public function whereRaw($filter, $bind = null)
    {
        $this->_conditions[] = $filter;

        if ($bind !== null) {
            $this->_bind = array_merge($this->_bind, $bind);
        }

        return $this;
    }
281876
public function buildGlobalFilterRegistries(ContainerBuilder $container)
    {
        $filters          = $container->findTaggedServiceIds('spray_persistence.entity_filter');
        $registries = $container->findTaggedServiceIds('spray_persistence.filter_registry');
        foreach ($filters as $filterId => $filterOptions) {
            foreach (array_filter($filterOptions, array($this, 'filterGlobalFilterOptions')) as $options) {
                foreach ($registries as $registryId => $registryOptions) {
                    $this->attachFilterToRegistry(
                        $this->locateFilterRegistry($container, $registryId),
                        $filterId,
                        $options
                    );
                }
            }
        }
    }
313376
public void addMappingFilter(String mapping, com.ibm.websphere.servlet.filter.IFilterConfig config){
        	context.addMappingFilter(mapping, config);
        }
930831
public function toArray(iFilter $filter)
	{
		$result = array();
		if($this->uuid != null)
			$result[Database::XML_UUID] = $this->uuid;
		if($this->name != null)
			$result[Database::XML_NAME] = $this->name;
		if($this->icon != null && $filter->acceptIcons())
			$result[Database::XML_ICONID] = $this->icon;
		if($this->customIcon != null && $filter->acceptIcons())
			$result[Database::XML_CUSTOMICONUUID] = $this->customIcon;
		if($this->groups != null)
		{
			$groups = array();
			foreach($this->groups as &$group)
			{
				if($filter->acceptGroup($group))
					$groups[] = $group->toArray($filter);
			}
			if(!empty($groups))
				$result[Database::GROUPS] = $groups;
		}
		if($this->entries != null)
		{
			$entries = array();
			foreach($this->entries as &$entry)
			{
				if($filter->acceptEntry($entry))
					$entries[] = $entry->toArray($filter);
			}
			if(!empty($entries))
				$result[Database::ENTRIES] = $entries;
		}
		return $result;
	}
28286
public function searchByLocation($lat, $long){
        if($lat != null && $long != null){
            $this->addParam("lat", $lat);
            $this->addParam("lng", $long);
        }
    }
1109577
public function process(ContainerBuilder $container): void
    {
        if (!$container->has('assetic.twig_formula_loader.real')) {
            return;
        }

        $container
            ->findDefinition('assetic.twig_formula_loader.real')
            ->replaceArgument(1, null);
    }
450614
public function process(ContainerBuilder $container)
    {
        $factory = $container->findDefinition(FilterFactory::class);

        $filters = [];

        foreach ($container->findTaggedServiceIds(self::FILTER_TAG) as $id => $attributes) {
            $filters[$id] = new Reference($id);
        }

        $factory->replaceArgument(0, ServiceLocatorTagPass::register($container, $filters));
    }
782081
private function search(AbstractFilter $filter)
    {
        if ($this->ldapSearchOptions) {
            $ldapResource = $this->ldap->getResource();
            foreach ($this->ldapSearchOptions as $name => $options) {
                ldap_set_option($ldapResource, $name, $options);
            }
        }

        return $this->ldap->searchEntries($filter, null, Ldap::SEARCH_SCOPE_SUB, $this->entryAttributesToFetch);
    }
540546
private function setFiltersManager($repository, ContainerBuilder $container)
    {
        $definition = new Definition(
            'ONGR\FilterManagerBundle\Search\FilterManager',
            [
                new Reference('ongr_translations.filters_container'),
                new Reference($repository),
                new Reference('event_dispatcher'),
                new Reference('jms_serializer')
            ]
        );

        $container->setDefinition('ongr_translations.filter_manager', $definition);
    }
1321203
public function process(ContainerBuilder $container)
    {
        $parameterBag = $container->getParameterBag();

        $parameterReplacer = $container->get(ServiceNames::PARAMETER_REPLACER);

        $parameterReplacer->processParameterBag($parameterBag, $container);
    }
657855
protected function applySimpleFilter(Filter $filter)
    {
        $value = (array) $filter->getValue();
        if (count($value) > 1) {
            $this->query->whereIn($filter->getField(), $value);
        } else {
            $this->query->where($filter->getField(),
                $filter->getOperator(), $value[0]);
        }
    }
575961
public function setFilter($filter)
    {
        parent::setFilter($filter);

        $this->userOptions['value'] = $this->getOption('value') === '' ? null : $this->getOption('value');
    }
1054733
public void postOrderFilterNodes(final NaryTreeNodeFilter filter) {
        postOrderTraversal(new FnO1ToVoid<IntNaryTree>() {
            @Override
            public void call(IntNaryTree node) {
                if (!node.isLeaf()) {
                    ArrayList<IntNaryTree> filtChildren = new ArrayList<IntNaryTree>();
                    for (IntNaryTree child : node.children) {
                        if (filter.accept(child)) {
                            filtChildren.add(child);
                        }
                    }
                    node.children = filtChildren;
                }
            }
        });
        updateStartEnd();
    }
1287960
public function addFilter($filter, $condition = 'AND') {
        if ($this->searchParams->filter == null) {
            $this->searchParams->filter = $filter;
        } else {
            $this->searchParams->filter .= " {$condition} $filter";
        }
    }
965485
public function process(ContainerBuilder $container)
    {
        /** @var Glob $glob */
        $glob = $container->get(Glob::class);

        $locales = $glob->execGlob(ROOT . 'lang/*.po');
        $locales = array_map(function ($file) {
            return basename($file, '.po');
        }, $locales);

        $container->setParameter('locales', $locales);
    }