include/basix/tuple.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : tuple.hpp
* DESCRIPTION: Syntactic tuple type constructor
* 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 __TUPLE_HPP
#define __TUPLE_HPP
#include <basix/vector.hpp>
#include <basix/table.hpp>
#include <basix/wrap.hpp>
#include <basix/compound.hpp>


namespace mmx {
#define TMPL template<typename C>
#define Tuple tuple<C>

/******************************************************************************
* The tuple class
******************************************************************************/

template<typename C>
class tuple {
MMX_ALLOCATORS
  generic rep;
public:
  inline generic operator * () const { return rep; }
  inline tuple (const generic& g): rep (g) {}
  inline tuple (const Tuple& t): rep (t.rep) {}
  inline C operator[] (nat i) const { return as<C> (rep[i+1]); }
};

WRAP_INDIRECT_IMPL(TMPL inline,Tuple)

TMPL inline nat N (const Tuple& t) { return N (*t) - 1; }

TMPL syntactic
flatten (const Tuple& t) {
  return flatten (gen (GEN_TUPLE, cdr (compound_to_vector (*t))));
}

WRAP_BINARY_IMPL_1(TMPL,Tuple,generic,"Tu","Tuple",C)

/******************************************************************************
* Useful conversions
******************************************************************************/

TMPL Tuple
as_tuple (const vector<C>& a) {
  nat i, n= N(a);
  vector<generic> t= fill<generic> (n+1);
  t[0]= GEN_TUPLE;
  for (i=0; i<n; i++)
    t[i+1]= as<generic> (a[i]);
  return Tuple (vector_to_compound (t));
}

TMPL vector<C>
as_vector (const Tuple& t) {
  nat i, n= N(t);
  vector<C> a= fill<C> (n);
  for (i=0; i<n; i++)
    a[i]= t[i];
  return a;
}

template<typename T, typename F>
struct as_helper<tuple<T>,tuple<F> > {
  static tuple<T> cv (const tuple<F>& r) {
    return as_tuple<T> (vector<T> (as_vector<F> (r))); }
};


TMPL iterator<C>
iterate (const Tuple& t) {
  return iterate (as_vector (t));
}

/******************************************************************************
* Type information for tuple types
******************************************************************************/

inline nat new_tuple_type_id (nat id);

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

void tuple_type_info (nat& id, bool& mode);

inline bool
is_tuple_type (nat id) {
  bool mode= false;
  tuple_type_info (id, mode);
  return mode;
}

inline nat
tuple_to_scalar (nat id) {
  bool mode= false;
  tuple_type_info (id, mode);
  return id;
}

inline nat
new_tuple_type_id (nat id) {
  bool mode= true;
  tuple_type_info (id, mode);
  return id;
}

#undef TMPL
#undef Tuple
} // namespace mmx
#endif // __TUPLE_HPP

---