include/basix/instance.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : instance.hpp
* DESCRIPTION: Instances of a dynamic type of a given category
* 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 __MMX__INSTANCE__HPP
#define __MMX__INSTANCE__HPP

#include <basix/table.hpp>
#include <basix/wrap.hpp>
#include <basix/literal.hpp>
#include <basix/compound.hpp>

namespace mmx {
#define TMPL template<typename Cat, nat Nr>
#define Instance instance<Cat,Nr>

/******************************************************************************
* Instances
******************************************************************************/

TMPL
class instance {
MMX_ALLOCATORS
  generic rep;
public:
  static Cat Cur;
public:
  inline generic operator * () const { return rep; }
  inline instance (const instance& prg2): rep (prg2.rep) {}
  inline instance (const generic& prg): rep (prg) {}
  instance ();
  template<typename C1>
  instance (const C1& c1);
  template<typename C1, typename C2>
  instance (const C1& c1, const C2& c2);
  template<typename C1, typename C2, typename C3>
  instance (const C1& c1, const C2& c2, const C3& c3);
};

WRAP_WRAPPED_IMPL(TMPL,Instance);
WRAP_PRINT_IMPL(TMPL,Instance);
WRAP_BINARY_IMPL(TMPL,Instance,generic,"Ins","Ins")

TMPL Cat Instance::Cur = Cat ();

template<typename Dest, typename Src> inline Dest
view_as (const Src& src) {
  return *((Dest*) ((void*) &src));
}

template<typename Dest, typename Src> inline Dest&
view_as (Src& src) {
  return *((Dest*) ((void*) &src));
}

/******************************************************************************
* Constructors
******************************************************************************/

template<typename Cat, nat Nr>
struct constructor_0 {
  static inline generic op () {
    return Instance::Cur -> sample_1 (); }
};

TMPL inline
Instance::instance ():
  rep (constructor_0<Cat,Nr>::op ()) {}

template<typename Cat, nat Nr, typename C1>
struct constructor_1 {
  static inline generic op (const C1& c1) {
    generic r;
    set_as (view_as<Instance> (r), c1);
    return r;
  }
};

TMPL template<typename C1> inline
Instance::instance (const C1& c1):
  rep (constructor_1<Cat,Nr,C1>::op (c1)) {}

template<typename Cat, nat Nr, typename C1, typename C2>
struct constructor_2 {
  static inline generic op (const C1& c1, const C2& c2) {
    generic r;
    set_as (view_as<Instance> (r), c1, c2);
    return r;
  }
};

TMPL template<typename C1, typename C2> inline
Instance::instance (const C1& c1, const C2& c2):
  rep (constructor_2<Cat,Nr,C1,C2>::op (c1, c2)) {}

template<typename Cat, nat Nr, typename C1, typename C2, typename C3>
struct constructor_3 {
  static inline generic op (const C1& c1, const C2& c2, const C3& c3) {
    generic r;
    set_as (view_as<Instance> (r), c1, c2, c3);
    return r;
  }
};

TMPL template<typename C1, typename C2, typename C3> inline
Instance::instance (const C1& c1, const C2& c2, const C3& c3):
  rep (constructor_3<Cat,Nr,C1,C2,C3>::op (c1, c2, c3)) {}

/******************************************************************************
* Commodity routines (should be handled in a better way later)
******************************************************************************/

TMPL inline bool operator == (const Instance& x, const int& i) {
  return x == promote (i, x); }
TMPL inline bool operator != (const Instance& x, const int& i) {
  return x != promote (i, x); }
TMPL inline bool operator < (const Instance& x, const int& i) {
  return x < promote (i, x); }
TMPL inline bool operator > (const Instance& x, const int& i) {
  return x > promote (i, x); }
TMPL inline bool operator <= (const Instance& x, const int& i) {
  return x <= promote (i, x); }
TMPL inline bool operator >= (const Instance& x, const int& i) {
  return x >= promote (i, x); }

/******************************************************************************
* Local change of the current dynamic type
******************************************************************************/

TMPL
class local_instance_type {
  Cat Old;
public:
  inline local_instance_type (const Cat& New):
    Old (Instance::Cur) { Instance::Cur = New; }
  inline ~local_instance_type () {
    Instance::Cur = Old; }
};

#undef TMPL
#undef Instance
} // namespace mmx
#endif // __MMX__INSTANCE__HPP

---