Returns allowed link types

@return array
357226
public function getTypes()
    {
        $types = $this->config()->get('types');
        $i18nTypes = [];
        $allowedTypes = $this->config()->get('allowed_types');

        if ($this->allowed_types_override) {
            // Prioritise local field over global settings
            $allowedTypes = $this->allowed_types_override;
        }

        if ($allowedTypes) {
            foreach ($allowedTypes as $type) {
                if (!array_key_exists($type, $types)) {
                    user_error("{$type} is not a valid link type");
                }
            }

            foreach (array_diff_key($types, array_flip($allowedTypes)) as $key => $value) {
                unset($types[$key]);
            }
        }

        // Get translatable labels
        foreach ($types as $key => $label) {
            $i18nTypes[$key] = _t('Linkable.TYPE' . strtoupper($key), $label);
        }

        return $i18nTypes;
    }
29080
private function getPermissionTypes()
    {
        $types = [];

        /**
         * @var $route \Symfony\Component\Routing\Route
         */
        foreach ($this->get('router')->getRouteCollection()->all() as $name => $route) {
            if ($route->hasOption('require_admin_permission')) {
                list($permissionType,) = explode('.', $route->getOption('require_admin_permission'));
                $types[$permissionType] = [
                    'id'   => $permissionType,
                    'name' => $permissionType
                ];
            }
        }

        ksort($types);

        return array_values($types);
    }
721123
public function getAllLinkbaseRoleTypes()
	{
		// Gather all role types
		return array_reduce( $this->context->importedSchemas, function( $carry, /** @var XBRL $taxonomy */ &$taxonomy )
		{
			$lrts = $taxonomy->getLinkbaseRoleTypes();

			foreach ( $lrts as $linkbase => $definition )
			{
				if ( isset( $carry[ $linkbase ] ) )
				{
					$carry = array_merge( $carry[ $linkbase ], $definition );
				}
				else
				{
					$carry[ $linkbase ] = $definition;
				}
			}

			return $carry;

		}, array() );
	}
18536
public function getLinks()
    {
        $links = '';
        foreach ($this->links as $link) {
            $links .= $link . "\n";
        }
        $links = rtrim($links, "\n");
        return $links;
    }
241839
public function getAllowedFileTypes()
	{
		$arrFileTypesOfParents = array();
		
		if ($this->fileTypesInherit && !$this->isRootCategory() && $this->hasParentCategory())
		{
			$arrFileTypesOfParents = $this->parentCategory->getAllowedFileTypes();
		}
		
		$arrFileTypes = DmsUtils::getUniqueFileTypes($this->fileTypes, $arrFileTypesOfParents);
		
		return $arrFileTypes;
	}
709452
private function getLinksDeclaration()
    {

        // we got a max instances allowed in normality tags
        $links = $this->entity->pgClass->getLinks();
        foreach( $links as &$link ) {
            $link = $link->toArray();
        }
        $links = json_encode( $links );
        $links = Php::varExport( $links, true );

        $this->class->classComponents[] = new VariableDeclaration(
            'links',
            new SFormatf( <<<'PHP'
                /**
                 * Link information for this relation
                 * @var array
                 */
                protected $links = %s;
PHP
                , $links
            )
        );

    }
711636
public function getLinkModeOptions()
    {
        return [
            self::LINK_MODE_TITLE  => _t(__CLASS__ . '.TITLE', 'Title'),
            self::LINK_MODE_BUTTON => _t(__CLASS__ . '.BUTTON', 'Button'),
            self::LINK_MODE_BOTH   => _t(__CLASS__ . '.BOTHTITLEANDBUTTON', 'Both Title and Button')
        ];
    }
706780
public function getLinks() : Array
    {
        if( ! $this->isJsonCheck() || $this->refresh === true )
        {
            $result = $this->getApiResult();

            if( ! is_object($result) )
            {
                throw new Exception\BadRequestURLException($this->address);
            }

            $this->putJsonContent($result);
        }

        $result = $this->decodeArrrayJsonContent();

        return $this->convertArrayByKeyValues($result);
    }
239719
public function getTypes()
    {
        $handlers = &gplcart_static('price.rule.types');

        if (isset($handlers)) {
            return $handlers;
        }

        $handlers = gplcart_config_get(GC_FILE_CONFIG_PRICE_RULE_TYPE);
        $this->hook->attach('price.rule.types', $handlers, $this);
        return $handlers;
    }
