Returns the key value-pairs of request type code and their shortened string value.

@return array
516134
public static function get_request_types_short() {
        return [
            api::DATAREQUEST_TYPE_EXPORT => get_string('requesttypeexportshort', 'tool_dataprivacy'),
            api::DATAREQUEST_TYPE_DELETE => get_string('requesttypedeleteshort', 'tool_dataprivacy'),
            api::DATAREQUEST_TYPE_OTHERS => get_string('requesttypeothersshort', 'tool_dataprivacy'),
        ];
    }
1002458
public static function get_request_types() {
        return [
            api::DATAREQUEST_TYPE_EXPORT => get_string('requesttypeexport', 'tool_dataprivacy'),
            api::DATAREQUEST_TYPE_DELETE => get_string('requesttypedelete', 'tool_dataprivacy'),
            api::DATAREQUEST_TYPE_OTHERS => get_string('requesttypeothers', 'tool_dataprivacy'),
        ];
    }
580532
private function getApplyQueryStringParams()
    {
        $qsParams = [
            $this->getFilter()->getRequestVar()      => $this->getApplyValue(),
            $this->_htmlPagerBlock->getPageVarName() => null,
        ];

        return $qsParams;
    }
855686
protected function getRequestCookies()
    {
        $pairs = array();

        foreach ($this->cookies as $k => $v) {
            $pairs[] = "$k=$v";
        }

        return join($pairs, ';');
    }
756287
public function getQueryVariables()
    {
        $pattern = '`[' . preg_quote('&', '/') . ']`';
        $parts   = preg_split($pattern, $this->_encodedQuery, -1, PREG_SPLIT_NO_EMPTY);
        $return  = array();

        foreach ($parts as $part) {

            if (strpos($part, '=') !== false) {

                list($key, $value) = explode('=', $part, 2);

            } else {

                $key   = $part;
                $value = null;
            }

            $key          = urldecode($key);
            $value        = urldecode($value);
            $return[$key] = $value;
        }

        return $return;
    }
724407
protected function getEscapedCharacters() : array
    {
        if (self::$escapedSpecialCharacters !== null) {
            return self::$escapedSpecialCharacters;
        }

        return self::$escapedSpecialCharacters = \array_values(self::$specialCharactersMapping);
    }
583083
public function getAcceptEncodes(): array
    {
        $ens = [];

        if ($value = $this->getLine('Accept-Encoding')) {
            if (\strpos($value, ';')) {
                [$value,] = \explode(';', $value, 2);
            }

            $value = \str_replace(' ', '', $value);
            $ens   = \explode(',', $value);
        }

        return $ens;
    }
690925
public function getUnicodeKeys() {
		$the_array = $this->icons_array;

		if ( is_array( $the_array ) ) {
			$temp = array();

			foreach ( $the_array as $class => $unicode ) {
				$temp[ $class ] = $unicode;
			}

			$the_array = $temp;
		}

		return $the_array;
	}
604674
public static function GetCharsetMapForMimeType () {
		return [
			Encoding::UTF_8		=> static::CHARSET_UTF_8,
			Encoding::EUC_JP	=> static::CHARSET_EUC_JP,
			Encoding::SJIS		=> static::CHARSET_SHIFT_JIS,
			Encoding::SJIS_WIN	=> static::CHARSET_SHIFT_JIS,
		];
	}
443209
public function getShortcodes()
    {
        $shortcodes = array_map(function ($replacement) {
            return "[{$replacement}]";
        }, $this->replacements);

        return collect(array_combine($shortcodes, $this->replacements));
    }
962288
public function getCharsets()
    {
        if (null !== $this->charsets) {
            return $this->charsets;
        }

        $charsets = $this->headers->getParameterListAsObject('Accept-Charset');

        return $this->charsets = $charsets->getParameterKeys();
    }
259955
public static function getFileFormTypes(): array
    {
        $values = array_map(static function (string $keyword): string {
            return self::getFileFormTypeValue($keyword);
        }, array_combine(self::OBJE_FILE_FORM_TYPE, self::OBJE_FILE_FORM_TYPE));

        uasort($values, '\Fisharebest\Webtrees\I18N::strcasecmp');

        return $values;
    }
298667
public function getValues()
    {
        $contentType = $this->getContenttype();
        if (!isset($contentType['fields'])) {
            return [];
        }

        $allValues = $this->toArray();

        return array_intersect_key($allValues, ($contentType['fields']));
    }
1049363
public function decodeHttpQuery()
    {
        $values = [];

        foreach ($this->getRequest()->query->all() as $key => $parameter) {
            if (strpos($key, self::PAGE) === 0) {
                $chunks = explode('_', $key);
                $contextId = end($chunks);
                $pager = new Pager($this);
                $pager->setFor($contextId)->setCurrent($parameter);
                $values[$key] = $pager;
            }
        }

        return $values;
    }
33882
public function getData()
    {
        $this->validate('currency', 'description', 'encryptionKey', 'returnUrl');

        // The test mode is included to determine the redirect URL.

        return [
            'VPSProtocol' => $this->VPSProtocol,
            'TxType' => $this->getTxType(),
            'Vendor' => $this->getVendor(),
            'Crypt' => $this->generateCrypt($this->getCryptData()),
            'TestMode' => $this->getTestMode(),
        ];
    }
286944
public function getPhpValues()
    {
        $values = array();
        foreach ($this->getValues() as $name => $value) {
            $qs = http_build_query(array($name => $value), '', '&');
            if (!empty($qs)) {
                parse_str($qs, $expandedValue);
                $varName = substr($name, 0, strlen(key($expandedValue)));
                $values = array_replace_recursive($values, array($varName => current($expandedValue)));
            }
        }

        return $values;
    }
403765
public function getInputFilterSpecification(): array
    {
        return [
            'api_key' => [
                'required' => false,
                'filters' => [
                    ['name' => StripTags::class],
                    ['name' => StringTrim::class],
                ],
                'validators' => [
                    ['name' => StringLength::class, 'options' => [
                        'encoding' => 'UTF-8',
                        'min'      => 10,
                        'max'      => 20,
                    ]],
                    ['name' => Alnum::class],
                ],
            ],
            'blog' => [
                'required' => false,
                'filters' => [
                    ['name' => StripTags::class],
                    ['name' => StringTrim::class],
                ],
                'validators' => [
                    ['name' => StringLength::class, 'options' => [
                        'encoding' => 'UTF-8',
                        'min'      => 10,
                        'max'      => 255,
                    ]],
                    ['name' => Uri::class, 'options' => [
                        'uriHandler'    => Http::class,
                        'allowRelative' => false,
                    ]],
                ],
            ],
        ];
    }