/* Copyright (c) 1997-2010
   Ewgenij Gawrilow, Michael Joswig (Technische Universitaet Darmstadt, Germany)
   http://www.polymake.de

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version: http://www.gnu.org/licenses/gpl.txt.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
--------------------------------------------------------------------------------
   $Project: polymake $$Id: wrappers.h 9991 2010-12-12 23:36:28Z gawrilow $
*/

#ifndef POLYMAKE_PERL_WRAPPERS_H
#define POLYMAKE_PERL_WRAPPERS_H

/* The following classes are designed to be used in the files automatically generated by polymake.
   If you use them in the manually written code, you are doing it on your own risk!

   The changes in syntax and contents must be concerted with the corresponding routines
   in the package Polymake::Core::CPlusPlus
*/

namespace pm { namespace perl {

template <typename Target>
struct access {
   typedef Target type;
   typedef Target return_type;
   typedef typename attrib<Target>::minus_const value_type;

   static return_type get(const Value& v)
   {
      return static_cast<Target>(v);
   }
};

template <typename Target>
struct access_canned<Target, true, true> {
   typedef Target type;
   typedef Target& return_type;
   typedef typename attrib<Target>::minus_const value_type;

   static return_type get(const Value& v)
   {
      if (const std::type_info *t=v.get_canned_typeinfo()) {
         if (*t==typeid(value_type))
            return v.get_canned<value_type>();

         if (wrapper_type conversion=type_cache<value_type>::get_conversion_constructor(v.sv)) {
            // it is a wrapper for new<T0>(T1), it expects the argument at stack[1]
            char fup;
            if (SV *ret=conversion(const_cast<SV**>(&v.sv)-1, &fup))
               return *reinterpret_cast<value_type*>(v.get_canned_value(ret));
            else
               throw exception();
         }
      }

      Value temp_can;
      value_type *value=new(temp_can.allocate_canned(type_cache<value_type>::force_descr())) value_type;
      v >> *value;
      const_cast<Value&>(v).sv=temp_can.get_temp();
      return *value;
   }
};

template <typename Target>
struct access_canned<Target, false, true> {
   typedef Target type;
   typedef Target& return_type;
   typedef typename attrib<Target>::minus_const value_type;

   static return_type get(const Value& v)
   {
      return v.get_canned<value_type>();
   }
};

template <typename Target, bool _try>
struct access_canned<Target, _try, false> {
   typedef typename inherit_const<typename Unwary<typename attrib<Target>::minus_const>::type, Target>::type type;
   typedef Target& return_type;

   static return_type get(const Value& v)
   {
      return wary(access_canned<type, _try, true>::get(v));
   }
};

template <typename Target>
struct access< TryCanned<Target> > : access_canned<Target, true> {};

template <typename Target>
struct access< Canned<Target> > : access_canned<Target, false> {};

template <typename Target>
struct access< Enum<Target> > {
   typedef const Target type;
   typedef Target return_type;
   typedef Target value_type;

   static return_type get(const Value& v)
   {
      return Target(v.enum_value());
   }
};

class FunctionBase {
protected:
   static
   int register_func(wrapper_type wrapper, const char *sig, size_t siglen, const char *file, size_t filelen, int line,
                     SV *arg_types, void *func_ptr, const char *func_ptr_type);

   static
   void register_disabled(const char *sig, size_t siglen, const char *file, size_t filelen, int line, SV *arg_types);

   static
   void add_rules(const char *file, int line, const char *text, ...);
};

class Function : protected FunctionBase {
public:
   template <typename Fptr, size_t filelen>
   Function(Fptr *fptr, const char (&file)[filelen], int line, const char* text)
   {
      const int i=register_func(&TypeListUtils<Fptr>::get_flags, 0, 0, file, filelen-1, line,
                                TypeListUtils<Fptr>::get_types(), (void*)fptr, typeid(type2type<Fptr>).name());
      add_rules(file,line,text,i);
   }
};

template <typename Wrapper>
class WrapperBase : protected FunctionBase {
public:
   template <size_t namelen, size_t filelen, typename first_arg> static
   void register_it(const char (&name)[namelen], const char (&file)[filelen], int line, first_arg arg0)
   {
      register_func(&Wrapper::call, name, namelen-1, file, filelen-1, line,
                    TypeListUtils<typename Wrapper::arg_list>::get_types(arg0), 0, 0);
   }
};

template <typename Typelist>
struct DisabledFunction : protected FunctionBase {
   template <size_t namelen, size_t filelen>
   DisabledFunction(const char (&name)[namelen], const char (&file)[filelen], int line)
   {
      register_disabled(name, namelen-1, file, filelen-1, line, TypeListUtils<Typelist>::get_types(0));
   }
};

template <typename T, bool _enable=!(has_trivial_destructor<T>::value || is_masquerade<T>::value)>
class Destroy {
   static void _do(T *dst)
   {
      dst->~T();
   }
public:
   static destructor_type func() { return reinterpret_cast<destructor_type>(&_do); }
};

template <typename T>
class Destroy<T, false> {
public:
   static destructor_type func() { return 0; }
};

template <typename T, bool _enable=(identical<T,typename object_traits<T>::persistent_type>::value && !is_masquerade<T>::value)>
class Copy {
   static void construct(void* place, const T* src)
   {
      new(place) T(*src);
   }
public:
   static copy_constructor_type func() { return reinterpret_cast<copy_constructor_type>(&construct); }
};

template <typename T>
class Copy<T, false> {
public:
   static copy_constructor_type func() { return NULL; }
};

template <typename T, bool _and_enable=true, bool _enable=_and_enable && is_mutable<T>::value>
class Assign {
   static void assign(T* dst, SV* sv, value_flags flags)
   {
      Value src(sv, flags);
      src >> *dst;
   }
public:
   static assignment_type func() { return reinterpret_cast<assignment_type>(&assign); }
};

template <typename T, bool _and_enable>
class Assign<T, _and_enable, false> {
public:
   static assignment_type func() { return NULL; }
};

template <typename T, bool _enable=is_printable<T>::value>
class ToString {
protected:
   static SV* to_string(const T* src)
   {
      Value ret;
      ostream my_stream(ret);
      PlainPrinter<> printer(my_stream);
      printer << *src;
      return ret.get_temp();
   }
public:
   static conv_to_SV_type func() { return reinterpret_cast<conv_to_SV_type>(&to_string); }
};

class Unprintable {
protected:
   static SV* to_string(const char*, const char*);
public:
   static conv_to_SV_type func() { return &to_string; }
};

template <typename T>
class ToString<T, false> : public Unprintable {};

template <typename T, typename _serialized=typename object_traits<T>::serialized>
class Serialized : public True {
protected:
   static const bool assign_via_serialized = is_mutable<T>::value && is_mutable<_serialized>::value &&
                                             !io_test::has_generic_input_operator<ValueInput<>,T>::value;

