archive.h

Go to the documentation of this file.

 
/*
 *  GiNaC Copyright (C) 1999-2026 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
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef GINAC_ARCHIVE_H
#define GINAC_ARCHIVE_H
 
#include "ex.h"
 
#include <iosfwd>
#include <map>
#include <string>
#include <vector>
 
namespace GiNaC {
 
class archive;
 
 
typedef unsigned archive_node_id;
 
typedef unsigned archive_atom;
 
 
class archive_node
{
    friend std::ostream &operator<<(std::ostream &os, const archive_node &ar);
    friend std::istream &operator>>(std::istream &is, archive_node &ar);
 
public:
    enum property_type {
        PTYPE_BOOL,
        PTYPE_UNSIGNED,
        PTYPE_STRING,
        PTYPE_NODE
    };
 
    struct property_info {
        property_info() {}
        property_info(property_type t, const std::string &n, unsigned c = 1) : type(t), name(n), count(c) {}
 
        property_type type; 
        std::string name;   
        unsigned count;     
    };
    typedef std::vector<property_info> propinfovector;
 
    struct property {
        property() {}
        property(archive_atom n, property_type t, unsigned v) : type(t), name(n), value(v) {}
 
        property_type type; 
        archive_atom name;  
        unsigned value;     
    };
    typedef std::vector<property>::const_iterator archive_node_cit;
    struct archive_node_cit_range {
        archive_node_cit begin, end;
    };
 
    archive_node(archive &ar) : a(ar), has_expression(false) {}
    archive_node(archive &ar, const ex &expr);
 
    const archive_node &operator=(const archive_node &other);
 
    void add_bool(const std::string &name, bool value);
 
    void add_unsigned(const std::string &name, unsigned value);
 
    void add_string(const std::string &name, const std::string &value);
 
    void add_ex(const std::string &name, const ex &value);
 
    bool find_bool(const std::string &name, bool &ret, unsigned index = 0) const;
 
    bool find_unsigned(const std::string &name, unsigned &ret, unsigned index = 0) const;
 
    bool find_string(const std::string &name, std::string &ret, unsigned index = 0) const;
 
    archive_node_cit find_first(const std::string &name) const;
    archive_node_cit find_last(const std::string &name) const;
 
    archive_node_cit_range find_property_range(const std::string &name1, const std::string &name2) const;
 
    bool find_ex(const std::string &name, ex &ret, lst &sym_lst, unsigned index = 0) const;
 
    void find_ex_by_loc(archive_node_cit loc, ex &ret, lst &sym_lst) const;
 
    const archive_node &find_ex_node(const std::string &name, unsigned index = 0) const;
 
    void get_properties(propinfovector &v) const;
 
    ex unarchive(lst &sym_lst) const;
    bool has_same_ex_as(const archive_node &other) const;
    bool has_ex() const {return has_expression;}
    ex get_ex() const {return e;}
 
    void forget();
    void printraw(std::ostream &os) const;
 
private:
    archive &a;
 
    std::vector<property> props;
 
    mutable bool has_expression;
 
    mutable ex e;
};
 
typedef basic* (*synthesize_func)();
typedef std::map<std::string, synthesize_func> unarchive_map_t;
 
class unarchive_table_t
{
    static int usecount;
    static unarchive_map_t* unarch_map;
public:
    unarchive_table_t();
    ~unarchive_table_t();
    synthesize_func find(const std::string& classname) const;
    void insert(const std::string& classname, synthesize_func f);
};
static unarchive_table_t unarch_table_instance;
 
#define GINAC_DECLARE_UNARCHIVER(classname)         \
class classname ## _unarchiver                  \
{                               \
    static int usecount;                    \
public:                             \
    static GiNaC::basic* create();              \
    classname ## _unarchiver();             \
    ~ classname ## _unarchiver();               \
};                              \
static classname ## _unarchiver classname ## _unarchiver_instance
 
#define GINAC_BIND_UNARCHIVER(classname)            \
classname ## _unarchiver::classname ## _unarchiver()        \
{                               \
    static GiNaC::unarchive_table_t table;          \
    if (usecount++ == 0) {                  \
        table.insert(std::string(#classname),       \
            &(classname ## _unarchiver::create));   \
    }                           \
}                               \
GiNaC::basic* classname ## _unarchiver::create()        \
{                               \
    return new classname();                 \
}                               \
classname ## _unarchiver::~ classname ## _unarchiver() { }  \
int classname ## _unarchiver::usecount = 0
 
 
class archive
{
    friend std::ostream &operator<<(std::ostream &os, const archive &ar);
    friend std::istream &operator>>(std::istream &is, archive &ar);
 
public:
    archive() {}
    ~archive() {}
 
    archive(const ex &e) {archive_ex(e, "ex");}
 
    archive(const ex &e, const char *n) {archive_ex(e, n);}
 
    void archive_ex(const ex &e, const char *name);
 
    ex unarchive_ex(const lst &sym_lst, const char *name) const;
 
    ex unarchive_ex(const lst &sym_lst, unsigned index = 0) const;
 
    ex unarchive_ex(const lst &sym_lst, std::string &name, unsigned index = 0) const;
 
    unsigned num_expressions() const;
 
    const archive_node &get_top_node(unsigned index = 0) const;
 
    void clear();
 
    archive_node_id add_node(const archive_node &n);
    archive_node &get_node(archive_node_id id);
 
    void forget();
    void printraw(std::ostream &os) const;
 
private:
    std::vector<archive_node> nodes;
 
    struct archived_ex {
        archived_ex() {}
        archived_ex(archive_atom n, archive_node_id node) : name(n), root(node) {}
 
        archive_atom name;     
        archive_node_id root;  
    };
 
    std::vector<archived_ex> exprs;
 
public:
    archive_atom atomize(const std::string &s) const;
    const std::string &unatomize(archive_atom id) const;
 
private:
    mutable std::vector<std::string> atoms;
    typedef std::map<std::string, archive_atom>::const_iterator inv_at_cit;
    mutable std::map<std::string, archive_atom> inverse_atoms;
 
    mutable std::map<ex, archive_node_id, ex_is_less> exprtable;
};
 
 
std::ostream &operator<<(std::ostream &os, const archive &ar);
std::istream &operator>>(std::istream &is, archive &ar);
 
} // namespace GiNaC
 
#endif // ndef GINAC_ARCHIVE_H