Adds a determiner tag.

@param  string $determiner
@return OpenGraph
500608
public function determiner(string $determiner = '') : self
    {
        $enum = [
            'a', 
            'an', 
            'the',
            'auto',
            ''
        ];

        if ($this->validate and ! in_array($determiner, $enum)) {
            throw new Exception("Open Graph: Invalid determiner '{$determiner}' (unkown value)");
        }

        $this->tags[] = $this->createTag('determiner', $determiner);

        return $this;
    }
879783
public function add(TypeResolverInterface $resolver, $priority = 1)
    {
        $this->chain->insert($resolver, $priority);

        return $this;
    }
697722
protected function add(string $field, ValidatorInterface $validator)
    {
        $this->data[$field] = null;
        $this->validation->add($field, $validator);
        return $this;
    }
473130
public function registerBladeEngine($resolver)
    {
        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $this->container['blade.compiler'] = function ($container) {
            return new BladeCompiler($container['config']->get('view.compiled'));
        };

        $resolver->register('blade', function () {
            return new CompilerEngine($this->container['blade.compiler']);
        });
    }
925964
public function setDivider($divider = '/'): Breadcrumbs
    {
        if (!is_string($divider) && !is_null($divider)) {
            throw new InvalidArgumentException('Breadcrumbs::setDivider() only accepts strings or NULL');
        }
        $this->setOption('divider', $divider);

        return $this;
    }
678045
public function add(Closure $event, $checker = null)
    {
        $this->events[] = !is_null($checker) ? new Event($event, $checker)
            : new Event($event, function () {
            });

        return $this;
    }
665950
public function addFormatters(FormatterInterface ...$formatters): self
    {
        foreach ($formatters as $formatter) {
            foreach ($formatter->contentTypes() as $contentType) {
                $this->formatters[$contentType] = $formatter;
            }
        }

        return $this;
    }
371146
protected function createTag(string $name, $value, bool $prefixed = true) : OpenGraphTag
    {
        return new OpenGraphTag($name, $value, $prefixed);
    }
255624
public function uriSafe($spacer = "-")
  {
    $this->string = str_replace($spacer, " ", $this->string);
    $this->string = $this->transliterate();
		$this->string = preg_replace("/(\s|[^A-Za-z0-9\-])+/", $spacer, trim(strtolower($this->string)));
		$this->string = trim($this->string, $spacer);

		return new self($this->string);
  }
837439
public function add(string $alias, ClaimChecker $checker): self
    {
        $this->checkers[$alias] = $checker;

        return $this;
    }
628511
public function AddrFormat($addr) {
    if (empty($addr[1])) {
      return $this->SecureHeader($addr[0]);
    } else {
      return $this->EncodeHeader($this->SecureHeader($addr[1]), 'phrase') . " <" . $this->SecureHeader($addr[0]) . ">";
    }
  }
113021
protected function createSessionDriver()
    {
        $determiner = new Determiners\Session(
            $this->app['config']['localize-middleware']['session']
        );

        $determiner->setFallback($this->app['config']['app']['fallback_locale']);

        return $determiner;
    }
1009873
public function registerBladeEngine($resolver)
    {
        $app = $this->app;

        // Also register tpl engine
        $this->registerTplEngine($resolver);

        $resolver->register('blade', function() use ($app)
        {
            $cache = $app['path.storage'].'/views';

            // The Compiler engine requires an instance of the CompilerInterface, which in
            // this case will be the Blade compiler, so we'll first create the compiler
            // instance to pass into the engine so it can compile the views properly.
            $compiler = new BladeCompiler($app['files'], $cache);


            return new CompilerEngine($compiler, $app['files']);
        });
    }
1069681
public function registerMarkdownEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Markdown compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->bindShared('markdown.compiler', function($app)
        {
            $cachePath = $app['config']['view.compiled'];

            return new MarkdownCompiler($app['files'], $cachePath);
        });

        $resolver->register('markdown', function() use ($app)
        {
            return new CompilerEngine($app['markdown.compiler'], $app['files']);
        });
    }
724182
public function registerBladeEngine($resolver)
    {
        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        Zilf::$container->register(
            'blade.compiler', function () {

                return new BladeCompiler(
                    Zilf::$container['files'], Zilf::$app->runtimePath().'/views'
                );

            }
        );

        $resolver->register(
            'blade', function () {
                return new CompilerEngine(Zilf::$container['blade.compiler']);
            }
        );
    }
402461
public function Controller_Add($Sender) {
      $Sender->AddSideMenu('settings/tagging');
      $Sender->Title('Add Tag');
      
      // Set the model on the form.
      $TagModel = new TagModel;
      $Sender->Form->SetModel($TagModel);
      
      if ($Sender->Form->AuthenticatedPostBack()) {
         // Make sure the tag is valid
         $TagName = $Sender->Form->GetFormValue('Name');
         if (!TagModel::ValidateTag($TagName))
            $Sender->Form->AddError('@'.T('ValidateTag', 'Tags cannot contain commas.'));
         
         // Make sure that the tag name is not already in use.
         if ($TagModel->GetWhere(array('Name' => $TagName))->NumRows() > 0) {
            $Sender->Form->AddError('The specified tag name is already in use.');
         }
         
         $Saved = $Sender->Form->Save();
         if ($Saved)
            $Sender->InformMessage(T('Your changes have been saved.'));
      }
      
      $Sender->Render('addedit', '', 'plugins/Tagging');
   }
823756
public function attachSigner(Swift_Signer $signer)
    {
        if ($signer instanceof Swift_Signers_HeaderSigner) {
            $this->headerSigners[] = $signer;
        } elseif ($signer instanceof Swift_Signers_BodySigner) {
            $this->bodySigners[] = $signer;
        }

        return $this;
    }