   static void _assign(T *dst, SV *sv, value_flags flags)
   {
      Value src(sv, flags);
      src >> object_traits<T>::serialize(*dst);
   }

   static SV* _conv(const T *src, const char *frame_upper_bound)
   {
      Value ret(value_flags(value_allow_non_persistent | value_read_only));
      ret.put(object_traits<T>::serialize(*src), 0, frame_upper_bound, 0);
      return ret.get_temp();
   }

   static assignment_type assign(False) { return Assign<T>::func(); }
   static assignment_type assign(True) { return reinterpret_cast<assignment_type>(&_assign); }
public:
   static assignment_type assign() { return assign(bool2type<assign_via_serialized>()); }
   static conv_to_SV_type conv() { return reinterpret_cast<conv_to_SV_type>(&_conv); }
   static provide_type provide() { return &type_cache<typename deref<_serialized>::type>::provide; }
};

template <typename Base, typename E, typename Params>
class Serialized<sparse_elem_proxy<Base,E,Params>, void> : public False {
protected:
   static SV* _conv(const sparse_elem_proxy<Base,E,Params> *src, const char*)
   {
      Value ret;
      ret << src->get();
      return ret.get_temp();
   }
public:
   static assignment_type assign() { return NULL; }
   static conv_to_SV_type conv() { return reinterpret_cast<conv_to_SV_type>(&_conv); }
   static provide_type provide() { return 0; }
};

template <typename T>
class Serialized<T, void> : public False {
public:
   static assignment_type assign() { return NULL; }
   static conv_to_SV_type conv() { return NULL; }
   static provide_type provide() { return 0; }
};

class ClassRegistratorBase {
protected:
   static
   SV* register_class(const char *name, size_t namelen, const char *file, size_t filelen, int line,
                      SV *someref,
                      const char *typeid_name, const char *const_typeid_name,
                      bool is_mutable, class_kind kind,
                      SV *vtbl_sv);

   static
   SV* create_builtin_vtbl(
      const std::type_info& type,
      size_t obj_size,
      int primitive_lvalue,
      copy_constructor_type copy_constructor,
      assignment_type assignment,
      destructor_type destructor
   );

   static
   SV* create_scalar_vtbl(
      const std::type_info& type,
      size_t obj_size,
      copy_constructor_type copy_constructor,
      assignment_type assignment,
      destructor_type destructor,
      conv_to_SV_type to_string,
      conv_to_SV_type to_serialized,
      conv_to_int_type to_int,
      conv_to_double_type to_double
   );

   static
   SV* create_iterator_vtbl(
      const std::type_info& type,
      size_t obj_size,
      copy_constructor_type copy_constructor,
      destructor_type destructor,
      iterator_deref_type deref,
      iterator_incr_type incr,
      conv_to_int_type at_end
   );

   static
   SV* create_opaque_vtbl(
      const std::type_info& type,
      size_t obj_size,
      assignment_type assignment,
      destructor_type destructor,
      conv_to_SV_type to_string,
      conv_to_SV_type to_serialized,
      provide_type provide_serialized_type
   );

   static
   SV* create_container_vtbl(
      const std::type_info& type,
      size_t obj_size, int total_dimension, int own_dimension,
      copy_constructor_type copy_constructor,
      assignment_type assignment,
      destructor_type destructor,
      conv_to_SV_type to_string,
      conv_to_int_type size,
      container_resize_type resize,
      container_store_type store_at_ref,
      provide_type provide_key_type,
      provide_type provide_value_type
   );

