'Does the complete dispatching process.  `view_func` is called with
the endpoint and a dict with the values for the view.  It should
look up the view function, call it, and return a response object
or WSGI application.  http exceptions are not caught by default
so that applications can display nicer error messages by just
catching them by hand.  If you want to stick with the default
error messages you can pass it ``catch_http_exceptions=True`` and
it will catch the http exceptions.
Here a small example for the dispatch usage::
from werkzeug.wrappers import Request, Response
from werkzeug.wsgi import responder
from werkzeug.routing import Map, Rule
def on_index(request):
return Response(\'Hello from the index\')
url_map = Map([Rule(\'/\', endpoint=\'index\')])
views = {\'index\': on_index}
@responder
def application(environ, start_response):
request = Request(environ)
urls = url_map.bind_to_environ(environ)
return urls.dispatch(lambda e, v: views[e](request, **v),
catch_http_exceptions=True)
Keep in mind that this method might return exception objects, too, so
use :class:`Response.force_type` to get a response object.
:param view_func: a function that is called with the endpoint as
first argument and the value dict as second.  Has
to dispatch to the actual view function with this
information.  (see above)
:param path_info: the path info to use for matching.  Overrides the
path info specified on binding.
:param method: the HTTP method used for matching.  Overrides the
method specified on binding.
:param catch_http_exceptions: set to `True` to catch any of the
werkzeug :class:`HTTPException`\s.'

def dispatch(self, view_func, path_info=None, method=None, catch_http_exceptions=False):

    try:
        try:
            (endpoint, args) = self.match(path_info, method)
        except RequestRedirect as e:
            return e
        return view_func(endpoint, args)
    except HTTPException as e:
        if catch_http_exceptions:
            return e
        raise