187107
public function get_plugin_types_menu() {
        global $CFG;

        $pluginman = core_plugin_manager::instance();

        $menu = array('' => get_string('choosedots'));
        foreach (array_keys($pluginman->get_plugin_types()) as $plugintype) {
            $menu[$plugintype] = $pluginman->plugintype_name($plugintype).' ('.$plugintype.')';
        }

        return $menu;
    }
928912
public function getOperationsAllowed()
    {
        if ($this->_getField(self::$OPERATIONS_ALLOWED) == '') {
            return Array();
        } else {
            return explode(',', $this->_getField(self::$OPERATIONS_ALLOWED));
        }
    }
536214
public function GetAllowedAttributes()
    {
        static $aAttributes = null;

        if (null === $aAttributes) {
            $aAttributes = array();
            $oAttributeList = TdbShopAttributeList::GetList();
            $oAttributeList->GoToStart();
            while ($oAttribute = &$oAttributeList->Next()) {
                $aAttributes[] = $oAttribute->fieldSystemName;
            }
        }

        return $aAttributes;
    }
255232
public function getTypeAllowableValues()
    {
        return [
            self::TYPE_TEXT,
            self::TYPE_DATE,
            self::TYPE_FLOAT,
            self::TYPE_ID,
            self::TYPE_BOOLEAN,
        ];
    }
1325031
protected static function _getErrorTypes()
    {
        $errType = array(
            E_ERROR             => 'Error',
            E_WARNING           => 'Warning',
            E_PARSE             => 'Parsing Error',
            E_NOTICE            => 'Notice',
            E_CORE_ERROR        => 'Core Error',
            E_CORE_WARNING      => 'Core Warning',
            E_COMPILE_ERROR     => 'Compile Error',
            E_COMPILE_WARNING   => 'Compile Warning',
            E_USER_ERROR        => 'User Error',
            E_USER_WARNING      => 'User Warning',
            E_USER_NOTICE       => 'User Notice',
            E_STRICT            => 'Runtime Notice',
            E_RECOVERABLE_ERROR => 'Catchable Fatal Error',
        );

        if (defined('E_DEPRECATED')) {
            $errType[E_DEPRECATED]      = 'Deprecated';
            $errType[E_USER_DEPRECATED] = 'User Deprecated';
        }

        $errType[E_ALL] = 'All errors';

        return $errType;
    }
220028
public function PageTypes()
    {
        $classes = SiteTree::page_type_classes();

        $result = new ArrayList();

        foreach ($classes as $class) {
            $instance = SiteTree::singleton($class);
            if ($instance instanceof HiddenClass) {
                continue;
            }

            // skip this type if it is restricted
            $needPermissions = $instance->config()->get('need_permission');
            if ($needPermissions && !$this->can($needPermissions)) {
                continue;
            }

            $result->push(new ArrayData(array(
                'ClassName' => $class,
                'AddAction' => $instance->i18n_singular_name(),
                'Description' => $instance->i18n_classDescription(),
                'IconURL' => $instance->getPageIconURL(),
                'Title' => $instance->i18n_singular_name(),
            )));
        }

        $result = $result->sort('AddAction');

        return $result;
    }
847296
public function supported_returntypes() {
        // We can only support references if the system account is connected.
        if (!empty($this->issuer) && $this->issuer->is_system_account_connected()) {
            $setting = get_config('googledocs', 'supportedreturntypes');
            if ($setting == 'internal') {
                return FILE_INTERNAL;
            } else if ($setting == 'external') {
                return FILE_CONTROLLED_LINK;
            } else {
                return FILE_CONTROLLED_LINK | FILE_INTERNAL;
            }
        } else {
            return FILE_INTERNAL;
        }
    }
1125848
public function getValidElementTypes(){
        return array(
            'oat\\taoQtiItem\\model\\qti\\Img',
            'oat\\taoQtiItem\\model\\qti\\Math',
            'oat\\taoQtiItem\\model\\qti\\feedback\\Feedback',
            \oat\taoQtiItem\model\qti\QtiObject::class,
            'oat\\taoQtiItem\\model\\qti\\Tooltip',
            'oat\\taoQtiItem\\model\\qti\\interaction\\Interaction',
            'oat\\taoQtiItem\\model\\qti\\RubricBlock',
            'oat\\taoQtiItem\\model\\qti\\InfoControl',
            'oat\\taoQtiItem\\model\\qti\\XInclude',
            \oat\taoQtiItem\model\qti\Table::class,
        );
    }