   static
   void fill_iterator_access_vtbl(
      SV *vtbl, int i,
      size_t it_size, size_t cit_size,
      destructor_type it_destructor,
      destructor_type cit_destructor,
      container_begin_type begin,
      container_begin_type cbegin,
      container_access_type deref,
      container_access_type cderef
   );

   static
   void fill_random_access_vtbl(
      SV *vtbl,
      container_access_type random,
      container_access_type crandom
   );

   static
   SV* create_composite_vtbl(
      const std::type_info& type,
      size_t obj_size, int obj_dimension,
      copy_constructor_type copy_constructor,
      assignment_type assignment,
      destructor_type destructor,
      conv_to_SV_type to_string,
      provide_type provide_elem_types,
      int n_elems,
      void (*fill)(composite_access_vtbl*)
   );
};

template <typename T>
class Builtin : protected ClassRegistratorBase {
protected:
   static const bool is_assignable=io_test::has_std_input_operator<T>::value;
public:
   static
   SV* register_it(const char *name, size_t namelen, const char* file=0, size_t filelen=0, int line=0)
   {
      const char* const typeid_name=typeid(T).name();
      return register_class(
         name, namelen, file, filelen, line,
         NULL,
         typeid_name, typeid_name,
         false, class_is_scalar,
         create_builtin_vtbl(
            typeid(T), sizeof(T), list_contains<primitive_lvalues,T>::value,
            Copy<T>::func(),
            Assign<T, is_assignable>::func(),
            Destroy<T>::func()
         )
      );
   }

   template <size_t namelen, size_t filelen>
   Builtin(const char (&name)[namelen], const char (&file)[filelen], int line)
   {
      register_it(name, namelen-1, file, filelen-1, line);
   }
};

template <typename T, typename Model=typename object_traits<T>::model>
class ClassRegistrator;

template <>
class ClassRegistrator<Scalar,is_opaque> {};
template <>
class ClassRegistrator<Array,is_container> {};

template <typename T>
class ClassRegistrator<T, is_scalar> : protected ClassRegistratorBase {
protected:
   template <typename Target>
   struct do_conv {
      static Target func(const T* obj)
      {
         conv<T,Target> c;
         return c(*obj);
      }
   };
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(typename const_equivalent<T>::type).name(),
         is_mutable<T>::value,
         class_is_scalar,
         create_scalar_vtbl(
            typeid(T), sizeof(T),
            Copy<T>::func(),
            Assign<T>::func(),
            Destroy<T>::func(),
            ToString<T>::func(),
            Serialized<T>::conv(),
            reinterpret_cast<conv_to_int_type>(&do_conv<int>::func),
            reinterpret_cast<conv_to_double_type>(&do_conv<double>::func)
         )
      );
   }
};

template <typename T, bool _is_iterator=check_iterator_feature<T,end_sensitive>::value>
class OpaqueClassRegistrator : protected ClassRegistratorBase {
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(typename const_equivalent<T>::type).name(),
         is_mutable<T>::value,
         Serialized<T>::value ? class_kind(class_is_opaque | class_is_serializable) : class_is_opaque,
         create_opaque_vtbl(
            typeid(T), sizeof(T),
            Serialized<T>::assign(),
            Destroy<T>::func(),
            ToString<T>::func(),
            Serialized<T>::conv(),
            Serialized<T>::provide()
         )
      );
   }
};

template <typename T>
class OpaqueClassRegistrator<T, true> : protected ClassRegistratorBase {
protected:
   static const bool read_only=attrib<typename iterator_traits<T>::reference>::is_const;

   static SV* deref(const T* it, const char *frame_upper_bound)
   {
      Value ret(value_flags(read_only ? value_expect_lval | value_allow_non_persistent | value_read_only
                                      : value_expect_lval | value_allow_non_persistent));
      ret.put_lval(**it, 0, frame_upper_bound, 0);
      return ret.get_temp();
   }

   static void incr(T* it)
   {
      ++(*it);
   }

   static int at_end(const T* it)
   {
      return it->at_end();
   }
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(T).name(),
         true,
         class_is_opaque,
         create_iterator_vtbl(
            typeid(T), sizeof(T),
            Copy<T>::func(),
            Destroy<T>::func(),
            reinterpret_cast<iterator_deref_type>(&deref),
            reinterpret_cast<iterator_incr_type>(&incr),
            reinterpret_cast<conv_to_int_type>(&at_end)
         )
      );
   }
};

template <typename T>
class ClassRegistrator<T, is_opaque>
   : public OpaqueClassRegistrator<T> {};

template <typename T, bool _enabled=true, bool _is_mutable=!object_traits<T>::is_always_const>
struct input_mode : io_test::input_mode<T,false> {};

template <typename T, bool _is_mutable>
struct input_mode<T,false,_is_mutable> {
   typedef False type;
};

template <typename T, bool _enabled>
struct input_mode<T,_enabled,false> {
   typedef False type;
};

template <typename T, typename Category=typename container_traits<typename serialized_of<T>::type>::category,
          bool _obscure=serialized_of<T>::obscure>
