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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : alias.hpp
* DESCRIPTION: Alias type (for references)
* COPYRIGHT  : (C) 2006  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 __ALIAS_HPP
#define __ALIAS_HPP
#include <basix/vector.hpp>
#include <basix/wrap.hpp>


namespace mmx {
#define TMPL template<typename C>
#define Alias alias<C>
#define Alias_rep alias_rep<C>
#define Generic_alias generic_alias<C>
class routine;
TMPL class alias;

/******************************************************************************
* The alias class
******************************************************************************/

TMPL
class alias_rep REP_STRUCT {
protected:
  inline alias_rep () {}
  inline virtual ~alias_rep () {}

public:
  virtual C get () const = 0;
  virtual C& open () const = 0;
  virtual void close () const = 0;
  friend class Alias;
};

TMPL
class alias {
INDIRECT_PROTO_1 (alias, alias_rep, C)
public:
  inline const Alias_rep* operator * () const { return rep; }
  alias (const C& x);
};
INDIRECT_IMPL_1 (alias, alias_rep, typename C, C)

TMPL inline syntactic flatten (const Alias& a) { return flatten (a->get ()); }
TMPL inline alias<C> new_alias (const C& c) { return alias<C> (c); }
TMPL inline C get_alias (const Alias& a) { return a->get (); }
TMPL inline C& open_alias (const Alias& a) { return a->open (); }
TMPL inline void close_alias (const Alias& a) { a->close (); }
TMPL inline C set_alias (const Alias& a, const C& c) {
  a->open ()= c; a->close (); return c; }

WRAP_INDIRECT_IMPL(TMPL inline,Alias)

TMPL
struct binary_helper<Alias >: public void_binary_helper<Alias > {
  static inline string short_type_name () {
    return "Al" * Short_type_name (C); }
  static inline generic full_type_name () {
    return gen ("Alias", Full_type_name (C)); }
};

/******************************************************************************
* Global aliases
******************************************************************************/

TMPL
class global_alias_rep: public Alias_rep {
  C& val;
public:
  inline global_alias_rep (C& val2): val (val2) {}
  inline C get () const { return val; }
  inline C& open () const { return val; }
  inline void close () const {}
};

TMPL Alias
global_alias (C& c) {
  return new global_alias_rep<C> (c);
}

/******************************************************************************
* Basic aliases
******************************************************************************/

TMPL
class basic_alias_rep: public Alias_rep {
  C val;
public:
  inline basic_alias_rep (const C& val2): val (val2) {}
  inline C get () const { return val; }
  inline C& open () const { return *(const_cast<C*> (&val)); }
  inline void close () const {}
};

TMPL
Alias::alias (const C& c) {
  rep= new basic_alias_rep<C> (c);
}

/******************************************************************************
* The generic_alias class. At a first sight, this class may seem superfluous.
* However, we need it for a correct implementation of the Alias (Generic) type.
* Indeed, if x : Alias (Generic) and x refers to an element of type T,
* then x is transformed into an element of type Generic_alias (T) during
* function applications. This enables us to apply converters which depend
* on T, such as the basic converter Generic_alias (T) -> T.
******************************************************************************/

template<typename C>
class generic_alias {
MMX_ALLOCATORS
  alias<generic> rep;
public:
  inline alias<generic> operator * () const { return rep; }
  inline generic_alias (const alias<generic>& a): rep (a) {}
  inline generic_alias (const Generic_alias& a): rep (a.rep) {}
};

TMPL inline syntactic flatten (const Generic_alias& a) { return flatten (*a); }
TMPL inline generic_alias<C> new_genalias (const alias<generic>& a) {
  return generic_alias<C> (a); }
TMPL inline alias<generic> generalize_genalias (const Generic_alias& a) {
  return *a; }
TMPL inline C get_genalias (const Generic_alias& a) {
  return as<C> ((*a)->get ()); }
TMPL inline generic set_genalias (const Generic_alias& a, const generic& c) {
  return set_alias (*a, c); }

WRAP_WRAPPED_IMPL(TMPL inline,Generic_alias)

/******************************************************************************
* Incarnate generic aliases as ordinary aliases
******************************************************************************/

TMPL
class incarnate_alias_rep: public Alias_rep {
  generic_alias<C> a;
  C* temp;
public:
  inline incarnate_alias_rep (const generic_alias<C>& a2):
    a (a2), temp (NULL) {}
  inline ~incarnate_alias_rep () {
    ASSERT (temp == NULL, "destruction while accessing alias"); }
  inline C get () const { return get_genalias (a); }
  inline C& open () const {
    incarnate_alias_rep<C>* me= const_cast<incarnate_alias_rep<C>*> (this);
    me->temp= mmx_new_one<C> (as<C> (get_genalias (a)));
    return *me->temp; }
  inline void close () const {
    incarnate_alias_rep<C>* me= const_cast<incarnate_alias_rep<C>*> (this);
    set_genalias (a, as<generic> (*temp));
    mmx_delete_one<C> (me->temp);
    me->temp= NULL; }
};

TMPL inline alias<C> incarnate_genalias (const generic_alias<C>& a) {
  return new incarnate_alias_rep<C> (a); }

/******************************************************************************
* Type information for alias types
******************************************************************************/

void alias_type_info (nat& id, int& mode);
void alias_specializer (nat id, routine& r);
void alias_getter (nat id, routine& r);
void alias_setter (nat id, routine& r);
generic specialize_alias (const generic& a);
generic get_alias (const generic& a);
generic set_alias (const generic& a, const generic& val);

inline bool
is_alias_type (nat id) {
  int mode= 0;
  alias_type_info (id, mode);
  return mode == 1;
}

inline nat
alias_to_scalar (nat id) {
  int mode= 0;
  alias_type_info (id, mode);
  return id;
}

inline nat
scalar_to_alias (nat id) {
  int mode= 1;
  alias_type_info (id, mode);
  return id;
}

inline nat
new_alias_type_id (nat id) {
  int mode= 2;
  alias_type_info (id, mode);
  return id;
}

inline nat
new_generic_alias_type_id (nat id) {
  int mode= 3;
  alias_type_info (id, mode);
  return id;
}

TMPL struct type_information<Alias > { static nat id; };
TMPL nat type_information<Alias >::id=
  new_alias_type_id (type_information<C>::id);

TMPL struct type_information<Generic_alias > { static nat id; };
TMPL nat type_information<Generic_alias >::id=
  new_generic_alias_type_id (type_information<C>::id);

/******************************************************************************
* Further utilities for the creation of common aliases
******************************************************************************/

template<typename C, typename R, typename A>
class alias_unary_access_rep: public alias_rep<C> {
  alias<R> r;
  A a;
public:
  inline alias_unary_access_rep (const alias<R>& rr, const A& aa):
    r (rr), a (aa) {}
  C get () const { return read (get_alias (r), a); }
  C& open () const { return open_alias (r) [a]; }
  void close () const { close_alias (r); }
};

template<typename C, typename R, typename A> inline alias<C>
alias_access (const alias<R>& r, const A& a) {
  return new alias_unary_access_rep<C,R,A> (r, a);
}

template<typename C, typename R, typename A, typename B>
class alias_binary_access_rep: public alias_rep<C> {
  alias<R> r;
  A a;
  B b;
public:
  inline alias_binary_access_rep
    (const alias<R>& rr, const A& aa, const B& bb):
      r (rr), a (aa), b (bb) {}
  C get () const { return read (get_alias (r), a, b); }
  C& open () const { return open_alias (r) (a, b); }
  void close () const { close_alias (r); }
};

template<typename C, typename R, typename A, typename B> inline alias<C>
alias_access (const alias<R>& r, const A& a, const B& b) {
  return new alias_binary_access_rep<C,R,A,B> (r, a, b);
}

template<typename R, typename A> inline void
alias_reset (const alias<R>& r, const A& a) {
  reset (r->open (), a);
  r->close ();
}

template<typename R, typename A> inline alias<R>
alias_write (const alias<R>& r, const A& a) {
  r->open () << a;
  r->close ();
  return r;
}

template<typename R, typename A, typename B> inline void
alias_glue (const alias<R>& r, const A& a, const B& b) {
  glue (r->open (), a, b);
  r->close ();
}

#undef TMPL
#undef Alias
#undef Alias_rep
#undef Generic_alias
} // namespace mmx
#endif // __ALIAS_HPP