swig Namespace Reference


Classes

class  SwigPtr_PyObject
struct  SwigVar_PyObject
struct  stop_iteration
struct  SwigPyIterator
struct  noconst_traits
struct  noconst_traits< const Type >
struct  pointer_category
struct  value_category
struct  traits
struct  traits_info
struct  traits< Type * >
struct  traits_as
struct  traits_check
struct  traits_from_ptr
struct  traits_from
struct  traits_from< Type * >
struct  traits_from< const Type * >
struct  traits_asptr
struct  traits_asval
struct  traits_asval< Type * >
struct  traits_as< Type, value_category >
struct  traits_as< Type, pointer_category >
struct  traits_as< Type *, pointer_category >
struct  traits_check< Type, value_category >
struct  traits_check< Type, pointer_category >
struct  traits< PyObject * >
struct  traits_asval< PyObject * >
struct  traits_check< PyObject *, value_category >
struct  traits_from< PyObject * >
class  SwigPyIterator_T
struct  from_oper
class  SwigPyIteratorOpen_T
class  SwigPyIteratorClosed_T
struct  SwigPySequence_Ref
struct  SwigPySequence_ArrowProxy
struct  SwigPySequence_InputIterator
struct  SwigPySequence_Cont
struct  traits< GiNaC::ex >
struct  traits_asptr_stdseq
struct  traits_from_stdseq
struct  traits_asptr< std::vector< T > >
struct  traits_from< std::vector< T > >
struct  traits< std::vector< GiNaC::ex, std::allocator< GiNaC::ex > > >
struct  traits_asptr< std::pair< T, U > >
struct  traits_from< std::pair< T, U > >
struct  traits< std::pair< GiNaC::ex, GiNaC::ex > >
struct  traits_asptr< std::map< K, T > >
struct  traits_from< std::map< K, T > >
struct  from_key_oper
struct  from_value_oper
struct  SwigPyMapIterator_T
struct  SwigPyMapKeyIterator_T
struct  SwigPyMapValueITerator_T
struct  traits< std::map< GiNaC::ex, GiNaC::ex, GiNaC::ex_is_less, std::allocator< std::pair< GiNaC::ex const, GiNaC::ex > > > >
struct  traits< int >
struct  traits_asval< int >
struct  traits_from< int >
struct  traits< std::pair< GiNaC::ex, int > >
struct  traits< std::map< GiNaC::ex, int, GiNaC::ex_is_less, std::allocator< std::pair< GiNaC::ex const, int > > > >
struct  traits< GiNaC::symbol >
struct  traits< std::pair< GiNaC::symbol, GiNaC::ex > >
struct  traits_asptr< std::list< T > >
struct  traits_from< std::list< T > >
struct  traits< std::list< std::pair< GiNaC::symbol, GiNaC::ex >, std::allocator< std::pair< GiNaC::symbol, GiNaC::ex > > > >
struct  traits< std::list< GiNaC::ex, std::allocator< GiNaC::ex > > >
struct  traits_asptr< std::set< T > >
struct  traits_from< std::set< T > >
struct  traits< std::set< GiNaC::ex, GiNaC::ex_is_less, std::allocator< GiNaC::ex > > >

Functions

template<class Type >
const char * type_name ()
template<class Type >
swig_type_infotype_info ()
template<class Type >
PyObject * from (const Type &val)
template<class Type >
PyObject * from_ptr (Type *val, int owner)
template<class Type >
int asptr (PyObject *obj, Type **vptr)
template<class Type >
int asval (PyObject *obj, Type *val)
template<class Type >
Type as (PyObject *obj, bool te=false)
template<class Type >
bool check (PyObject *obj)
size_t check_index (ptrdiff_t i, size_t size, bool insert=false)
size_t slice_index (ptrdiff_t i, size_t size)
template<class Sequence , class Difference >
Sequence::iterator getpos (Sequence *self, Difference i)
template<class Sequence , class Difference >
Sequence::const_iterator cgetpos (const Sequence *self, Difference i)
template<class Sequence , class Difference >
Sequence * getslice (const Sequence *self, Difference i, Difference j)
template<class Sequence , class Difference , class InputSeq >
void setslice (Sequence *self, Difference i, Difference j, const InputSeq &v)
template<class Sequence , class Difference >
void delslice (Sequence *self, Difference i, Difference j)
template<typename OutIter >
SwigPyIteratormake_output_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)
template<typename OutIter >
SwigPyIteratormake_output_iterator (const OutIter &current, PyObject *seq=0)
template<class SwigPySeq , class Seq >
void assign (const SwigPySeq &swigpyseq, Seq *seq)
template<class SwigPySeq , class K , class T >
void assign (const SwigPySeq &swigpyseq, std::map< K, T > *map)
template<typename OutIter >
SwigPyIteratormake_output_key_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)
template<typename OutIter >
SwigPyIteratormake_output_value_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)
template<class SwigPySeq , class T >
void assign (const SwigPySeq &swigpyseq, std::set< T > *seq)