class ContainerClassRegistrator : protected ClassRegistratorBase {
public:
   typedef serialized_of<T> helper;
   typedef typename helper::type Obj;
   static const bool
        is_associative=is_assoc_container<Obj>::value,
             is_sparse=check_container_feature<Obj,sparse>::value,
      is_sparse_native=check_container_feature<T,sparse>::value ||
                       io_test::unknown_columns<T>::value==0,   // enforce the cols= attribute in XML representation
              like_set=list_contains< list(is_set, is_unordered_set), typename object_traits<Obj>::generic_tag>::value;
   typedef typename if_else<is_associative, end_sensitive, void>::type iterator_feature;
   typedef typename ensure_features<Obj, iterator_feature>::iterator iterator;
   typedef typename ensure_features<Obj, iterator_feature>::const_iterator const_iterator;

   static const bool allow_non_const_access= !object_traits<T>::is_always_const &&
                                             !identical<iterator,const_iterator>::value &&
                                             !attrib<typename iterator_traits<iterator>::reference>::is_const &&
                                             !object_traits<typename iterator_traits<iterator>::value_type>::is_always_const;

   typedef bool2type<allow_non_const_access> non_const_access;
protected:
   static int do_size(const T* obj)
   {
      return helper::serialize(*obj).size();
   }

   static int dim(const T* obj)
   {
      return helper::serialize(*obj).dim();
   }

   static void _resize(T* obj, int n)
   {
      helper::serialize(*obj).resize(n);
   }

   static void fixed_size(T* obj, int n)
   {
      if (get_dim(helper::serialize(*obj)) != n)
         throw std::runtime_error("size mismatch");
   }

   static void clear_by_resize(T* obj, int)
   {
      helper::serialize(*obj).clear();
   }

   template <typename E>
   static void check_insertion(const Obj&, const E&, False) {}

   static void check_insertion(const Obj& obj, int x, True)
   {
      if (x<0 || x>=obj.dim())
         throw std::runtime_error("element out of range");
   }

   static void push_back(T *obj, iterator *it, int, SV *src)
   {
      Value v(src);
      typename Obj::value_type x;
      v >> x;
      check_insertion(helper::serialize(*obj), x,
                      bool2type<check_container_feature<Obj,sparse_compatible>::value>());
      helper::serialize(*obj).insert(*it, x);
   }

   static void insert(T *obj, iterator*, int, SV *src)
   {
      Value v(src);
      typename item4insertion<typename Obj::value_type>::type x;
      v >> x;
      check_insertion(helper::serialize(*obj), x,
                      bool2type<check_container_feature<Obj,sparse_compatible>::value>());
      helper::serialize(*obj).insert(x);
   }

   static void store_dense(T*, iterator *it, int, SV *src)
   {
      Value v(src, value_not_trusted);
      v >> non_const(**it);
      ++(*it);
   }

   static void store_sparse(T *obj, iterator *it, int index, SV *src)
   {
      Value v(src, value_not_trusted);
      typename Obj::value_type x;
      v >> x;
      conv<typename Obj::value_type, bool> non_zero;
      if (non_zero(x)) {
         if (!it->at_end() && it->index()==index) {
            **it=x; ++(*it);
         } else {
            helper::serialize(*obj).insert(*it,index,x);
         }
      } else {
         if (!it->at_end() && it->index()==index)
            helper::serialize(*obj).erase((*it)++);
      }
   }

   template <typename Iterator, bool non_const>
   struct do_it {
      typedef typename assign_const<T, !non_const>::type* ObjPtr;

      static void begin(void *it_place, ObjPtr obj)
      {
         new(it_place) Iterator(ensure(helper::serialize(*obj), (iterator_feature*)0).begin());
      }

      static void rbegin(void *it_place, ObjPtr obj)
      {
         new(it_place) Iterator(ensure(helper::serialize(*obj), (iterator_feature*)0).rbegin());
      }

