added functions to retrieve the properties stored in archive objects
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Mon, 9 Apr 2001 21:33:48 +0000 (21:33 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Mon, 9 Apr 2001 21:33:48 +0000 (21:33 +0000)
outside of unarchive(), for printing or debugging purposes

ginac/archive.cpp
ginac/archive.h

index 8d54681e70152753f975f432437ceafe8062485d..43b2667cac1c9e0b80c59df913f516726820da6b 100644 (file)
@@ -32,9 +32,6 @@
 namespace GiNaC {
 
 
-/** Archive an expression.
- *  @param ex  the expression to be archived
- *  @param name  name under which the expression is stored */
 void archive::archive_ex(const ex &e, const char *name)
 {
        // Create root node (which recursively archives the whole expression tree)
@@ -77,8 +74,6 @@ archive_node &archive::get_node(archive_node_id id)
 }
 
 
-/** Retrieve expression from archive by name.
- *  @param sym_lst  list of pre-defined symbols */
 ex archive::unarchive_ex(const lst &sym_lst, const char *name) const
 {
        // Find root node
@@ -90,15 +85,13 @@ ex archive::unarchive_ex(const lst &sym_lst, const char *name) const
                        goto found;
                i++;
        }
-       throw (std::logic_error("expression with name '" + name_string + "' not found in archive"));
+       throw (std::runtime_error("expression with name '" + name_string + "' not found in archive"));
 
 found:
        // Recursively unarchive all nodes, starting at the root node
        return nodes[i->root].unarchive(sym_lst);
 }
 
-/** Retrieve expression from archive by index.
- *  @param sym_lst  list of pre-defined symbols */
 ex archive::unarchive_ex(const lst &sym_lst, unsigned int index) const
 {
        if (index >= exprs.size())
@@ -108,8 +101,6 @@ ex archive::unarchive_ex(const lst &sym_lst, unsigned int index) const
        return nodes[exprs[index].root].unarchive(sym_lst);
 }
 
-/** Retrieve expression and its name from archive by index.
- *  @param sym_lst  list of pre-defined symbols */
 ex archive::unarchive_ex(const lst &sym_lst, std::string &name, unsigned int index) const
 {
        if (index >= exprs.size())
@@ -122,13 +113,19 @@ ex archive::unarchive_ex(const lst &sym_lst, std::string &name, unsigned int ind
        return nodes[exprs[index].root].unarchive(sym_lst);
 }
 
-
-/** Return number of archived expressions. */
 unsigned int archive::num_expressions(void) const
 {
        return exprs.size();
 }
 
+const archive_node &archive::get_top_node(unsigned int index) const
+{
+       if (index >= exprs.size())
+               throw (std::range_error("index of archived expression out of range"));
+
+       return nodes[exprs[index].root];
+}
+
 
 /*
  *  Archive file format
@@ -358,25 +355,21 @@ bool archive_node::has_same_ex_as(const archive_node &other) const
 }
 
 
-/** Add property of type "bool" to node. */
 void archive_node::add_bool(const std::string &name, bool value)
 {
        props.push_back(property(a.atomize(name), PTYPE_BOOL, value));
 }
 
-/** Add property of type "unsigned int" to node. */
 void archive_node::add_unsigned(const std::string &name, unsigned int value)
 {
        props.push_back(property(a.atomize(name), PTYPE_UNSIGNED, value));
 }
 
-/** Add property of type "string" to node. */
 void archive_node::add_string(const std::string &name, const std::string &value)
 {
        props.push_back(property(a.atomize(name), PTYPE_STRING, a.atomize(value)));
 }
 
-/** Add property of type "ex" to node. */
 void archive_node::add_ex(const std::string &name, const ex &value)
 {
        // Recursively create an archive_node and add its ID to the properties of this node
@@ -385,8 +378,6 @@ void archive_node::add_ex(const std::string &name, const ex &value)
 }
 
 
-/** Retrieve property of type "bool" from node.
- *  @return "true" if property was found, "false" otherwise */
 bool archive_node::find_bool(const std::string &name, bool &ret) const
 {
        archive_atom name_atom = a.atomize(name);
@@ -401,8 +392,6 @@ bool archive_node::find_bool(const std::string &name, bool &ret) const
        return false;
 }
 
-/** Retrieve property of type "unsigned" from node.
- *  @return "true" if property was found, "false" otherwise */
 bool archive_node::find_unsigned(const std::string &name, unsigned int &ret) const
 {
        archive_atom name_atom = a.atomize(name);
@@ -417,8 +406,6 @@ bool archive_node::find_unsigned(const std::string &name, unsigned int &ret) con
        return false;
 }
 
-/** Retrieve property of type "string" from node.
- *  @return "true" if property was found, "false" otherwise */
 bool archive_node::find_string(const std::string &name, std::string &ret) const
 {
        archive_atom name_atom = a.atomize(name);
@@ -433,8 +420,6 @@ bool archive_node::find_string(const std::string &name, std::string &ret) const
        return false;
 }
 
-/** Retrieve property of type "ex" from node.
- *  @return "true" if property was found, "false" otherwise */
 bool archive_node::find_ex(const std::string &name, ex &ret, const lst &sym_lst, unsigned int index) const
 {
        archive_atom name_atom = a.atomize(name);
@@ -455,6 +440,47 @@ found:
        return true;
 }
 
+const archive_node &archive_node::find_ex_node(const std::string &name, unsigned int index) const
+{
+       archive_atom name_atom = a.atomize(name);
+       std::vector<property>::const_iterator i = props.begin(), iend = props.end();
+       unsigned int found_index = 0;
+       while (i != iend) {
+               if (i->type == PTYPE_NODE && i->name == name_atom) {
+                       if (found_index == index)
+                               return a.get_node(i->value);
+                       found_index++;
+               }
+               i++;
+       }
+       throw (std::runtime_error("property with name '" + name + "' not found in archive node"));
+}
+
+
+void archive_node::get_properties(std::vector<archive_node::property_info> &v) const
+{
+       v.clear();
+       std::vector<property>::const_iterator i = props.begin(), iend = props.end();
+       while (i != iend) {
+               property_type type = i->type;
+               string name = a.unatomize(i->name);
+
+               std::vector<property_info>::iterator a = v.begin(), aend = v.end();
+               bool found = false;
+               while (a != aend) {
+                       if (a->type == type && a->name == name) {
+                               a->count++;
+                               found = true;
+                               break;
+                       }
+                       a++;
+               }
+               if (!found)
+                       v.push_back(property_info(type, name));
+               i++;
+       }       
+}
+
 
 /** Convert archive node to GiNaC expression. */
 ex archive_node::unarchive(const lst &sym_lst) const
@@ -476,6 +502,17 @@ ex archive_node::unarchive(const lst &sym_lst) const
 }
 
 
+/** Assignment operator of property_info. */
+const archive_node::property_info &archive_node::property_info::operator=(const property_info &other)
+{
+       if (this != &other) {
+               type = other.type;
+               name = other.name;
+               count = other.count;
+       }
+       return *this;
+}
+
 /** Assignment operator of property. */
 const archive_node::property &archive_node::property::operator=(const property &other)
 {
@@ -488,7 +525,6 @@ const archive_node::property &archive_node::property::operator=(const property &
 }
 
 
-/** Clear all archived expressions. */
 void archive::clear(void)
 {
        atoms.clear();
index 24c6d5d905548a6901eb5f5f842dda46191fe177..c5030eb5a6083b541b7f0d55838da3668e015928 100644 (file)
@@ -51,6 +51,30 @@ class archive_node
        friend std::istream &operator>>(std::istream &is, archive_node &ar);
 
 public:
+       /** Property data types */
+       enum property_type {
+               PTYPE_BOOL,
+               PTYPE_UNSIGNED,
+               PTYPE_STRING,
+               PTYPE_NODE
+       };
+
+       /** Information about a stored property. A vector of these structures
+        *  is returned by get_properties().
+        *  @see get_properties */
+       struct property_info {
+               property_info() {}
+               property_info(property_type t, const std::string &n, unsigned c = 1) : type(t), name(n), count(c) {}
+               ~property_info() {}
+
+               property_info(const property_info &other) : type(other.type), name(other.name), count(other.count) {}
+               const property_info &operator=(const property_info &other);
+
+               property_type type;     /**< Data type of property. */
+               std::string name;   /**< Name of property. */
+               unsigned count;     /**< Number of occurrences. */
+       };
+
        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);
@@ -59,19 +83,43 @@ public:
        archive_node(const archive_node &other);
        const archive_node &operator=(const archive_node &other);
 
-       bool has_same_ex_as(const archive_node &other) const;
-
+       /** Add property of type "bool" to node. */
        void add_bool(const std::string &name, bool value);
+
+       /** Add property of type "unsigned int" to node. */
        void add_unsigned(const std::string &name, unsigned int value);
+
+       /** Add property of type "string" to node. */
        void add_string(const std::string &name, const std::string &value);
+
+       /** Add property of type "ex" to node. */
        void add_ex(const std::string &name, const ex &value);
 
+       /** Retrieve property of type "bool" from node.
+        *  @return "true" if property was found, "false" otherwise */
        bool find_bool(const std::string &name, bool &ret) const;
+
+       /** Retrieve property of type "unsigned" from node.
+        *  @return "true" if property was found, "false" otherwise */
        bool find_unsigned(const std::string &name, unsigned int &ret) const;
+
+       /** Retrieve property of type "string" from node.
+        *  @return "true" if property was found, "false" otherwise */
        bool find_string(const std::string &name, std::string &ret) const;
+
+       /** Retrieve property of type "ex" from node.
+        *  @return "true" if property was found, "false" otherwise */
        bool find_ex(const std::string &name, ex &ret, const lst &sym_lst, unsigned int index = 0) const;
 
+       /** Retrieve property of type "ex" from node, returning the node of
+        *  the sub-expression. */
+       const archive_node &find_ex_node(const std::string &name, unsigned int index = 0) const;
+
+       /** Return vector of properties stored in node. */
+       void get_properties(std::vector<property_info> &v) const;
+
        ex unarchive(const lst &sym_lst) const;
+       bool has_same_ex_as(const archive_node &other) const;
 
        void forget(void);
        void printraw(std::ostream &os) const;
@@ -79,14 +127,6 @@ public:
 private:
        static archive* dummy_ar_creator(void);
 
-       /** Property data types */
-       enum property_type {
-               PTYPE_BOOL,
-               PTYPE_UNSIGNED,
-               PTYPE_STRING,
-               PTYPE_NODE
-       };
-
        /** Archived property (data type, name and associated data) */
        struct property {
                property() {}
@@ -96,9 +136,9 @@ private:
                property(const property &other) : type(other.type), name(other.name), value(other.value) {}
                const property &operator=(const property &other);
 
-               property_type type;     /**< Data type of property. */
-               archive_atom name;      /**< Name of property. */
-               unsigned int value;     /**< Stored value. */
+               property_type type; /**< Data type of property. */
+               archive_atom name;  /**< Name of property. */
+               unsigned int value; /**< Stored value. */
        };
 
        /** Reference to the archive to which this node belongs. */
@@ -137,17 +177,38 @@ public:
        /** Construct archive from expression using the specified name. */
        archive(const ex &e, const char *n) {archive_ex(e, n);}
 
-       archive_node_id add_node(const archive_node &n);
-       archive_node &get_node(archive_node_id id);
-
+       /** Archive an expression.
+        *  @param e the expression to be archived
+        *  @param name name under which the expression is stored */
        void archive_ex(const ex &e, const char *name);
+
+       /** Retrieve expression from archive by name.
+        *  @param sym_lst list of pre-defined symbols */
        ex unarchive_ex(const lst &sym_lst, const char *name) const;
+
+       /** Retrieve expression from archive by index.
+        *  @param sym_lst list of pre-defined symbols
+     *  @see count_expressions */
        ex unarchive_ex(const lst &sym_lst, unsigned int index = 0) const;
+
+       /** Retrieve expression and its name from archive by index.
+        *  @param sym_lst list of pre-defined symbols
+        *  @param name receives the name of the expression
+     *  @see count_expressions */
        ex unarchive_ex(const lst &sym_lst, std::string &name, unsigned int index = 0) const;
+
+       /** Return number of archived expressions. */
        unsigned int num_expressions(void) const;
 
+       /** Return reference to top node of an expression specified by index. */
+       const archive_node &get_top_node(unsigned int index = 0) const;
+
+       /** Clear all archived expressions. */
        void clear(void);
 
+       archive_node_id add_node(const archive_node &n);
+       archive_node &get_node(archive_node_id id);
+
        void forget(void);
        void printraw(std::ostream &os) const;