/Users/mourrain/Devel/mmx/basix/include/basix/symbol.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : symbol.hpp
* DESCRIPTION: A symbol points to another object but is stored only once
*              unless explicitely specified
* COPYRIGHT  : (C) 2004  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 __MMX_SYMBOL_HPP
#define __MMX_SYMBOL_HPP
#include <basix/table.hpp>


namespace mmx {
#define TMPL_DEF template<typename C, typename V= exact_eq_table>
#define TMPL template<typename C, typename V>
#define Symbol symbol<C,V>
#define Symbol_rep symbol_rep<C,V>
TMPL class symbol_rep;
TMPL class symbol;
TMPL inline nat hash (const Symbol& s);
TMPL inline bool operator == (const Symbol& s1, const Symbol& s2);
TMPL inline bool operator != (const Symbol& s1, const Symbol& s2);
TMPL inline nat exact_hash (const Symbol& s);
TMPL inline bool exact_eq (const Symbol& s1, const Symbol& s2);
TMPL inline bool exact_neq (const Symbol& s1, const Symbol& s2);

/******************************************************************************
* Symbol class and its representation class
******************************************************************************/

TMPL_DEF
class symbol_rep REP_STRUCT {
private:
  typedef table<Symbol_rep*,C,V> table_type;

  static inline table_type& ptr () {
    typedef table<Symbol_rep*,C,V> table_type;
    static table_type* t= mmx_new_one<table_type> ();
    // FIXME: this table is never destroyed explicitely.
    // This solution avoids segfaults due to corrupted order of
    // destruction of static variables on exit.
    return *t; }
  static inline table_type all_entries () {
    return copy (ptr ()); }
  static inline Symbol_rep* get_entry (const C& ref) {
    return (inside (ptr ())) -> get (ref); }
  static inline void set_entry (const C& ref, Symbol_rep* val) {
    (inside (ptr ())) -> set (ref)= val; }
  static inline void reset_entry (const C& ref) {
    (inside (ptr ())) -> reset (ref); }

private:
  C ref;

public:
  inline Symbol_rep (const C& ref2): ref (ref2) {
    set_entry (ref, this); }
  inline ~Symbol_rep () {
    reset_entry (ref); }
  friend class Symbol;
  static void show_symbol_entries () {
    mmout << "symbols\t= " << all_entries () << "\n"; }
};

TMPL_DEF
class symbol {
INDIRECT_PROTO_2 (symbol, symbol_rep, C, V)
public:
  symbol (const C& ref= C()) {
    rep= Symbol_rep::get_entry (ref);
    if (rep == (Symbol_rep*) NULL) rep= new Symbol_rep (ref);
    else INC_COUNT (rep); }
  inline const C& operator * () const { return rep->ref; };
  friend nat hash LESSGTR (const Symbol& s);
  friend bool operator == LESSGTR (const Symbol& s1, const Symbol& s2);
  friend bool operator != LESSGTR (const Symbol& s1, const Symbol& s2);
  friend nat exact_hash LESSGTR (const Symbol& s);
  friend bool exact_eq LESSGTR (const Symbol& s1, const Symbol& s2);
  friend bool exact_neq LESSGTR (const Symbol& s1, const Symbol& s2);
};
INDIRECT_IMPL_2 (symbol, symbol_rep, typename C, C, typename V, V)

template<> struct symbolic_type_information<symbol<string> > {
  static const nat id= SYMBOLIC_LITERAL; };
template<typename C> struct symbolic_type_information<symbol<vector<C> > > {
  static const nat id= SYMBOLIC_COMPOUND; };

/******************************************************************************
* Routines related to equality testing
******************************************************************************/

TMPL inline nat hash (const Symbol& s) {
  return hash (*s); }
TMPL inline bool operator == (const Symbol& s1, const Symbol& s2) {
  return (*s1) == (*s2); }
TMPL inline bool operator != (const Symbol& s1, const Symbol& s2) {
  return (*s1) != (*s2); }

TMPL inline nat exact_hash (const Symbol& s) {
  return as_hash (s.rep); }
TMPL inline bool exact_eq (const Symbol& s1, const Symbol& s2) {
  return s1.rep == s2.rep; }
TMPL inline bool exact_neq (const Symbol& s1, const Symbol& s2) {
  return s1.rep != s2.rep; }

template<typename C> inline nat hash (const symbol<C,equal_table>& s) {
  return exact_hash (s); }
template<typename C> inline bool
operator == (const symbol<C,equal_table>& s1,
             const symbol<C,equal_table>& s2) {
  return exact_eq (s1, s2); }
template<typename C> inline bool
operator != (const symbol<C,equal_table>& s1,
             const symbol<C,equal_table>& s2) {
  return exact_neq (s1, s2); }

/******************************************************************************
* Printing symbols
******************************************************************************/

TMPL void show_symbol_entries () {
  Symbol_rep::show_symbol_entries (); }

TMPL inline syntactic flatten (const Symbol& s) {
  return apply ("symbol", flatten (*s)); }

TMPL
struct binary_helper<Symbol >: public void_binary_helper<Symbol > {
  static inline string short_type_name () {
    return "Sy" * Short_type_name (C); }
  static inline generic full_type_name () {
    return gen ("Symbol", Full_type_name (C)); }
  static inline generic disassemble (const Symbol& x) {
    return as<generic> (C (*x)); }
  static inline Symbol assemble (const generic& x) {
    return Symbol (as<C> (x)); }
  static inline void write (const port& out, const Symbol& s) {
    binary_write<C> (out, *s); }
  static inline Symbol read (const port& in) {
    return Symbol (binary_read<C> (in)); }
};

#undef TMPL_DEF
#undef TMPL
#undef Symbol
#undef Symbol_rep
} // namespace mmx
#endif // __MMX_SYMBOL_HPP