      static void deref(ObjPtr, Iterator *it, int, SV *dst, const char *frame_upper_bound)
      {
         Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent | (non_const ? 0 : value_read_only)));
         pv.put_lval(**it, 0, frame_upper_bound, 0);
         ++(*it);
      }

      static void deref_pair(ObjPtr, Iterator *it, int i, SV *dst, const char *frame_upper_bound)
      {
         if (i<=0) {
            // i==-1: FIRSTKEY;  i==0: NEXTKEY
            if (i==0) ++(*it);
            if (!it->at_end()) {
               Value pv(dst, value_flags(value_read_only | value_allow_non_persistent));
               pv.put((*it)->first, 0, frame_upper_bound, 0);
            }
         } else {
            // i==1: fetch value
            Value pv(dst, value_flags(value_allow_non_persistent | (non_const ? 0 : value_read_only)));
            pv.put((*it)->second, 0, frame_upper_bound, 0);
         }
      }
   };

   template <typename Iterator>
   struct do_sparse {
      static void deref(T *obj, Iterator *it, int index, SV *dst, const char*)
      {
         Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent));
         sparse_elem_proxy< sparse_proxy_it_base<Obj,Iterator>, typename Obj::value_type, typename Obj::reference::parameters >
            x(sparse_proxy_it_base<Obj,Iterator>(helper::serialize(*obj), *it, index));
         if (x.exists()) ++(*it);
         pv.put(x,0,0,0);
      }
   };

   template <typename Iterator>
   struct do_const_sparse {
      static void deref(const T*, Iterator *it, int index, SV *dst, const char* frame_upper_bound)
      {
         Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent | value_read_only));
         if (!it->at_end() && index==it->index()) {
            pv.put_lval(**it, 0, frame_upper_bound, 0);
            ++(*it);
         } else {
            operations::clear<typename Obj::value_type> zero;
            pv.put_lval(zero(), 0, frame_upper_bound, 0);
         }
      }
   };

   static conv_to_int_type size(False) { return reinterpret_cast<conv_to_int_type>(&do_size); }
   static conv_to_int_type size(True)  { return reinterpret_cast<conv_to_int_type>(&dim); }

   static container_resize_type resize(io_test::as_list<Obj>)
   {
      return reinterpret_cast<container_resize_type>(&clear_by_resize);
   }
   static container_resize_type resize(io_test::as_set)
   {
      return reinterpret_cast<container_resize_type>(&clear_by_resize);
   }
   template <bool _allow_sparse>
   static container_resize_type resize(io_test::as_array<1,_allow_sparse>)
   {
      return reinterpret_cast<container_resize_type>(&_resize);
   }
   template <bool _allow_sparse>
   static container_resize_type resize(io_test::as_array<0,_allow_sparse>)
   {
      return reinterpret_cast<container_resize_type>(&fixed_size);
   }
   static container_resize_type resize(io_test::as_sparse<-1>) { return NULL; }
   static container_resize_type resize(False) { return NULL; }

   static container_store_type store_at_ref(io_test::as_list<Obj>)
   {
      return reinterpret_cast<container_store_type>(&push_back);
   }
   static container_store_type store_at_ref(io_test::as_set)
   {
      return reinterpret_cast<container_store_type>(&insert);
   }
   template <int _resizeable, bool _allow_sparse>
   static container_store_type store_at_ref(io_test::as_array<_resizeable, _allow_sparse>)
   {
      return reinterpret_cast<container_store_type>(&store_dense);
   }
   template <int _resizeable>
   static container_store_type store_at_ref(io_test::as_sparse<_resizeable>)
   {
      return reinterpret_cast<container_store_type>(&store_sparse);
   }
   static container_store_type store_at_ref(False) { return NULL; }

   static destructor_type it_destructor(True) { return Destroy<iterator>::func(); }
   static destructor_type it_destructor(False) { return Destroy<const_iterator>::func(); }

   static container_begin_type begin(True)
   {
      return reinterpret_cast<container_begin_type>(&do_it<iterator, true>::begin);
   }
   static container_begin_type begin(False)
   {
      return reinterpret_cast<container_begin_type>(&do_it<const_iterator, false>::begin);
   }

   static container_access_type deref(False,False,True)
   {
      return reinterpret_cast<container_access_type>(&do_it<iterator, true>::deref);
   }
   static container_access_type deref(False,False,False)
   {
      return reinterpret_cast<container_access_type>(&do_it<const_iterator, false>::deref);
   }
   static container_access_type deref(True,False,True)
   {
      return reinterpret_cast<container_access_type>(&do_it<iterator, true>::deref_pair);
   }
   static container_access_type deref(True,False,False)
   {
      return reinterpret_cast<container_access_type>(&do_it<const_iterator, false>::deref_pair);
   }
   static container_access_type deref(False,True,True)
   {
      return reinterpret_cast<container_access_type>(&do_sparse<iterator>::deref);
   }
   static container_access_type deref(False,True,False)
   {
      return reinterpret_cast<container_access_type>(&do_const_sparse<const_iterator>::deref);
   }

   static provide_type provide_key_type(True)
   {
      return &type_cache<typename T::key_type>::provide;
   }
   static provide_type provide_key_type(False)
   {
      return &type_cache<typename object_traits<typename T::value_type>::persistent_type>::provide;
   }
   static provide_type provide_value_type(True)
   {
      return &type_cache<typename T::mapped_type>::provide;
   }
   static provide_type provide_value_type(False)
   {
      return &type_cache<typename object_traits<typename Obj::value_type>::persistent_type>::provide;
   }

   static SV* create_vtbl()
   {
      SV *vtbl=create_container_vtbl(
         typeid(T), sizeof(T),
         object_traits<T>::total_dimension, object_traits<T>::dimension,
         Copy<T>::func(),
         Assign<T>::func(),
         Destroy<T>::func(),
         ToString<T>::func(),
         size(bool2type<is_sparse>()),
         resize(typename input_mode<Obj>::type()),
         store_at_ref(typename input_mode<Obj, !is_associative>::type()),
         provide_key_type(bool2type<is_associative>()),
         provide_value_type(bool2type<is_associative>())
      );
      fill_iterator_access_vtbl(
         vtbl, 0,
         sizeof(iterator), sizeof(const_iterator),
         it_destructor(non_const_access()),
         it_destructor(False()),
         begin(non_const_access()),
         begin(False()),
         deref(bool2type<is_associative>(), bool2type<is_sparse>(), non_const_access()),
         deref(bool2type<is_associative>(), bool2type<is_sparse>(), False())
      );
      return vtbl;
   }

   static SV* register_me(const char* name, size_t namelen, const char* file, size_t filelen, int line, SV *someref, SV *vtbl)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(typename const_equivalent<T>::type).name(),
         is_mutable<T>::value,
         is_associative   ? class_kind(class_is_container | class_is_assoc_container) :
         is_sparse_native ? class_kind(class_is_container | class_is_sparse_container) :
         like_set         ? class_kind(class_is_container | class_is_set)
                          : class_is_container,
         vtbl);
   }