Function Documentation

template<class Type >
Type swig::as ( PyObject *  obj,
bool  te = false 
) [inline]

Definition at line 3736 of file SyFi_wrap.cc.

03736                                                  {
03737     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
03738   }

template<class Type >
int swig::asptr ( PyObject *  obj,
Type **  vptr 
) [inline]

Definition at line 3628 of file SyFi_wrap.cc.

References swig::traits_asptr< Type >::asptr().

Referenced by _wrap_ex_int_map_erase(), _wrap_exlist___delitem__(), _wrap_exlist___getitem__(), _wrap_exlist___setitem__(), _wrap_exlist___setitem____SWIG_0(), _wrap_exlist___setslice__(), _wrap_exlist_erase(), _wrap_exlist_insert(), _wrap_exlist_resize(), _wrap_exmap_erase(), _wrap_exset_erase(), _wrap_exvector___delitem__(), _wrap_exvector___getitem__(), _wrap_exvector___setitem__(), _wrap_exvector___setitem____SWIG_0(), _wrap_exvector___setslice__(), _wrap_exvector_erase(), _wrap_exvector_insert(), _wrap_exvector_resize(), _wrap_new_ex_int_map(), _wrap_new_ex_int_map__SWIG_2(), _wrap_new_exlist(), _wrap_new_exlist__SWIG_1(), _wrap_new_exmap(), _wrap_new_exmap__SWIG_2(), _wrap_new_exset(), _wrap_new_exset__SWIG_2(), _wrap_new_exvector(), _wrap_new_exvector__SWIG_1(), _wrap_new_symexlist(), _wrap_new_symexlist__SWIG_1(), _wrap_new_symexlist__SWIG_3(), _wrap_new_symexpair(), _wrap_new_symexpair__SWIG_2(), _wrap_symexlist___delitem__(), _wrap_symexlist___getitem__(), _wrap_symexlist___setitem__(), _wrap_symexlist___setitem____SWIG_0(), _wrap_symexlist___setitem____SWIG_1(), _wrap_symexlist___setslice__(), _wrap_symexlist_append(), _wrap_symexlist_assign(), _wrap_symexlist_erase(), _wrap_symexlist_insert(), _wrap_symexlist_insert__SWIG_0(), _wrap_symexlist_insert__SWIG_1(), _wrap_symexlist_push_back(), _wrap_symexlist_push_front(), _wrap_symexlist_resize(), _wrap_symexlist_resize__SWIG_1(), swig::traits_as< Type, pointer_category >::as(), swig::traits_asval< Type >::asval(), and swig::traits_check< Type, pointer_category >::check().

03628                                                {
03629     return traits_asptr<Type>::asptr(obj, vptr);
03630   }

template<class SwigPySeq , class T >
void swig::assign ( const SwigPySeq &  swigpyseq,
std::set< T > *  seq 
) [inline]

Definition at line 5275 of file SyFi_wrap.cc.

05275                                                        {
05276       // seq->insert(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
05277       typedef typename SwigPySeq::value_type value_type;
05278       typename SwigPySeq::const_iterator it = swigpyseq.begin();
05279       for (;it != swigpyseq.end(); ++it) {
05280         seq->insert(seq->end(),(value_type)(*it));
05281       }
05282     }

