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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : row_tuple.hpp
* DESCRIPTION: Syntactic row_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 __ROW_TUPLE_HPP
#define __ROW_TUPLE_HPP
#include <basix/vector.hpp>
#include <basix/wrap.hpp>


namespace mmx {
#define TMPL template<typename C>
#define Row_tuple row_tuple<C>
generic vector_to_compound (const vector<generic>& v);

/******************************************************************************
* The row_tuple class
******************************************************************************/

template<typename C>
class row_tuple {
MMX_ALLOCATORS
  generic rep;
public:
  inline generic operator * () const { return rep; }
  inline row_tuple (): rep (gen (GEN_ROW)) {}
  inline row_tuple (const generic& g): rep (g) {}
  inline row_tuple (const vector<C>& v):
    rep (gen (GEN_ROW, as<vector<generic> > (v))) {};
  inline row_tuple (const Row_tuple& t): rep (t.rep) {}
  inline C operator[] (nat i) const { return as<C> (rep[i+1]); }
};

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

WRAP_INDIRECT_IMPL(TMPL inline,Row_tuple)

TMPL syntactic
flatten (const Row_tuple& t) {
  return as_syntactic (gen (GEN_ROW, cdr (compound_to_vector (*t))));
}

WRAP_BINARY_IMPL_1(TMPL,Row_tuple,generic,"Rtu","Row_tuple",C)

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

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

TMPL vector<C>
as_vector (const Row_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<row_tuple<T>,row_tuple<F> > {
  static row_tuple<T> cv (const row_tuple<F>& r) {
    return as_row_tuple<T> (as<vector<T> > (as_vector<F> (r))); }
};

#undef TMPL
#undef Row_tuple
} // namespace mmx
#endif // __ROW_TUPLE_HPP