public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_me(name, namelen, file, filelen, line, someref, create_vtbl());
   }
};

template <typename T>
class ContainerClassRegistrator<T, bidirectional_iterator_tag, false>
   : public ContainerClassRegistrator<T, forward_iterator_tag, false> {
   typedef ContainerClassRegistrator<T, forward_iterator_tag, false> super;
public:
   typedef typename super::Obj::reverse_iterator reverse_iterator;
   typedef typename super::Obj::const_reverse_iterator const_reverse_iterator;
protected:
   static container_begin_type rbegin(True)
   {
      return reinterpret_cast<container_begin_type>(&super::template do_it<reverse_iterator, true>::rbegin);
   }
   static container_begin_type rbegin(False)
   {
      return reinterpret_cast<container_begin_type>(&super::template do_it<const_reverse_iterator, false>::rbegin);
   }

   static container_access_type rderef(False,True)
   {
      return reinterpret_cast<container_access_type>(&super::template do_it<reverse_iterator, true>::deref);
   }
   static container_access_type rderef(False,False)
   {
      return reinterpret_cast<container_access_type>(&super::template do_it<const_reverse_iterator, false>::deref);
   }
   static container_access_type rderef(True,True)
   {
      return reinterpret_cast<container_access_type>(&super::template do_sparse<reverse_iterator>::deref);
   }
   static container_access_type rderef(True,False)
   {
      return reinterpret_cast<container_access_type>(&super::template do_const_sparse<const_reverse_iterator>::deref);
   }

   static destructor_type rit_destructor(True) { return Destroy<reverse_iterator>::func(); }
   static destructor_type rit_destructor(False) { return Destroy<const_reverse_iterator>::func(); }
public:
   static SV* create_vtbl(False)
   {
      SV *vtbl=super::create_vtbl();
      super::fill_iterator_access_vtbl(
         vtbl, 2,
         sizeof(reverse_iterator), sizeof(const_reverse_iterator),
         rit_destructor(typename super::non_const_access()),
         rit_destructor(False()),
         rbegin(typename super::non_const_access()),
         rbegin(False()),
         rderef(bool2type<super::is_sparse>(), typename super::non_const_access()),
         rderef(bool2type<super::is_sparse>(), False())
      );
      return vtbl;
   }

   static SV* create_vtbl(True)
   {
      return super::create_vtbl();
   }
   static SV* create_vtbl()
   {
      return create_vtbl(bool2type<super::is_associative>());
   }
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return super::register_me(name, namelen, file, filelen, line, someref, create_vtbl());
   }
};

template <typename T>
class ContainerClassRegistrator<T, random_access_iterator_tag, false>
   : public ContainerClassRegistrator<T, bidirectional_iterator_tag, false> {
   typedef ContainerClassRegistrator<T, bidirectional_iterator_tag, false> super;
protected:
   static void _random(T *obj, char*, int index, SV *dst, const char *frame_upper_bound)
   {
      index=index_within_range(serialized_of<T>::serialize(*obj), index);
      Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent));
      pv.put_lval(serialized_of<T>::serialize(*obj)[index], 0, frame_upper_bound, 0);
   }

   static void crandom(const T *obj, char*, int index, SV *dst, const char *frame_upper_bound)
   {
      index=index_within_range(serialized_of<T>::serialize(*obj), index);
      Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent | value_read_only));
      pv.put_lval(serialized_of<T>::serialize(*obj)[index], 0, frame_upper_bound, 0);
   }

   static void random_sparse(T *obj, char*, int index, SV *dst, const char*)
   {
      index=index_within_range(serialized_of<T>::serialize(*obj), index);
      Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent));
      pv.put(super::helper::serialize(*obj)[index],0,0,0);
   }

   static container_access_type random(False, True)
   {
      return reinterpret_cast<container_access_type>(&_random);
   }
   static container_access_type random(True, True)
   {
      return reinterpret_cast<container_access_type>(&random_sparse);
   }
   template <typename _is_sparse>
   static container_access_type random(_is_sparse, False)
   {
      return reinterpret_cast<container_access_type>(&crandom);
   }
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      SV *vtbl=super::create_vtbl();
      super::fill_random_access_vtbl(
         vtbl,
         random(bool2type<super::is_sparse>(), typename super::non_const_access()),
         random(bool2type<super::is_sparse>(), False())
      );
      return super::register_me(name, namelen, file, filelen, line, someref, vtbl);
   }
};

template <typename T, typename Category>
class ContainerClassRegistrator<T, Category, true> : protected ClassRegistratorBase {
public:
   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(T).name(),
         false, class_is_opaque,
         create_builtin_vtbl(
            typeid(T), sizeof(T),
            0, 0, 0, Destroy<T>::func()
         )
      );
   }
};

template <typename T>
class ClassRegistrator<T, is_container>
   : public ContainerClassRegistrator<T> {};

template <typename T, int n=0, int l=list_length<typename object_traits<T>::elements>::value>
struct CompositeClassRegistrator {
   typedef typename n_th<typename object_traits<T>::elements, n>::type member_type;
   static const bool allow_non_const_access = !attrib<member_type>::is_const &&
                                              !object_traits<typename deref<member_type>::type>::is_always_const;