template<class SwigPySeq , class K , class T >
void swig::assign ( const SwigPySeq &  swigpyseq,
std::map< K, T > *  map 
) [inline]

Definition at line 4718 of file SyFi_wrap.cc.

04718                                                           {
04719       typedef typename std::map<K,T>::value_type value_type;
04720       typename SwigPySeq::const_iterator it = swigpyseq.begin();
04721       for (;it != swigpyseq.end(); ++it) {
04722         map->insert(value_type(it->first, it->second));
04723       }
04724     }

template<class SwigPySeq , class Seq >
void swig::assign ( const SwigPySeq &  swigpyseq,
Seq *  seq 
) [inline]

Definition at line 4406 of file SyFi_wrap.cc.

Referenced by _wrap_exlist_assign(), _wrap_exvector_assign(), _wrap_symexlist_assign(), and swig::traits_asptr_stdseq< Seq, T >::asptr().

04406                                                {
04407     // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
04408     typedef typename SwigPySeq::value_type value_type;
04409     typename SwigPySeq::const_iterator it = swigpyseq.begin();
04410     for (;it != swigpyseq.end(); ++it) {
04411       seq->insert(seq->end(),(value_type)(*it));
04412     }
04413   }

template<class Type >
int swig::asval ( PyObject *  obj,
Type *  val 
) [inline]

template<class Sequence , class Difference >
Sequence::const_iterator swig::cgetpos ( const Sequence *  self,
Difference  i 
) [inline]

Definition at line 3882 of file SyFi_wrap.cc.

References check_index().

