"""Printing subsystem driver"""

 class Printer(object):

     """Generic printer driver

     This is a generic printer driver.

     It's job is to provide infrastructure for implementing new printers easily.

     Basically, if you want to implement a printer, all you have to do is:

     1. Subclass Printer.

     2. In your subclass, define _print_<CLASS> methods

        For each class you want to provide printing to, define an appropriate

        method how to do it. For example if you want a class FOO to be printed in

        it's own way, define _print_FOO:

        def _print_FOO(self, e):

            ...

        this should return how FOO instance e is printed

        Also, if BAR is a subclass of FOO, _print_FOO(bar) will be called for

        instance of BAR, if no _print_BAR is provided.  Thus, usually, we don't

        need to provide prining routines for every class we want to support --

        only generic routine has to be provided for a set of classes. 

        A good example for this are functions - for example PrettyPrinter only

        defines _print_Function, and there is no _print_sin, _print_tan, etc...

        On the other hand, a good printer will probably have to define separate

        routines for Symbol, Atom, Number, Integral, Limit, etc...

     3. If convenient, override self.emptyPrinter

        This callable will be called to obtain printing result as a last resort,

        that is when no appropriate _print_<CLASS> was found for an expression.

     """

     def __init__(self):

         self._depth = -1

         self._str = str

         self.emptyPrinter = str

     def doprint(self, expr):

         """Returns printer's representation for expr (as a string)"""

         return self._str(self._print(expr))

     def _print(self, expr, *args):

         """internal dispatcher

            It's job is to loop through expr classes (class + it's bases), and

            try to dispatch the work to _print_<EXPR_CLASS>

            e.g., suppose we have the following class hierarcy::

                  Basic

                    |

                  Atom

                    |

                  Number

                    |

                 Rational

            then, for expr=Rational(...), in order to dispatch, we will try

            calling printer methods as shown in the figure below:

                p._print(expr)

                |

                |-- p._print_Rational(expr)

                |

                |-- p._print_Number(expr)

                |

                |-- p._print_Atom(expr)

                |

                `-- p._print_Basic(expr)

            if ._print_Rational method exists in the printer, then it is called,

            and the result is returned back.

            otherwise, we proceed with trying Rational bases in the inheritance

            order.

            if nothing exists, we just return:

                p.emptyPrinter(expr)

         """

         self._depth += 1

         # See if the class of expr is known, or if one of its super

         # classes is known, and use that print function

         res = None

         for cls in expr.__class__.__mro__:

             if hasattr(self, '_print_'+cls.__name__):

                 res = getattr(self, '_print_'+cls.__name__)(expr, *args)

                 break

         # Unknown object, just use its string representation

         if res is None:

             res = self.emptyPrinter(expr)

         self._depth -= 1

         return res