   static void _get(T *obj, SV *dst, const char *frame_upper_bound)
   {
      Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent));
      pv.put_lval(visit_n_th(serialized_of<T>::serialize(*obj), int2type<n>()), 0, frame_upper_bound, 0);
   }

   static void cget(const T *obj, SV *dst, const char *frame_upper_bound)
   {
      Value pv(dst, value_flags(value_expect_lval | value_allow_non_persistent | value_read_only));
      pv.put_lval(visit_n_th(serialized_of<T>::serialize(*obj), int2type<n>()), 0, frame_upper_bound, 0);
   }

   static void _store(T *obj, SV *src)
   {
      Value v(src, value_not_trusted);
      v >> visit_n_th(serialized_of<T>::serialize(*obj), int2type<n>());
   }

   static composite_access_type get(True)  { return reinterpret_cast<composite_access_type>(&_get); }
   static composite_access_type get(False) { return reinterpret_cast<composite_access_type>(&cget); }
   static composite_store_type store(True)  { return reinterpret_cast<composite_store_type>(&_store); }
   static composite_store_type store(False) { return NULL; }

   static void init(composite_access_vtbl *acct)
   {
      acct->get[0]=get(bool2type<allow_non_const_access>());
      acct->get[1]=get(False());
      acct->store=store(bool2type<allow_non_const_access>());
      CompositeClassRegistrator<T,n+1,l>::init(++acct);
   }
};

template <typename T, int l>
struct CompositeClassRegistrator<T,l,l> {
   static void init(composite_access_vtbl*) {}
};

template <typename T>
struct get_persistent_type {
   typedef typename object_traits<T>::persistent_type type;
};

template <typename T>
class ClassRegistrator<T, is_composite> : protected ClassRegistratorBase {
public:
   typedef typename list_transform_unary<get_persistent_type, typename object_traits<T>::elements>::type elements;

   static SV* register_it(const char* name, size_t namelen, SV *someref, const char* file=0, size_t filelen=0, int line=0)
   {
      return register_class(
         name, namelen, file, filelen, line, someref,
         typeid(T).name(), typeid(typename const_equivalent<T>::type).name(),
         is_mutable<T>::value,
         class_is_composite,
         create_composite_vtbl(
            typeid(T), sizeof(T), object_traits<T>::total_dimension,
            Copy<T>::func(),
            Assign<T>::func(),
            Destroy<T>::func(),
            ToString<T>::func(),
            &TypeListUtils<elements>::provide,
            list_length<elements>::value,
            &CompositeClassRegistrator<T>::init
         )
      );
   }
};

} }
namespace polymake { namespace perl_bindings {

template <typename T>
class Class : public pm::perl::ClassRegistrator<T> {
public:
   template <size_t namelen, size_t filelen>
   Class(const char (&name)[namelen], const char (&file)[filelen], int line)
   {
      pm::perl::ClassRegistrator<T>::register_it(name, namelen-1, 0, file, filelen-1, line);
   }
};

} }
namespace pm { namespace perl {

class ClassTemplate {
private:
   static void register_class(const char *name, size_t l);
public:
   ClassTemplate(const char *name, size_t l)
   {
      register_class(name,l);
   }

   template <size_t nl>
   ClassTemplate(const char (&name)[nl])
   {
      register_class(name,nl-1);
   }
};

SV* get_parameterized_type(const char *pkg, size_t pkgl, bool exact_match);

template <typename TypeList, size_t pkgl, bool exact_match> inline
SV* get_parameterized_type(const char (&pkg)[pkgl], bool2type<exact_match>)
{
   Stack stack(true, 1+TypeListUtils<TypeList>::type_cnt);
   if (TypeListUtils<TypeList>::push_types(stack)) {
      return get_parameterized_type(pkg, pkgl-1, exact_match);
   } else {
      stack.cancel();
      return NULL;
   }
}

class EmbeddedRule {
protected:
   EmbeddedRule() {}

   static
   void add(const char *file, int line, const char *text, size_t l);
public:
   template <size_t l>
   EmbeddedRule(const char *file, int line, const char (&text)[l])
   {
      add(file,line,text,l-1);
   }
};

class EmbeddedPropertyBase {
protected:
   static
   void register_type(const char *name, size_t namelen,
                      wrapper_type wrapper, const char *file, size_t filelen);
};

template <typename T>
class EmbeddedPropertyType : protected type_cache<T>, protected EmbeddedPropertyBase {
protected:
   // stack[0] is the function wrapper descriptor, the interesting arguments start at [1]
   static SV* register_it(SV **stack, char*)
   {
      ArrayHolder ret(2);
      type_infos ti;
      ti.descr=ClassRegistrator<T>::register_it(0,1,stack[1]);
      ti.set_proto(stack[1]);
      ti.magic_allowed=true;
      type_cache<T>::get(&ti);

      SV *super=NULL;
      recognize(&super, recognizer_bait(0), (T*)0, (T*)0);
      ret.push(super ? super : Scalar::undef());
      ret.push(field_names(recognizer_bait(0), (T*)0));
      return ret.get_temp();
   }
public:
   template <size_t namelen, size_t filelen>
   EmbeddedPropertyType(const char (&name)[namelen], const char (&file)[filelen])
   {
      register_type(name, namelen-1, &register_it, file, filelen-1);
   }
};

template <typename Source, typename Target>
struct assignable_to : pm::assignable_to<typename access<Source>::type, Target> {};

template <typename Source, typename Target,
          bool _implicitly=pm::convertible_to<typename access<Source>::type, Target>::value,
          bool _isomorphic=isomorphic_types<typename access<Source>::value_type, Target>::value &&
                           assignable_to<Source,Target>::value,
          typename discr=typename isomorphic_types<typename access<Source>::value_type, Target>::discriminant>
struct convertible_to : bool2type<_implicitly> {};

// two isomorphic types belong to the same generic family and assignable:
// there is a good chance to have an explicit conversion constructor too
template <typename Source, typename Target, typename Tag>
struct convertible_to<Source, Target, false, true, cons<Tag,Tag> > : True {};

template <typename Target, typename Source, bool _enabled=assignable_to<Source,Target>::value>
struct Operator_assign : protected FunctionBase {
   typedef cons<Target,Source> arg_list;

