Breadcrumb Make an Object.

@param string $name
@param callable $callable
@return void
511400
public function make($name, callable  $callable)
    {
        $breadcrumb = new Breadcrumb($callable);
        $breadcrumb->route($name);

        $this->collection->put($name, $breadcrumb);
    }
1648
public function extend($name, $callable, $strict = true)
    {
        if (!$this->services->has($name)) {
            if ($strict) {
                throw new InvalidArgumentException(sprintf('Service "%s" is not defined.', $name));
            } else {
                return false;
            }
        }

        $factory = $this->services->get($name);

        if (!is_object($factory) || !method_exists($factory, '__invoke')) {
            throw new InvalidArgumentException(sprintf('Service "%s" does not contain an object definition.', $name));
        }

        if (!is_object($callable) || !method_exists($callable, '__invoke')) {
            throw new InvalidArgumentException('Extension service definition is not a Closure or invokable object.');
        }

        $extended = function($c) use($callable, $factory) {
            /** @var Closure $factory */
            return $callable($factory($c), $c);
        };

        if ($this->factories->contains($factory)) {
            $this->factories->detach($factory);
            $this->factories->attach($extended);
        }

        $this->services->unlock($name);
        $this->services->set($name, $extended);

        return $this->services->get($name);
    }
146877
public function add($snippet, Callable $callable=null) {
		if (is_object($snippet) && $snippet instanceof Snippets) {
			$this->addSnippetClass($snippet);
		}
		if (is_string($snippet) && is_callable($callable)) {
			// '$snippet' is a tag name: register $callable
			$this->snippets[$snippet] = $callable;
		}
	}
379548
public function firstCrumb($name, $link = null, $options = null) {
		array_unshift($this->_crumbs, array($name, $link, $options));
		return $this;
	}
1086876
public function create(string $name, callable $definition)
    {
        $this->_name = $name;
        $this->_definition = $definition;
    }
1343542
public function put($path, $callable, $name = null) {
		return $this->add($path, $callable, $name, self::HTTP_METHOD_PUT);
	}
1162340
public function AddBreadcrumb($Name, $Link = NULL, $Position = 'back') {
      $Breadcrumb = array(
         'Name'   => T($Name),
         'Url'    => $Link
      );
      
      $Breadcrumbs = $this->Data('Breadcrumbs', array());
      switch ($Position) {
         case 'back':
            $Breadcrumbs = array_merge($Breadcrumbs, array($Breadcrumb));
            break;
         case 'front':
            $Breadcrumbs = array_merge(array($Breadcrumb), $Breadcrumbs);
            break;
      }
      $this->SetData('Breadcrumbs', $Breadcrumbs);
   }
774085
public function addBaselineCallable($name, $callable)
    {
        if (isset($this->callables[$name])) {
            throw new \InvalidArgumentException(sprintf(
                'Baseline callable "%s" has already been registered.',
                $name
            ));
        }

        if (!is_callable($callable)) {
            throw new \InvalidArgumentException(sprintf(
                'Given baseline "%s" callable "%s" is not callable.',
                $name, is_string($callable) ? $callable : gettype($callable)
            ));
        }

        $this->callables[$name] = $callable;
    }
1230294
public function get(string $name): Closure
    {
        if ( ! $this->has($name)) {
            throw new DefinitionNotFoundException("No breadcrumbs defined for route [{$name}].");
        }

        return $this->definitions[$name];
    }
364808
private function callback(string $name)
    {
        if (!$this->hasCallback($name)) {
            throw new XslCallbackException('A callback with the name ' . $name . ' does not exist.');
        }

        return $this->callbacks[$name];
    }
357468
public function delete($url, $callable, $name = null, $templatePath = null)
    {
        $this->multiple([\Parable\Http\Request::METHOD_DELETE], $url, $callable, $name, $templatePath);
        return $this;
    }
1273088
public function addBreadcrumbLink($name, $url = '', $icon = '')
    {
        $this->breadcrumbItems->push((object) ['name' => $name, 'url' => $url, 'icon' => $icon]);
    }
136832
public static function createCallback(string $name, callable $callback): DenormalizationFieldMappingBuilderInterface
    {
        $self = new self($name);
        $self->fieldDenormalizer = new CallbackFieldDenormalizer($callback);

        return $self;
    }
1096695
public function breadcrumbAppend($name, $label, $route = null, array $parameters = [])
    {
        $this->createBreadcrumb();

        $this
            ->breadcrumb
            ->addChild($name, ['route' => $route, 'routeParameters' => $parameters])
            ->setLabel($label)
        ;
    }
213016
public function forEachNamed($name, callable $callable)
    {
        Types::assert(['string' => [$name]]);

        $name = strtolower($name);

        if (isset($this->headers[$name]))
        {
            foreach ($this->headers[$name] as $header)
            {
                $callable($header);
            }
        }
    }
391598
public function any($url, $callable, $name = null, $templatePath = null)
    {
        $this->multiple(\Parable\Http\Request::VALID_METHODS, $url, $callable, $name, $templatePath);
        return $this;
    }
541532
public function register($name, Closure $callback): void
    {
        if ($this->has($name)) {
            $this->callbacks = $this->callbacks->put($name, $this->callbacks->get($name, collect())->push($callback));
        } else {
            $builder = new MenuGenerator();

            $builder->setViewFactory($this->viewFactory);

            $this->menus->put($name, $builder);

            $this->callbacks = $this->callbacks->put($name, $this->callbacks->get($name, collect())->push($callback));
        }
    }