Returns a list of enabled LibraryHook class names.

Only class names are returned, any object creation happens
in the VCRFactory.

@return string[] List of LibraryHook class names.
11063
public function getLibraryHooks()
    {
        if (is_null($this->enabledLibraryHooks)) {
            return array_values($this->availableLibraryHooks);
        }

        return array_values(array_intersect_key(
            $this->availableLibraryHooks,
            array_flip($this->enabledLibraryHooks)
        ));
    }
768691
private function getDescriptors(): array
    {
        if ($this->input instanceof \Iterator) {
            $this->input->rewind();
        }
        if ('\\' === \DIRECTORY_SEPARATOR) {
            $this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
        } else {
            $this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
        }

        return $this->processPipes->getDescriptors();
    }
255789
public function getAvailablePopupTypes()
    {
        $popups = array();
        foreach ($this->popupTypes as $popupType) {
            $object = new $popupType();
            $popups[$object->getClassname()] = $object->getFullClassname();
        }

        return $popups;
    }
903401
public static function getList()
    {
        $app = Facade::getFacadeApplication();
        $db = $app->make('database')->connection();
        $libraries = [];
        foreach ($db->fetchAll('select sclHandle from SystemCaptchaLibraries order by sclHandle asc') as $row) {
            $scl = static::getByHandle($row['sclHandle']);
            $libraries[] = $scl;
        }

        return $libraries;
    }
1258427
public function getClassNames()
    {
        // Obtain Class Names:
        
        $classes = array_merge(
            $this->getStyleClassNames(),
            $this->getCustomClassNames(),
            $this->getAncestorClassNames()
        );
        
        // Obtain Extra Class Names:
        
        $classes = array_merge($classes, $this->getExtraClasses());
        
        // Apply Extensions:
        
        $this->extend('updateClassNames', $classes);
        
        // Answer Class Names:
        
        return $classes;
    }
