archive.h

Go to the documentation of this file.

/*
 *  GiNaC Copyright (C) 1999-2010 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, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#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;

    archive_node() : a(*dummy_ar_creator()), has_expression(false) {} // hack for cint which always requires a default constructor
    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;

    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:
    static archive* dummy_ar_creator();

    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;

    typedef std::map<ex, archive_node_id, ex_is_less>::iterator mapit;
    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