X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.h;h=fd6a74718032a18a0c5328b3a7967cfd2aefab8e;hp=ffc508dbee0dd48ae4b4d6e18b18b96a4f68b1da;hb=aac4cec4d116f0b39daddb35181d1aa85297d4ba;hpb=a377cee53b71348235ec36f83afeced7e10288a8 diff --git a/ginac/basic.h b/ginac/basic.h index ffc508db..fd6a7471 100644 --- a/ginac/basic.h +++ b/ginac/basic.h @@ -3,7 +3,7 @@ * Interface to GiNaC's ABC. */ /* - * GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2020 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 @@ -20,25 +20,25 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __GINAC_BASIC_H__ -#define __GINAC_BASIC_H__ - -#include // for size_t -#include -#include -#include -// CINT needs to work properly with -#include +#ifndef GINAC_BASIC_H +#define GINAC_BASIC_H #include "flags.h" #include "ptr.h" #include "assertion.h" #include "registrar.h" +#include // for size_t +#include +#include +#include // for typeid +#include +#include + namespace GiNaC { class ex; -class ex_is_less; +struct ex_is_less; class symbol; class numeric; class relational; @@ -92,7 +92,8 @@ struct map_function { /** Degenerate base class for visitors. basic and derivative classes * support Robert C. Martin's Acyclic Visitor pattern (cf. - * http://objectmentor.com/publications/acv.pdf). */ + * http://condor.depaul.edu/dmumaugh/OOT/Design-Principles/acv.pdf + * or chapter 10 of Andrei Alexandrescu's "Modern C++ Design"). */ class visitor { protected: virtual ~visitor() {} @@ -108,7 +109,7 @@ class basic : public refcounted // default constructor, destructor, copy constructor and assignment operator protected: - basic() : tinfo_key(&tinfo_static), flags(0) {} + basic() : flags(0) {} public: /** basic destructor, virtual because class ex will delete objects of @@ -121,21 +122,22 @@ public: const basic & operator=(const basic & other); protected: - /** Constructor with specified tinfo_key (used by derived classes instead - * of the default constructor to avoid assigning tinfo_key twice). */ - basic(tinfo_t ti) : tinfo_key(ti), flags(0) {} - // new virtual functions which can be overridden by derived classes public: // only const functions please (may break reference counting) /** Create a clone of this object on the heap. One can think of this as * simulating a virtual copy constructor which is needed for instance by * the refcounted construction of an ex from a basic. */ - virtual basic * duplicate() const { return new basic(*this); } + virtual basic * duplicate() const + { + basic * bp = new basic(*this); + bp->setflag(status_flags::dynallocated); + return bp; + } // evaluation - virtual ex eval(int level = 0) const; - virtual ex evalf(int level = 0) const; + virtual ex eval() const; + virtual ex evalf() const; virtual ex evalm() const; virtual ex eval_integ() const; protected: @@ -198,7 +200,7 @@ public: virtual ex series(const relational & r, int order, unsigned options = 0) const; // rational functions - virtual ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const; + virtual ex normal(exmap & repl, exmap & rev_lookup) const; virtual ex to_rational(exmap & repl) const; virtual ex to_polynomial(exmap & repl) const; @@ -215,7 +217,7 @@ public: // noncommutativity virtual unsigned return_type() const; - virtual tinfo_t return_type_tinfo() const; + virtual return_type_t return_type_tinfo() const; // functions for complex expressions virtual ex conjugate() const; @@ -244,6 +246,23 @@ public: void print_dispatch(const registered_class_info & ri, const print_context & c, unsigned level) const; + /** Save (serialize) the object into archive node. + * + * Losely speaking, this method turns an expression into a byte + * stream (which can be saved and restored later on, or sent via + * network, etc.) + */ + virtual void archive(archive_node& n) const; + /** Load (deserialize) the object from an archive node. + * + * @note This method is essentially a constructor. However, + * constructors can't be virtual. So, if unarchiving routines + * are implemented as constructors one would need to define such + * a constructor in every class, even if all it does is simply + * calling constructor of a superclass. + */ + virtual void read_archive(const archive_node& n, lst& syms); // no const + ex subs_one_level(const exmap & m, unsigned options) const; ex diff(const symbol & s, unsigned nth = 1) const; int compare(const basic & other) const; @@ -265,8 +284,6 @@ public: } } - tinfo_t tinfo() const {return tinfo_key;} - /** Set some status_flags. */ const basic & setflag(unsigned f) const {flags |= f; return *this;} @@ -282,16 +299,12 @@ protected: // member variables protected: - tinfo_t tinfo_key; ///< type info mutable unsigned flags; ///< of type status_flags mutable unsigned hashvalue; ///< hash value }; - // global variables -extern int max_recursion_level; - // convenience type checker template functions @@ -299,16 +312,41 @@ extern int max_recursion_level; template inline bool is_a(const basic &obj) { - return dynamic_cast(&obj) != 0; + return dynamic_cast(&obj) != nullptr; } /** Check if obj is a T, not including base classes. */ template inline bool is_exactly_a(const basic & obj) { - return obj.tinfo() == &T::tinfo_static; + return typeid(T) == typeid(obj); +} + +/** Constructs a new (class basic or derived) B object on the heap. + * + * This function picks the object's ctor based on the given argument types. + * + * This helps the constructor of ex from basic (or a derived class B) because + * then the constructor doesn't have to duplicate the object onto the heap. + * See ex::construct_from_basic(const basic &) for more information. + */ +template +inline B & dynallocate(Args &&... args) +{ + return const_cast(static_cast((new B(std::forward(args)...))->setflag(status_flags::dynallocated))); +} +/** Constructs a new (class basic or derived) B object on the heap. + * + * This function is needed for GiNaC classes which have public ctors from + * initializer lists of expressions (which are not a type and not captured + * by the variadic template version). + */ +template +inline B & dynallocate(std::initializer_list il) +{ + return const_cast(static_cast((new B(il))->setflag(status_flags::dynallocated))); } } // namespace GiNaC -#endif // ndef __GINAC_BASIC_H__ +#endif // ndef GINAC_BASIC_H