643085
public function getEnabledProviders()
    {
        $result = [];

        foreach (Port1HybridAuth::PROVIDERS as $provider) {
            if ((Boolean)$this->config->getByNamespace('Port1HybridAuth', strtolower($provider) . '_enabled')) {
                $label = $this->snippetManager->getNamespace('frontend/account/login')->get('SignInWith' . $provider);

                $result[$provider] = $label;
            }
        }
260037
public function getExtensionsClassesNames()
    {
        return array_replace([
            Extensions\VinCodeValidatorExtension::class,
            Extensions\GrzCodeValidatorExtension::class,
            Extensions\StsCodeValidatorExtension::class,
            Extensions\PtsCodeValidatorExtension::class,
            Extensions\BodyCodeValidatorExtension::class,
            Extensions\ChassisCodeValidatorExtension::class,
            Extensions\DriverLicenseNumberValidatorExtension::class,
        ], $this->getConfigExtensionsClassesNames());
    }
1205154
public function getKeywords()
    {
        $keywords = [];

        foreach ($this->config()->get('global_keywords') as $k => $v) {
            $keywords[] = '<strong>'.$k.'</strong> ' . $v;
        }

        if ($this->NotifyOnClass && class_exists($this->NotifyOnClass)) {
            $dummy = singleton($this->NotifyOnClass);
            if ($dummy instanceof NotifiedOn || $dummy->hasMethod('getAvailableKeywords')) {
                $myKeywords = $dummy->getAvailableKeywords();
                
                if (is_array($myKeywords)) {
                    foreach ($myKeywords as $keyword => $desc) {
                        $keywords[] = '<strong>'.$keyword.'</strong> - '.$desc;
                    }
                }
            }
        }

        return $keywords;
    }
63377
public function getNamespaceList()
    {
        if (!isset($this->_namespaceList)) $this->getBasePathList();
        static::$_modulesNs[$this::className()] = $this->_namespaceList;
        return $this->_namespaceList;
    }
491247
public static function getBackendAjaxClassNames()
    {
        $nameSpace = __NAMESPACE__ . '\\PageSeo';
        $ajaxPrefix = self::AJAX_PREFIX;

        return array(
            //$ajaxPrefix . PageSeo\AdvancedController::LIST_TYPE
            //  => $nameSpace . '\\' . 'AdvancedController',//unused
            $ajaxPrefix . PageSeo\GeoController::LIST_TYPE           => $nameSpace . '\\' . 'GeoController',
            $ajaxPrefix . PageSeo\MetaDataController::LIST_TYPE      => $nameSpace . '\\' . 'MetaDataController',
            $ajaxPrefix . PageSeo\PageTitleController::LIST_TYPE     => $nameSpace . '\\' . 'PageTitleController',
            $ajaxPrefix . PageSeo\PageTitleSimController::LIST_TYPE  => $nameSpace . '\\' . 'PageTitleSimController',
            $ajaxPrefix . PageSeo\SearchEnginesController::LIST_TYPE => $nameSpace . '\\' . 'SearchEnginesController',
            $ajaxPrefix . PageSeo\UrlController::LIST_TYPE           => $nameSpace . '\\' . 'UrlController',
        );
    }
662404
public function getAllClasses()
    {
        $returnValue = null;

        
    	
        $returnValue = new core_kernel_classes_ContainerCollection(new core_kernel_classes_Container(__METHOD__),__METHOD__);
        
        $dbWrapper = core_kernel_classes_DbWrapper::singleton();
        
        $query =  "SELECT DISTINCT subject FROM statements WHERE (predicate = ? AND object = ?) OR predicate = ?";
    	$result	= $dbWrapper->query($query, array(
			OntologyRdf::RDF_TYPE,
            OntologyRdfs::RDFS_CLASS,
            OntologyRdfs::RDFS_SUBCLASSOF
        ));
        
        while ($row = $result->fetch()) {
        	$returnValue->add(new core_kernel_classes_Class($row['subject']));
        }
		
        

        return $returnValue;
    }
763677
public function getClassNames()
    {
        // Obtain Class Names:
        
        $classes = $this->styles('navbar.nav');
        
        // Merge Additional Class Names:
        
        if ($this->MultiLevelSubMenus) {
            $classes[] = 'multi-level';
        }
        
        // Answer Class Names:
        
        return array_merge(
            parent::getClassNames(),
            $classes
        );
    }
481774
public function getClassNamesForContainer()
    {
        $classes = [$this->owner->isFullWidth() ? 'container-fluid' : 'container'];
        
        if ($this->owner->isEdgeToEdge()) {
            $classes[] = $this->style('section.edge-to-edge');
        }
        
        return $classes;
    }
1253714
private Set<ExecutableElement> getHookMethodsFromInterfaces() {
    return component
        .getInterfaces()
        .stream()
        .map(DeclaredType.class::cast)
        .map(DeclaredType::asElement)
        .map(TypeElement.class::cast)
        .flatMap(typeElement -> ElementFilter
            .methodsIn(typeElement.getEnclosedElements())
            .stream())
        .filter(method -> hasAnnotation(method, HookMethod.class))
        .peek(this::validateHookMethod)
        .collect(Collectors.toSet());
  }
339164
public static function getDefaultHandlers(): array
    {
        $numberHandler = new NumberHandler();

        return [
            'array' => new ArrayHandler(),
            'boolean' => new BooleanHandler(),
            'float' => $numberHandler,
            'integer' => $numberHandler,
            'number' => $numberHandler,
            'mixed' => new MixedHandler(),
            'object' => new ObjectHandler(),
            'resource' => new ResourceHandler(),
            'string' => new StringHandler(),
            'multiple' => new MultipleHandler()
        ];
    }
91972
public function getAllClassNames()
    {
        if ($this->classNames === null) {
            $metadata = $this->getAllMetadata();

            /** @var ClassMetadataInfo $meta */
            foreach ($metadata as $meta) {
                if ($this->annotationReader->isRevised($meta->getName())) {
                    $this->classNames[] = $meta->getName();
                }
            }
        }

        return $this->classNames;
    }
166506
public function getTextAlignmentClassNames()
    {
        $classes = [];
        
        $alignment = $this->owner->dbObject('TextAlignment');
        
        foreach ($alignment->getViewports() as $viewport) {
            $classes[] = $this->getTextAlignmentClass($viewport, $alignment->getField($viewport));
        }
        
        return $classes;
    }