include/basix/cache.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : cache.hpp
* DESCRIPTION: Table wrapper for modified equality tests
* COPYRIGHT  : (C) 2012  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __CACHE_HPP
#define __CACHE_HPP
#include <basix/table.hpp>


namespace mmx {
#define TMPL template<typename C, typename T>
#define Table table<C,T>
#define Cache cache<C,T>

/******************************************************************************
* The cache wrapper class
******************************************************************************/

TMPL
class cache {
MMX_ALLOCATORS
  Table rep;
public:
  inline Table operator * () const { return rep; }
  inline Table& operator * () { return rep; }
  inline cache (): rep (Table ()) {}
  inline cache (const Table& c): rep (c) {}
};

TMPL inline nat hash (const Cache& c) { return hard_hash (*c); }
TMPL inline nat exact_hash (const Cache& c) { return hard_hash (*c); }
TMPL inline nat hard_hash (const Cache& c) { return hard_hash (*c); }
TMPL inline bool operator == (const Cache& c1, const Cache& c2) {
  return hard_eq (*c1, *c2); }
TMPL inline bool operator != (const Cache& c1, const Cache& c2) {
  return hard_neq (*c1, *c2); }
TMPL inline bool exact_eq (const Cache& c1, const Cache& c2) {
  return hard_eq (*c1, *c2); }
TMPL inline bool exact_neq (const Cache& c1, const Cache& c2) {
  return hard_neq (*c1, *c2); }
TMPL inline bool hard_eq (const Cache& c1, const Cache& c2) {
  return hard_eq (*c1, *c2); }
TMPL inline bool hard_neq (const Cache& c1, const Cache& c2) {
  return hard_neq (*c1, *c2); }

TMPL inline syntactic flatten (const Cache& c) { return flatten (*c); }

/******************************************************************************
* Basic functionality
******************************************************************************/

TMPL inline nat N (const Cache& c) {
  return N (*c); }
TMPL inline double complexity (const Cache& c) {
  return complexity (*c); }
TMPL inline nat discrete_complexity (const Cache& c) {
  return discrete_complexity (*c); }

TMPL inline void inside_set (const Cache& c, const T& x, const C& v) {
  inside_set (*c, x, v); }
TMPL inline void reset (Cache& c, const T& x) {
  reset (*c, x); }
TMPL inline bool contains (const Cache& c, const T& x) {
  return contains (*c, x); }
TMPL inline C read (const Cache& c, const T& x) {
  return read (*c, x); }
TMPL inline iterator<T> entries (const Cache& c) {
  return entries (*c); }
TMPL inline Cache append (const Cache& t, const Cache& u) {
  return Cache (append (*t, *u)); }

/******************************************************************************
* Constructors for glue
******************************************************************************/

template<typename T, typename C> inline Cache
make_cache_1 (const format<T>& fm1, const format<C>& fm2) {
  return Cache (table<C,T> (default_cst (fm2), fm1));
}

template<typename T, typename C> inline Cache
make_cache_2 (const C& init, const format<T>& fm) {
  return Cache (table<C,T> (init, fm));
}

template<typename T, typename C> inline Cache
make_cache_3 (const vector<pair<T,C> >& v) {
  return Cache (table<C,T> (default_cst (get_format2 (CF(v))), iterate (v)));
}

template<typename T, typename C> inline Cache
make_cache_4 (const C& init, const vector<pair<T,C> >& v) {
  return Cache (table<C,T> (init, iterate (v)));
}

#undef TMPL
#undef Table
#undef Cache
} // namespace mmx
#endif // __CACHE_HPP

---