   static void call(Target& dst, const Value& src)
   {
      if (MaybeWary<Target>::value && (src.get_flags() & value_not_trusted))
         maybe_wary(dst)=src.get<Source>();
      else
         dst=src.get<Source>();
   }

   template <size_t filelen>
   Operator_assign(const char (&file)[filelen], int line, int=0)
   {
      register_func(reinterpret_cast<wrapper_type>(&call),
                    "=ass", 4, file, filelen-1, line, TypeListUtils<arg_list>::get_types(), 0, 0);
   }
};

template <typename Target, typename Source>
struct Operator_assign<Target, Source, false> : protected FunctionBase {
   typedef cons<Target,Source> arg_list;

   template <size_t filelen>
   Operator_assign(const char (&file)[filelen], int line, int=0)
   {
      register_disabled("=ass", 4, file, filelen-1, line, TypeListUtils<arg_list>::get_types());
   }
};

template <typename Target, typename Source, bool _enabled=convertible_to<Source,Target>::value>
struct Operator_convert : protected FunctionBase {
   typedef cons<Target,Source> arg_list;

   static Target call(const Value& src)
   {
      return Target(src.get<Source>());
   }

   template <size_t filelen>
   Operator_convert(const char (&file)[filelen], int line, int=0)
   {
      register_func(reinterpret_cast<wrapper_type>(&call),
                    ".cnv", 4, file, filelen-1, line, TypeListUtils<arg_list>::get_types(), 0, 0);
   }
};

template <typename Target, typename Source>
struct Operator_convert<Target, Source, false> : protected FunctionBase {
   typedef cons<Target,Source> arg_list;

   template <size_t filelen>
   Operator_convert(const char (&file)[filelen], int line, int=0)
   {
      register_disabled(".cnv", 4, file, filelen-1, line, TypeListUtils<arg_list>::get_types());
   }
};

Wrapper4UnaryOperator(-, neg);
Wrapper4UnaryOperator(!, not);
Wrapper4UnaryOperator(~, com);
Wrapper4UnaryOperator(static_cast<bool>, boo);

Wrapper4BinaryOperator(+, add);
Wrapper4BinaryOperator(-, sub);
Wrapper4BinaryOperator(*, mul);
Wrapper4BinaryOperator(/, div);
Wrapper4BinaryOperator(%, mod);
Wrapper4BinaryOperator(&, and);
Wrapper4BinaryOperator(|, _or);
Wrapper4BinaryOperator(^, xor);
Wrapper4BinaryOperator(<<, lsh);
Wrapper4BinaryOperator(>>, rsh);

Wrapper4UnaryAssignOperator(++, inc);
Wrapper4UnaryAssignOperator(--, dec);

Wrapper4BinaryAssignOperator(+=, add);
Wrapper4BinaryAssignOperator(-=, sub);
Wrapper4BinaryAssignOperator(*=, mul);
Wrapper4BinaryAssignOperator(/=, div);
Wrapper4BinaryAssignOperator(%=, mod);
Wrapper4BinaryAssignOperator(&=, and);
Wrapper4BinaryAssignOperator(|=, _or);
Wrapper4BinaryAssignOperator(^=, xor);
Wrapper4BinaryAssignOperator(<<=, lsh);
Wrapper4BinaryAssignOperator(>>=, rsh);

Wrapper4BinaryOperator(==, _eq);
Wrapper4BinaryOperator(!=, _ne);
Wrapper4BinaryOperator(<, _lt);
Wrapper4BinaryOperator(<=, _le);
Wrapper4BinaryOperator(>, _gt);
Wrapper4BinaryOperator(>=, _ge);

template <typename Arg0, typename Arg1>
WrapperStart( Operator_Binary_brk, ":brk", Arg0,Arg1 ) {
   Value arg0(stack[0]), arg1(stack[1]);
   WrapperReturnLvalue( Arg0, arg0.get<Arg0>() [ arg1.get<Arg1>() ] );
};

} }

#endif // POLYMAKE_PERL_WRAPPERS_H

// Local Variables:
// mode:C++
// c-basic-offset:3
// indent-tabs-mode:nil
// End:
