@param string $type

@return Shopgate_Model_Redirect_DeeplinkSuffixValue
779059
public function getValue($type)
    {
        if (!isset($this->valuesByType[$type]) || ($this->valuesByType[$type] === null)) {
            return new Shopgate_Model_Redirect_DeeplinkSuffixValueUnset();
        }

        if ($this->valuesByType[$type] === false) {
            return new Shopgate_Model_Redirect_DeeplinkSuffixValueDisabled();
        }

        return $this->valuesByType[$type];
    }
50903
public function setRedirectType($type) {
        if (!is_int($type)) throw new IllegalTypeException('Illegal type of parameter $type: '.gettype($type));

        $this->redirectType = $type;
        return $this;
    }
423289
protected function obtainAPIURLEndpoint($type)
    {
        $uri = str_replace('{forgeserver}', $this->server, config('forge-publish.' . $type));
        $uri = str_replace('{forgesite}', $this->site, $uri);
        return config('forge-publish.url') . $uri;
    }
449640
public function setType(string $type = "F") : CNabuDataObject
    {
        if ($type === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$type")
            );
        }
        $this->setValue('nb_site_alias_type', $type);
        
        return $this;
    }
1221058
public function actionIndex($type = 'product')
    {
        if (!is_product_type_name($type)) {
            throw new NotFoundHttpException(t('app', 'The requested page does not exist.'));
        }
        $searchModel = new TermOfProductTypeSearch();
        $queryParams = request()->queryParams;
        $queryParams['TermOfProductTypeSearch']['product_type'] = $type;
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index', [
            'searchModel'  => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
919489
protected function ftFilter($type)
    {
        if ($type === Column::TYPE_TEXT)
        {
            return array_map(function ($v) {
                return trim($v, '%');
            }, $this->searcher->query);
        }
        return $this->searcher->query;

    }
1283059
public function hasType( string $type ): bool
	{
		if( substr($type, 0, 2) !== "#/" )
		{
			$type = "#/{$type}";
		}
		return $this->getType() === $type;
	}
449263
private function getCacheFile($type)
    {
        $type = str_replace(EntityMetadata::NAMESPACE_DELIM, '_', $type);
        return $this->dir.'/ModlrData.'.$this->cachePrefix.'.'.$type.'.'.$this->extension;
    }
752271
public function dataUrl($type = 'jpeg')
    {
        $type      = $this->getType($type);
        $imageFunc = 'image' . $type;

        ob_start();

        $imageFunc($this->newImage);

        $data = ob_get_contents();

        ob_end_clean();

        $this->destroyAll();

        $dataUrl = 'data:image/'. $type . ';base64,' . base64_encode($data);

        return $dataUrl;
    }
1211098
function pathObjectUrl($entity, $type = LinkGeneratorService::TYPE_LINK_DEFAULT, array $parameters = array()) {
        if($entity === null){
            return "";
        }
        return $this->linkGeneratorService->generateOnlyUrl($entity, $type, $parameters);
    }
962907
protected function getRedirectResponse($type) {
    $sdk = $this->getSdk($type);

    if ($sdk instanceof RedirectResponse) {
      return $sdk;
    }

    $this->authManager->setSdk($sdk);
    $url = $this->authManager->getAuthenticationUrl($type);

    return new TrustedRedirectResponse($url);
  }
853075
public function setType(Type $type = null)
    {
        if ($this->type !== $type) {
            // romove link on this item for old type
            if ($this->type instanceof Type) {
                $tmp = $this->type;
                $this->type = null;
                $tmp->removeItem($this);
            }
            $this->type = $type;
            // add link on this item
            if ($this->type instanceof Type) {
                $this->type->addItem($this);
            }
        }

        return $this;
    }
791022
public function actionBrowse($type)
    {
        $files = null;
        $relative = null;
        // check if request type is defined
        if ($this->allowedExt[$type] === null || !Any::isArray($this->allowedExt[$type])) {
            throw new NativeException('Hack attempt');
        }
        // list files in directory
        $files = File::listFiles('/upload/' . $type, $this->allowedExt[$type]);

        // absolute path to relative URI
        foreach ($files as $file) {
            $newName = Str::sub($file, Str::length(root)+1);
            $relative[] = trim(Str::replace(DIRECTORY_SEPARATOR, '/', $newName), '/');
        }

        // generate response
        return App::$View->render('editor/browse', [
            'callbackName' => App::$Security->strip_tags(App::$Request->query->get('CKEditor')),
            'callbackId' => (int)App::$Request->query->get('CKEditorFuncNum'),
            'files' => $relative,
            'type' => $type
        ], __DIR__);
    }
1016764
public function getMappedType($type)
    {
        if ($this->hasMappedType($type)) {
            return $this->mappedTypes[$type];
        }

        if ($this->useStrictTypeMapping) {
            throw PlatformException::mappedTypeDoesNotExist($type);
        }

        return $this->fallbackMappedType;
    }
222400
public function getUriForDiagrammType($type)
    {
        switch ($type) {
            case Diagramm::TYPE_ACTIVITY:
                $uri = $this->getOptions()->getYumlActivityDiagrammUrl();
                break;
            case Diagramm::TYPE_CLASS:
                $uri = $this->getOptions()->getYumlClassDiagrammUrl();
                break;
            case Diagramm::TYPE_DIAGRAMM:
                throw new \InvalidArgumentException('Unsupported diagramm type "' . $type . '"');
                break;
            case Diagramm::TYPE_USE_CASE:
                $uri = $this->getOptions()->getYumlUseCaseDiagrammUrl();
                break;
            default:
                throw new \InvalidArgumentException('Unkown diagramm type "' . $type . '"');
                break;
        }
        return $uri;
    }
289421
public function addDisallowedType($type)
    {
        if (!in_array(strtolower($type), $this->disallowedTypes)) {
            $this->disallowedTypes[] = strtolower($type);
        }
        return $this;
    }
1148381
public function setEncodingType($type)
    {
        switch ($type) {
            case self::RFC3986:
                $this->encoding = 'rawurlencode';
                break;
            case self::RFC1738:
                $this->encoding = 'urlencode';
                break;
            case false:
                $this->encoding = function ($v) { return $v; };
                break;
            default:
                throw new \InvalidArgumentException('Invalid URL encoding type');
        }
    }