Referenced by std_list_Sl_GiNaC_ex_Sg____getitem____SWIG_1(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____getitem____SWIG_1(), std_set_Sl_GiNaC_ex_Sc_GiNaC_ex_is_less_Sg____getitem__(), and std_vector_Sl_GiNaC_ex_Sg____getitem____SWIG_1().

03882                                                {
03883     typename Sequence::const_iterator pos = self->begin();
03884     std::advance(pos, check_index(i,self->size()));
03885     return pos;
03886   }

template<class Type >
bool swig::check ( PyObject *  obj  )  [inline]

Definition at line 3757 of file SyFi_wrap.cc.

03757                                    {
03758     return traits_check<Type, typename traits<Type>::category>::check(obj);
03759   }

size_t swig::check_index ( ptrdiff_t  i,
size_t  size,
bool  insert = false 
) [inline]

Definition at line 3846 of file SyFi_wrap.cc.

Referenced by cgetpos(), delslice(), getpos(), getslice(), and setslice().

03846                                                              {
03847     if ( i < 0 ) {
03848       if ((size_t) (-i) <= size)
03849         return (size_t) (i + size);
03850     } else if ( (size_t) i < size ) {
03851       return (size_t) i;
03852     } else if (insert && ((size_t) i == size)) {
03853       return size;
03854     }
03855     
03856     throw std::out_of_range("index out of range");
03857   }

template<class Sequence , class Difference >
void swig::delslice ( Sequence *  self,
Difference  i,
Difference  j 
) [inline]

Definition at line 3932 of file SyFi_wrap.cc.

References check_index(), and slice_index().

Referenced by std_list_Sl_GiNaC_ex_Sg____delitem____SWIG_1(), std_list_Sl_GiNaC_ex_Sg____delslice__(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____delitem____SWIG_1(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____delslice__(), std_vector_Sl_GiNaC_ex_Sg____delitem____SWIG_1(), and std_vector_Sl_GiNaC_ex_Sg____delslice__().

03932                                                        {
03933     typename Sequence::size_type size = self->size();
03934     typename Sequence::size_type ii = swig::check_index(i, size, true);
03935     typename Sequence::size_type jj = swig::slice_index(j, size);
03936     if (jj > ii) {
03937       typename Sequence::iterator sb = self->begin();
03938       typename Sequence::iterator se = self->begin();
03939       std::advance(sb,ii);
03940       std::advance(se,jj);
03941       self->erase(sb,se);
03942     }
03943   }

template<class Type >
PyObject* swig::from ( const Type &  val  )  [inline]

template<class Type >
PyObject* swig::from_ptr ( Type *  val,
int  owner 
) [inline]

Definition at line 3608 of file SyFi_wrap.cc.

References swig::traits_from_ptr< Type >::from().

03608                                                   {
03609     return traits_from_ptr<Type>::from(val, owner);
03610   }

template<class Sequence , class Difference >
Sequence::iterator swig::getpos ( Sequence *  self,
Difference  i 
) [inline]

template<class Sequence , class Difference >
Sequence* swig::getslice ( const Sequence *  self,
Difference  i,
Difference  j 
) [inline]

Definition at line 3890 of file SyFi_wrap.cc.

References check_index(), and slice_index().

Referenced by std_list_Sl_GiNaC_ex_Sg____getitem____SWIG_0(), std_list_Sl_GiNaC_ex_Sg____getslice__(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____getitem____SWIG_0(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____getslice__(), std_vector_Sl_GiNaC_ex_Sg____getitem____SWIG_0(), and std_vector_Sl_GiNaC_ex_Sg____getslice__().

03890                                                              {
03891     typename Sequence::size_type size = self->size();
03892     typename Sequence::size_type ii = swig::check_index(i, size);
03893     typename Sequence::size_type jj = swig::slice_index(j, size);
03894 
03895     if (jj > ii) {
03896       typename Sequence::const_iterator vb = self->begin();
03897       typename Sequence::const_iterator ve = self->begin();
03898       std::advance(vb,ii);
03899       std::advance(ve,jj);
03900       return new Sequence(vb, ve);
03901     } else {
03902       return new Sequence();
03903     }
03904   }

template<typename OutIter >
SwigPyIterator* swig::make_output_iterator ( const OutIter &  current,
PyObject *  seq = 0 
) [inline]

Definition at line 4155 of file SyFi_wrap.cc.

04156   {
04157     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
04158   }

template<typename OutIter >
SwigPyIterator* swig::make_output_iterator ( const OutIter &  current,
const OutIter &  begin,
const OutIter &  end,
PyObject *  seq = 0 
) [inline]

Definition at line 4148 of file SyFi_wrap.cc.

Referenced by _wrap_ex_int_map_begin(), _wrap_ex_int_map_end(), _wrap_ex_int_map_find(), _wrap_ex_int_map_lower_bound(), _wrap_ex_int_map_rbegin(), _wrap_ex_int_map_rend(), _wrap_ex_int_map_upper_bound(), _wrap_exlist_begin(), _wrap_exlist_end(), _wrap_exlist_erase__SWIG_0(), _wrap_exlist_erase__SWIG_1(), _wrap_exlist_insert__SWIG_0(), _wrap_exlist_rbegin(), _wrap_exlist_rend(), _wrap_exmap_begin(), _wrap_exmap_end(), _wrap_exmap_find(), _wrap_exmap_lower_bound(), _wrap_exmap_rbegin(), _wrap_exmap_rend(), _wrap_exmap_upper_bound(), _wrap_exset_begin(), _wrap_exset_end(), _wrap_exset_equal_range(), _wrap_exset_find(), _wrap_exset_insert(), _wrap_exset_lower_bound(), _wrap_exset_rbegin(), _wrap_exset_rend(), _wrap_exset_upper_bound(), _wrap_exvector_begin(), _wrap_exvector_end(), _wrap_exvector_erase__SWIG_0(), _wrap_exvector_erase__SWIG_1(), _wrap_exvector_insert__SWIG_0(), _wrap_exvector_rbegin(), _wrap_exvector_rend(), _wrap_symexlist_begin(), _wrap_symexlist_end(), _wrap_symexlist_erase__SWIG_0(), _wrap_symexlist_erase__SWIG_1(), _wrap_symexlist_insert__SWIG_0(), _wrap_symexlist_rbegin(), _wrap_symexlist_rend(), std_list_Sl_GiNaC_ex_Sg__iterator(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg__iterator(), std_map_Sl_GiNaC_ex_Sc_GiNaC_ex_Sc_GiNaC_ex_is_less_Sg__iterator(), std_map_Sl_GiNaC_ex_Sc_int_Sc_GiNaC_ex_is_less_Sg__iterator(), std_set_Sl_GiNaC_ex_Sc_GiNaC_ex_is_less_Sg__iterator(), and std_vector_Sl_GiNaC_ex_Sg__iterator().

04149   {
04150     return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
04151   }

template<typename OutIter >
SwigPyIterator* swig::make_output_key_iterator ( const OutIter &  current,
const OutIter &  begin,
const OutIter &  end,
PyObject *  seq = 0 
) [inline]

Definition at line 4822 of file SyFi_wrap.cc.

Referenced by std_map_Sl_GiNaC_ex_Sc_GiNaC_ex_Sc_GiNaC_ex_is_less_Sg__key_iterator(), and std_map_Sl_GiNaC_ex_Sc_int_Sc_GiNaC_ex_is_less_Sg__key_iterator().

04823     {
04824       return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
04825     }

template<typename OutIter >
SwigPyIterator* swig::make_output_value_iterator ( const OutIter &  current,
const OutIter &  begin,
const OutIter &  end,
PyObject *  seq = 0 
) [inline]

Definition at line 4840 of file SyFi_wrap.cc.

Referenced by std_map_Sl_GiNaC_ex_Sc_GiNaC_ex_Sc_GiNaC_ex_is_less_Sg__value_iterator(), and std_map_Sl_GiNaC_ex_Sc_int_Sc_GiNaC_ex_is_less_Sg__value_iterator().

04841     {
04842       return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
04843     }

template<class Sequence , class Difference , class InputSeq >
void swig::setslice ( Sequence *  self,
Difference  i,
Difference  j,
const InputSeq &  v 
) [inline]

Definition at line 3908 of file SyFi_wrap.cc.

References check_index(), and slice_index().

Referenced by std_list_Sl_GiNaC_ex_Sg____setitem____SWIG_0(), std_list_Sl_GiNaC_ex_Sg____setslice__(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____setitem____SWIG_0(), std_list_Sl_std_pair_Sl_GiNaC_symbol_Sc_GiNaC_ex_Sg__Sg____setslice__(), std_vector_Sl_GiNaC_ex_Sg____setitem____SWIG_0(), and std_vector_Sl_GiNaC_ex_Sg____setslice__().

03908                                                                           {
03909     typename Sequence::size_type size = self->size();
03910     typename Sequence::size_type ii = swig::check_index(i, size, true);
03911     typename Sequence::size_type jj = swig::slice_index(j, size);
03912     if (jj < ii) jj = ii;
03913     size_t ssize = jj - ii;
03914     if (ssize <= v.size()) {
03915       typename Sequence::iterator sb = self->begin();
03916       typename InputSeq::const_iterator vmid = v.begin();
03917       std::advance(sb,ii);
03918       std::advance(vmid, jj - ii);
03919       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
03920     } else {
03921       typename Sequence::iterator sb = self->begin();
03922       typename Sequence::iterator se = self->begin();
03923       std::advance(sb,ii);
03924       std::advance(se,jj);
03925       self->erase(sb,se);
03926       self->insert(sb, v.begin(), v.end());
03927     }
03928   }

size_t swig::slice_index ( ptrdiff_t  i,
size_t  size 
) [inline]

Definition at line 3860 of file SyFi_wrap.cc.

Referenced by delslice(), getslice(), and setslice().

03860                                         {
03861     if ( i < 0 ) {
03862       if ((size_t) (-i) <= size) {
03863         return (size_t) (i + size);
03864       } else {
03865         throw std::out_of_range("index out of range");
03866       }
03867     } else {
03868       return ( (size_t) i < size ) ? ((size_t) i) : size;
03869     }
03870   }

template<class Type >
swig_type_info* swig::type_info (  )  [inline]

Definition at line 3544 of file SyFi_wrap.cc.

References swig::traits_info< Type >::type_info().

03544                                      {
03545     return traits_info<Type>::type_info();
03546   }

template<class Type >
const char* swig::type_name (  )  [inline]

Definition at line 3527 of file SyFi_wrap.cc.

03527                                  {
03528     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
03529   }


Generated on Mon Aug 31 16:17:06 2009 for SyFi by  doxygen 1.5.9