implemented operator-> for the iterators

[ginac.git] / ginac / remember.h

diff --git a/ginac/remember.h b/ginac/remember.h
index 0d9bb687e875047152a04078b9ab0c61ed4c8bac..868b96620967871d507aca9c6501d82e08589a2c 100644 (file)
--- a/ginac/remember.h
+++ b/ginac/remember.h
@@ -4,7 +4,7 @@
  *  in GiNaC functions */
 
 /*
- *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2003 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
@@ -24,27 +24,26 @@
 #ifndef __GINAC_REMEMBER_H__
 #define __GINAC_REMEMBER_H__
 
+#include <iosfwd>
 #include <vector>
 #include <list>
 
-#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
-#endif // ndef NO_NAMESPACE_GINAC
 
 class function;
 class ex;
        
 /** A single entry in the remember table of a function.
-       Needs to be a friend of class function to access 'seq'.
-       'last_access' and 'successful_hits' are updated at each successful
-       'is_equal'. */
+ *  Needs to be a friend of class function to access 'seq'.
+ *  'last_access' and 'successful_hits' are updated at each successful
+ *  'is_equal'. */
 class remember_table_entry {
 public:
        remember_table_entry(function const & f, ex const & r);
        bool is_equal(function const & f) const;
-       ex get_result(void) const { return result; }
-       unsigned long get_last_access(void) const { return last_access; }
-       unsigned long get_successful_hits(void) const { return successful_hits; };
+       ex get_result() const { return result; }
+       unsigned long get_last_access() const { return last_access; }
+       unsigned long get_successful_hits() const { return successful_hits; };
 
 protected:
        unsigned hashvalue;
@@ -56,7 +55,7 @@ protected:
 };    
 
 /** A list of entries in the remember table having some least
-       significant bits of the hashvalue in common. */
+ *  significant bits of the hashvalue in common. */
 class remember_table_list : public std::list<remember_table_entry> {
 public:
        remember_table_list(unsigned as, unsigned strat);
@@ -68,37 +67,35 @@ protected:
 };
 
 /** The remember table is organized like an n-fold associative cache
-       in a microprocessor.  The table has a width of 's' (which is rounded
-       to table_size, some power of 2 near 's', internally) and a depth of 'as'
-       (unless you choose that entries are never discarded). The place where
-       an entry is stored depends on the hashvalue of the parameters of the
-       function (this corresponds to the address of byte to be cached).
-       The 'log_2(table_size)' least significant bits of this hashvalue
-       give the slot in which the entry will be stored or looked up.
-       Each slot can take up to 'as' entries. If a slot is full, an older
-       entry is removed by one of the following strategies:
-       - oldest entry (the first one in the list)
-       - least recently used (the one with the lowest 'last_access')
-       - least frequently used (the one with the lowest 'successful_hits')
-       or all entries are kept which means that the table grows indefinitely. */
+ *  in a microprocessor.  The table has a width of 's' (which is rounded
+ *  to table_size, some power of 2 near 's', internally) and a depth of 'as'
+ *  (unless you choose that entries are never discarded). The place where
+ *  an entry is stored depends on the hashvalue of the parameters of the
+ *  function (this corresponds to the address of byte to be cached).
+ *  The 'log_2(table_size)' least significant bits of this hashvalue
+ *  give the slot in which the entry will be stored or looked up.
+ *  Each slot can take up to 'as' entries. If a slot is full, an older
+ *  entry is removed by one of the following strategies:
+ *   - oldest entry (the first one in the list)
+ *   - least recently used (the one with the lowest 'last_access')
+ *   - least frequently used (the one with the lowest 'successful_hits')
+ *  or all entries are kept which means that the table grows indefinitely. */
 class remember_table : public std::vector<remember_table_list> {
 public:
        remember_table();
        remember_table(unsigned s, unsigned as, unsigned strat);
        bool lookup_entry(function const & f, ex & result) const;
        void add_entry(function const & f, ex const & result);
-       void clear_all_entries(void);
+       void clear_all_entries();
        void show_statistics(std::ostream & os, unsigned level) const;
-       static std::vector<remember_table> & remember_tables(void);
+       static std::vector<remember_table> & remember_tables();
 protected:
-       void init_table(void);
+       void init_table();
        unsigned table_size;
        unsigned max_assoc_size;
        unsigned remember_strategy;
 };      
 
-#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
 
 #endif // ndef __GINAC_REMEMBER_H__