Returns class properties, that can potentially become proxies.

@param ISearchContext $search_context Search context.

@return Property[]
15153
protected function getProperties(ISearchContext $search_context)
	{
		$ret = array();
		$reflection = new \ReflectionClass($search_context);

		foreach ( $reflection->getProperties() as $property ) {
			$ret[] = new Property($property, $this->annotationManager);
		}

		return $ret;
	}
1340332
public function getProxyBindings()
	{
		if($this->proxyTypes === NULL)
		{
			$this->proxyTypes = [];
			
			foreach($this->bindings as $binding)
			{
				$scope = $binding->getScope();
		
				if($scope === NULL)
				{
					continue;
				}
		
				if(Singleton::class == $scope)
				{
					continue;
				}
		
				$this->proxyTypes[strtolower($binding->getTypeName())] = $binding;
			}
		}
		
		return $this->proxyTypes;
	}
35966
public function getBlockedWords($search = ''){
        $where = array();
        if(!empty($search)){
            $where['word'] = array('LIKE', '%'.$search.'%');
        }
        $this->blockedWords = $this->db->selectAll($this->getBannedWordsTable(), $where);
        return $this->blockedWords;
    }
811412
public function createDecorator(ISearchContext $search_context)
	{
		$locator_factory = new BEMElementLocatorFactory(
			$search_context,
			$this->annotationManager,
			$this->_locatorHelper
		);

		return new BEMPropertyDecorator($locator_factory, $this);
	}
1346832
private function getProxyMethods(): array
    {
        if (null !== $this->reflectionProxyMethods) {
            return $this->reflectionProxyMethods;
        }

        $proxyMethods = [];
        $methods = $this->getClassMethods();

        foreach ($methods as $method) {
            $docComment = $method->getDocComment();

            if (\strpos($docComment, 'Transactional') !== false) {
                $annotation = $this->annotationReader->getMethodAnnotation(
                    $method,
                    Transactional::class
                );

                if ($annotation) {
                    $proxyMethods[] = $method;
                }
            }
        }

        $this->reflectionProxyMethods = $proxyMethods;

        return $proxyMethods;
    }
895688
protected function getTypeForContextValue($contextValue)
    {
        if (is_object($contextValue)) {
            if ($contextValue instanceof Proxy) {
                $type = get_parent_class($contextValue);
            } else {
                $type = get_class($contextValue);
            }
        } else {
            $type = gettype($contextValue);
        }
        return $type;
    }
470861
protected function _getSearchDataHeader(BaseSearch $search): array
    {
        $header = $search->getOptions();

        if ($search->hasIndices()) {
            $header['index'] = $search->getIndices();
        }

        if ($search->hasTypes()) {
            $header['types'] = $search->getTypes();
        }

        // Filter options accepted in the "header"
        return \array_intersect_key($header, \array_flip(self::$HEADER_OPTIONS));
    }
1083653
public function getData($search = false) {
        if ($this->option && method_exists($this->form, $this->option)) {
            return $this->form->{$this->option}(...[$search]);
        }

        return [];
    }
1207889
private static function getProps($class)
    {
        if ($class == NULL) {
            return array();
        }
        $class = new \ReflectionClass($class);
        $properties = array_filter($class->getProperties(), function ($prop) use($class)
        {
            return $prop->getDeclaringClass()->name == $class->name;
        });
        return $properties;
    }
818684
private function getSearchSuggestions()
    {
        $tokens = $this->getTokens();
        $allResults = array();
        foreach ($tokens as $token) {
            $allResults = $this->getSearchSuggestion($token, $allResults);
        }
        return $allResults;
    }
98070
public function getQueryContext(): ?array
    {
        $queryContext = $this->getConfiguration()->getOption('query_context');
        if ($queryContext && $this->getConfiguration()->getOption('use_global_context')) {
            $queryContext = array_merge($this->getFamily()->getContext(), (array) $queryContext);
        }

        return $queryContext;
    }
178047
public function search($query)
    {
        $this->logger->debug('Page:search');
        if (!Tools::isGoodString($query)) {
            $this->logger->error('Page::search: invalid query');
            return [];
        }
        $this->setGeneratorSearch($query, self::PAGE_NAMESPACE);
        $this->setParam('prop', 'pageprops');
        $this->send();
        return Tools::flatten($this->getResponse(['query', 'pages']));
    }
838158
public <T> List<T> search(Class<T> managedClass, Name base, String filter, SearchControls scope) {
        Filter searchFilter = null;
        if(StringUtils.hasText(filter)) {
            searchFilter = new HardcodedFilter(filter);
        }

        return ldapTemplate.find(base, searchFilter, scope, managedClass);
    }
30186
protected Map<String, Object> getPluginProperties() {
        Map<String, Object> properties = new HashMap<>();
        if (scanProperties != null) {
            properties.putAll(scanProperties);
        }
        properties.put(ScanInclude.class.getName(), scanIncludes);
        return properties;
    }
1070605
public static function get_available_in_context($contexts) {
        $params = self::validate_parameters(self::get_available_in_context_parameters(), array('contexts' => $contexts));
        $filters = $warnings = array();

        foreach ($params['contexts'] as $contextinfo) {
            try {
                $context = self::get_context_from_params($contextinfo);
                self::validate_context($context);
                $contextinfo['contextid'] = $context->id;
            } catch (Exception $e) {
                $warnings[] = array(
                    'item' => 'context',
                    'itemid' => $context['instanceid'],
                    'warningcode' => $e->getCode(),
                    'message' => $e->getMessage(),
                );
                continue;
            }
            $contextfilters = filter_get_available_in_context($context);

            foreach ($contextfilters as $filter) {
                $filters[] = array_merge($contextinfo, (array) $filter);
            }
        }

        return array(
            'filters' => $filters,
            'warnings' => $warnings,
        );
    }
207445
@Override
    public URL[] findResources()
    {
        URL[] result = null;

        if (classesToScan != null && !classesToScan.isEmpty())
        {
            result = findResourcesByContextLoader();
        }
        // else
        // {
        // result = findResourcesByClasspath();
        // }
        return result;
    }
758979
public function getSearchResults()
    {
        $term = $this->getRequest()->get('search', null);

        // Avoid querying ALL content when no search value is provided
        if (!$term) {
            return [];
        }

        $host = $this->getRequest()->getHost();
        $locale = $this->getRequest()->attributes->get('content')->getLocale();

        return $this->contentManager->getRepository()->search($term, $host, $locale);
    }