Back to index

nordugrid-arc-nox  1.1.0~rc6
Classes | Functions
swig Namespace Reference

Classes

class  PyObject_ptr
struct  PyObject_var
struct  stop_iteration
struct  PySwigIterator
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  PySwigIterator_T
struct  from_oper
class  PySwigIteratorOpen_T
class  PySwigIteratorClosed_T
struct  PySequence_Ref
struct  PySequence_ArrowProxy
struct  PySequence_InputIterator
struct  PySequence_Cont
struct  traits< std::string >
struct  traits_asval< std::string >
struct  traits_from< std::string >
struct  traits_asptr_stdseq
struct  traits_from_stdseq
struct  traits_asptr< std::list< T > >
struct  traits_from< std::list< T > >
struct  traits< std::list< std::string, std::allocator< std::string > > >
struct  traits_asptr< std::pair< T, U > >
struct  traits_from< std::pair< T, U > >
struct  traits< std::pair< std::string, std::string > >
struct  traits_asptr< std::map< K, T > >
struct  traits_from< std::map< K, T > >
struct  from_key_oper
struct  from_value_oper
struct  PyMapIterator_T
struct  PyMapKeyIterator_T
struct  PyMapValueIterator_T
struct  traits< std::map< std::string, std::string, std::less< std::string >, std::allocator< std::pair< std::string const, std::string > > > >
struct  traits< Arc::XMLNode >
struct  traits< std::list< Arc::XMLNode, std::allocator< Arc::XMLNode > > >
struct  traits< Arc::URL >
struct  traits< std::list< Arc::URL, std::allocator< Arc::URL > > >
struct  traits_asptr< std::vector< T > >
struct  traits_from< std::vector< T > >
struct  traits< std::vector< Arc::URL, std::allocator< Arc::URL > > >
struct  traits< std::pair< std::string, std::list< Arc::URL, std::allocator< Arc::URL > > > >
struct  traits< std::map< std::string, std::list< Arc::URL, std::allocator< Arc::URL > >, std::less< std::string >, std::allocator< std::pair< std::string const, std::list< Arc::URL, std::allocator< Arc::URL > > > > > >
struct  traits< Arc::ExecutionTarget >
struct  traits< std::list< Arc::ExecutionTarget, std::allocator< Arc::ExecutionTarget > > >
struct  traits< Arc::JobController >
struct  traits< std::list< Arc::JobController *, std::allocator< Arc::JobController * > > >
struct  traits< Arc::Job >
struct  traits< std::list< Arc::Job, std::allocator< Arc::Job > > >
struct  traits< Arc::JobState >
struct  traits< std::list< Arc::JobState, std::allocator< Arc::JobState > > >
struct  traits< Arc::DataSourceType >
struct  traits< std::list< Arc::DataSourceType, std::allocator< Arc::DataSourceType > > >
struct  traits< Arc::DataTargetType >
struct  traits< std::list< Arc::DataTargetType, std::allocator< Arc::DataTargetType > > >
struct  traits< Arc::FileType >
struct  traits< std::list< Arc::FileType, std::allocator< Arc::FileType > > >
struct  traits< Arc::DirectoryType >
struct  traits< std::list< Arc::DirectoryType, std::allocator< Arc::DirectoryType > > >
struct  traits< Arc::ApplicationEnvironment >
struct  traits< std::list< Arc::ApplicationEnvironment, std::allocator< Arc::ApplicationEnvironment > > >
struct  traits< Arc::Software >
struct  traits< std::list< Arc::Software, std::allocator< Arc::Software > > >
struct  traits< Arc::SoftwareRequirement >
struct  traits< std::list< Arc::SoftwareRequirement, std::allocator< Arc::SoftwareRequirement > > >
struct  traits< Arc::ResourceTargetType >
struct  traits< std::list< Arc::ResourceTargetType, std::allocator< Arc::ResourceTargetType > > >

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 >
PySwigIteratormake_output_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)
template<typename OutIter >
PySwigIteratormake_output_iterator (const OutIter &current, PyObject *seq=0)
template<class PySeq , class Seq >
void assign (const PySeq &pyseq, Seq *seq)
template<class PySeq , class K , class T >
void assign (const PySeq &pyseq, std::map< K, T > *map)
template<typename OutIter >
PySwigIteratormake_output_key_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)
template<typename OutIter >
PySwigIteratormake_output_value_iterator (const OutIter &current, const OutIter &begin, const OutIter &end, PyObject *seq=0)

Class Documentation

struct swig::stop_iteration

Definition at line 2875 of file arc_wrap.cpp.

struct swig::pointer_category

Definition at line 3221 of file arc_wrap.cpp.

struct swig::value_category

Definition at line 3222 of file arc_wrap.cpp.

struct swig::traits

template<class Type>
struct swig::traits< Type >

Definition at line 3227 of file arc_wrap.cpp.

struct swig::traits_as

template<class Type, class Category>
struct swig::traits_as< Type, Category >

