A responder is a class that subclasses, ``django_modelview.generic.responders.BaseResponder``

and whose class name must end with ``Responder``. A given ``ModelView`` may have any number

of responders, which are specified using the ``responders`` parameter as follows:

    from django_modelview.generic.rest_views import *

    responders = (HtmlResponder, JsonResponder, YamlResponder)

    articles = ModelView(Article.objects.all(),

                     responders=responders,

                     methods=('GET',))

The first responder will be used as the default if another responder is not explicitly

chosen. Thus, in the above example ``HtmlResponder`` will be used as the default

responder. 

In addition, each responder is also associated with one or more mimetypes. 

These mimetypes are used for determining the appropriate responder to use 

to respond to a request. Thus, there are three ways that a ``ModelView``

will attempt to discover the appropriate responder for a given request:

1) If ``format`` is explicitly set in the request's url, it will use that format.

       mv = ModelView(Article.objects.all(),

                      responders=(HtmlResponder,JsonResponder,YamlResponder),

                      methods=('GET',))

       ('^article/(?P<format>(html|json|yaml))?/?', mv)

   Thus, an incoming request that looks like ``/article/html/`` would always

   use the ``HtmlResponder``.

2) If the ``format`` is not explicitly made known, the ``ModelView`` will

   attempt to determine the correct responder using the request's mimetype.

   For example, a request with the mimetype ``text/yaml`` would be responded

   to using the ``YamlResponder``. The full list of associated mimetypes are

   discussed below.

3) Finally, if there is no explicit ``format`` in the url, nor is there a

   matching mimetype, then the default responder--the first in the list or

   tuple passed to the ``responders`` argument of the ``ModelView``

   initializer--will be used instead.

``BaseResponder`` is the foundation of all the other responder classes.

Subclassing BaseResponder

-------------------------

If the existing responders are inadequate for your application, it is

easy to subclass ``BaseResponder``. You will need to override two methods:

1) ``element(self, request, obj)`` returns an ``HttpResponse`` containing the

   appropriate rendering of a single instance, ``obj``.

2) ``render_list(self, request, object_list, paginator, page_obj)`` or

   ``list(self, request, paginate_by, allow_empty)``. Only one of these

   two methods will need to be overridden.

   If possible, it is preferable to override ``render_list``, which has

   already restricted the paramter ``object_list`` to viewable instances,

   and has handled most pagination logic as well.

   ``list`` on the other hand does none of this logic for you, and you must

   implement all such restrictions and partitioning on your own.

   Both ``list`` and ``render_list`` should return an ``HttpResponder`` object.

The ``HtmlResponder`` renders objects using the Django template system.

If attempting to render a list of objects, it was try to use the 

``appname/modelname_list.html`` template. If attempting to render a

single object, it will try to use the ``appname/modelname_detail.html``

template.

Is associated with the ``text/html`` mimetype.

The ``JsonResponder`` serializes the response using the Json 

serializer at ``django.core.serializers.json``.

It is associated with the ``application/json`` mimetype.

The ``XmlResponder`` serializes the response using the XML

serializer at ``django.core.serializers.xml_serializer``.

It is associated with the ``application/xml`` mimetype.

The ``YamlResponder`` serializes the response using the Yaml

serializer at ``django.core.serializers.pyyaml``.

It is associated with the ``text/yaml`` mimetype.

    mimetype = "text/html"