X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fprint.h;h=85e0fad78a1a590f63e8c1de006609e92f51828d;hp=8d4fc2f8612eeebe0367a2b4bf71bea454bd8bd9;hb=3fc32c7824dee9508a5286f1b121734084c8bdfb;hpb=68fdf425abf14d016d5f95ee7b9d06a19a3c5926 diff --git a/ginac/print.h b/ginac/print.h index 8d4fc2f8..85e0fad7 100644 --- a/ginac/print.h +++ b/ginac/print.h @@ -3,7 +3,7 @@ * Definition of helper classes for expression output. */ /* - * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -25,15 +25,30 @@ #include #include +#include + +#include "class_info.h" namespace GiNaC { -/* - * The following classes remain publicly visible for compatibility - * reasons only. New code should use the iostream manipulators defined - * in operators.h instead. - */ +/** This class stores information about a registered print_context class. */ +class print_context_options { +public: + print_context_options(const char *n, const char *p, unsigned i) + : name(n), parent_name(p), id(i) {} + + const char *get_name() const { return name; } + const char *get_parent_name() const { return parent_name; } + unsigned get_id() const { return id; } + +private: + const char *name; /**< Class name. */ + const char *parent_name; /**< Name of superclass. */ + unsigned id; /**< ID number (assigned automatically). */ +}; + +typedef class_info print_context_class_info; /** Flags to control the behavior of a print_context. */ @@ -45,53 +60,87 @@ public: }; -/** Context for default (ginsh-parsable) output. */ +/** Macro for inclusion in the declaration of a print_context class. + * It declares some functions that are common to all classes derived + * from 'print_context' as well as all required stuff for the GiNaC + * registry. */ +#define GINAC_DECLARE_PRINT_CONTEXT(classname, supername) \ +public: \ + typedef supername inherited; \ + friend class function_options; \ + friend class registered_class_options; \ +public: \ + static const GiNaC::print_context_class_info &get_class_info_static(); \ + virtual const GiNaC::print_context_class_info &get_class_info() const { return classname::get_class_info_static(); } \ + virtual const char *class_name() const { return classname::get_class_info_static().options.get_name(); } \ + \ + classname(); \ + virtual classname * duplicate() const { return new classname(*this); } \ +private: + +/** Macro for inclusion in the implementation of each print_context class. */ +#define GINAC_IMPLEMENT_PRINT_CONTEXT(classname, supername) \ +const GiNaC::print_context_class_info &classname::get_class_info_static() \ +{ \ + static GiNaC::print_context_class_info reg_info = GiNaC::print_context_class_info(GiNaC::print_context_options(#classname, #supername, GiNaC::next_print_context_id++)); \ + return reg_info; \ +} + + +extern unsigned next_print_context_id; + + +/** Base class for print_contexts. */ class print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_context, void) public: - print_context(); print_context(std::ostream &, unsigned options = 0); virtual ~print_context() {} - virtual print_context * duplicate() const {return new print_context(*this);} std::ostream & s; /**< stream to output to */ unsigned options; /**< option flags */ }; +/** Context for default (ginsh-parsable) output. */ +class print_dflt : public print_context +{ + GINAC_DECLARE_PRINT_CONTEXT(print_dflt, print_context) +public: + print_dflt(std::ostream &, unsigned options = 0); +}; + /** Context for latex-parsable output. */ class print_latex : public print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_latex, print_context) public: - print_latex(); print_latex(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_latex(*this);} }; /** Context for python pretty-print output. */ class print_python : public print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_python, print_context) public: - print_python(); print_python(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_python(*this);} }; /** Context for python-parsable output. */ class print_python_repr : public print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_python_repr, print_context) public: - print_python_repr(); print_python_repr(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_python_repr(*this);} }; /** Context for tree-like output for debugging. */ class print_tree : public print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_tree, print_context) public: - print_tree(unsigned d = 4); + print_tree(unsigned d); print_tree(std::ostream &, unsigned options = 0, unsigned d = 4); - print_context * duplicate() const {return new print_tree(*this);} const unsigned delta_indent; /**< size of indentation step */ }; @@ -99,43 +148,127 @@ public: /** Base context for C source output. */ class print_csrc : public print_context { + GINAC_DECLARE_PRINT_CONTEXT(print_csrc, print_context) public: - print_csrc(); print_csrc(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_csrc(*this);} }; /** Context for C source output using float precision. */ class print_csrc_float : public print_csrc { + GINAC_DECLARE_PRINT_CONTEXT(print_csrc_float, print_csrc) public: - print_csrc_float(); print_csrc_float(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_csrc_float(*this);} }; /** Context for C source output using double precision. */ class print_csrc_double : public print_csrc { + GINAC_DECLARE_PRINT_CONTEXT(print_csrc_double, print_csrc) public: - print_csrc_double(); print_csrc_double(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_csrc_double(*this);} }; /** Context for C source output using CLN numbers. */ class print_csrc_cl_N : public print_csrc { + GINAC_DECLARE_PRINT_CONTEXT(print_csrc_cl_N, print_csrc) public: - print_csrc_cl_N(); print_csrc_cl_N(std::ostream &, unsigned options = 0); - print_context * duplicate() const {return new print_csrc_cl_N(*this);} }; /** Check if obj is a T, including base classes. */ template inline bool is_a(const print_context & obj) -{ return dynamic_cast(&obj)!=0; } +{ return dynamic_cast(&obj) != 0; } + + +class basic; + +/** Base class for print_functor handlers */ +class print_functor_impl { +public: + virtual ~print_functor_impl() {} + virtual print_functor_impl *duplicate() const = 0; + virtual void operator()(const basic & obj, const print_context & c, unsigned level) const = 0; +}; + +/** print_functor handler for pointer-to-functions of class T, context type C */ +template +class print_ptrfun_handler : public print_functor_impl { +public: + typedef void (*F)(const T &, const C &, unsigned); + + print_ptrfun_handler(F f_) : f(f_) {} + print_ptrfun_handler *duplicate() const { return new print_ptrfun_handler(*this); } + + void operator()(const basic & obj, const print_context & c, unsigned level) const + { + // Call the supplied function + f(dynamic_cast(obj), dynamic_cast(c), level); + } + +private: + F f; +}; + +/** print_functor handler for member functions of class T, context type C */ +template +class print_memfun_handler : public print_functor_impl { +public: + typedef void (T::*F)(const C & c, unsigned level); + + print_memfun_handler(F f_) : f(f_) {} + print_memfun_handler *duplicate() const { return new print_memfun_handler(*this); } + + void operator()(const basic & obj, const print_context & c, unsigned level) const + { + // Call the supplied member function + return (dynamic_cast(obj).*f)(dynamic_cast(c), level); + } + +private: + F f; +}; + +/** This class represents a print method for a certain algebraic class and + * print_context type. Its main purpose is to hide the difference between + * member functions and nonmember functions behind one unified operator() + * interface. print_functor has value semantics and acts as a smart pointer + * (with deep copy) to a class derived from print_functor_impl which + * implements the actual function call. */ +class print_functor { +public: + print_functor() : impl(0) {} + print_functor(const print_functor & other) : impl(other.impl.get() ? other.impl->duplicate() : 0) {} + print_functor(std::auto_ptr impl_) : impl(impl_) {} + + template + print_functor(void f(const T &, const C &, unsigned)) : impl(new print_ptrfun_handler(f)) {} + + template + print_functor(void (T::*f)(const C &, unsigned)) : impl(new print_memfun_handler(f)) {} + + print_functor & operator=(const print_functor & other) + { + if (this != &other) { + print_functor_impl *p = other.impl.get(); + impl.reset(p ? other.impl->duplicate() : 0); + } + return *this; + } + + void operator()(const basic & obj, const print_context & c, unsigned level) const + { + (*impl)(obj, c, level); + } + + bool is_valid() const { return impl.get(); } + +private: + std::auto_ptr impl; +}; + } // namespace GiNaC