Definition at line 3268 of file arc_wrap.cpp.

struct swig::traits_check

template<class Type, class Category>
struct swig::traits_check< Type, Category >

Definition at line 3271 of file arc_wrap.cpp.


Function Documentation

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

Definition at line 3439 of file arc_wrap.cpp.

                                                 {
    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
  }
template<class Type >
int swig::asptr ( PyObject *  obj,
Type **  vptr 
) [inline]

Definition at line 3331 of file arc_wrap.cpp.

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

Here is the call graph for this function:

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

Definition at line 4252 of file arc_wrap.cpp.

                                       {
    // seq->assign(pyseq.begin(), pyseq.end()); // not used as not always implemented
    typedef typename PySeq::value_type value_type;
    typename PySeq::const_iterator it = pyseq.begin();
    for (;it != pyseq.end(); ++it) {
      seq->insert(seq->end(),(value_type)(*it));
    }
  }
template<class PySeq , class K , class T >
void swig::assign ( const PySeq &  pyseq,
std::map< K, T > *  map 
) [inline]

Definition at line 4534 of file arc_wrap.cpp.

                                                  {
      typedef typename std::map<K,T>::value_type value_type;
      typename PySeq::const_iterator it = pyseq.begin();
      for (;it != pyseq.end(); ++it) {
       map->insert(value_type(it->first, it->second));
      }
    }
template<class Type >
int swig::asval ( PyObject *  obj,
Type *  val 
) [inline]

Definition at line 3376 of file arc_wrap.cpp.

                                             {
    return traits_asval<Type>::asval(obj, val);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3574 of file arc_wrap.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3460 of file arc_wrap.cpp.

                                   {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
size_t swig::check_index ( ptrdiff_t  i,
size_t  size,
bool  insert = false 
) [inline]

Definition at line 3538 of file arc_wrap.cpp.

                                                             {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
       return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }
    
    throw std::out_of_range("index out of range");
  }

Here is the caller graph for this function:

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

Definition at line 3624 of file arc_wrap.cpp.

                                                       {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size, true);
    typename Sequence::size_type jj = swig::slice_index(j, size);
    if (jj > ii) {
      typename Sequence::iterator sb = self->begin();
      typename Sequence::iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      self->erase(sb,se);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3306 of file arc_wrap.cpp.

                                         {
    return traits_from<Type>::from(val);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3311 of file arc_wrap.cpp.

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

Here is the call graph for this function:

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

Definition at line 3566 of file arc_wrap.cpp.

                                        {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3582 of file arc_wrap.cpp.

                                                             {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size);
    typename Sequence::size_type jj = swig::slice_index(j, size);

    if (jj > ii) {
      typename Sequence::const_iterator vb = self->begin();
      typename Sequence::const_iterator ve = self->begin();
      std::advance(vb,ii);
      std::advance(ve,jj);
      return new Sequence(vb, ve);
    } else {
      return new Sequence();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3840 of file arc_wrap.cpp.

  {
    return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
  }
template<typename OutIter >
PySwigIterator* swig::make_output_iterator ( const OutIter &  current,
PyObject *  seq = 0 
) [inline]

Definition at line 3847 of file arc_wrap.cpp.

  {
    return new PySwigIteratorOpen_T<OutIter>(current, seq);
  }
template<typename OutIter >
PySwigIterator* swig::make_output_key_iterator ( const OutIter &  current,
const OutIter &  begin,
const OutIter &  end,
PyObject *  seq = 0 
) [inline]

Definition at line 4634 of file arc_wrap.cpp.

    {
      return new PyMapKeyIterator_T<OutIter>(current, begin, end, seq);
    }

Here is the caller graph for this function:

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

Definition at line 4652 of file arc_wrap.cpp.

    {
      return new PyMapValueIterator_T<OutIter>(current, begin, end, seq);
    }

Here is the caller graph for this function:

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

Definition at line 3600 of file arc_wrap.cpp.

                                                                          {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size, true);
    typename Sequence::size_type jj = swig::slice_index(j, size);
    if (jj < ii) jj = ii;
    size_t ssize = jj - ii;
    if (ssize <= v.size()) {
      typename Sequence::iterator sb = self->begin();
      typename InputSeq::const_iterator vmid = v.begin();
      std::advance(sb,ii);
      std::advance(vmid, jj - ii);
      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
    } else {
      typename Sequence::iterator sb = self->begin();
      typename Sequence::iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      self->erase(sb,se);
      self->insert(sb, v.begin(), v.end());
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3552 of file arc_wrap.cpp.

                                        {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size) {
       return (size_t) (i + size);
      } else {
       throw std::out_of_range("index out of range");
      }
    } else {
      return ( (size_t) i < size ) ? ((size_t) i) : size;
    }
  }

Here is the caller graph for this function:

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

Definition at line 3247 of file arc_wrap.cpp.

Here is the call graph for this function:

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

Definition at line 3230 of file arc_wrap.cpp.

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