enigma2  2.6
Public Member Functions | Static Public Attributes | List of all members
enigma.eCecDevicePtrVector Class Reference
Inheritance diagram for enigma.eCecDevicePtrVector:

Public Member Functions

def iterator (self)
 
def __iter__ (self)
 
def __nonzero__ (self)
 
def __bool__ (self)
 
def __len__ (self)
 
def __getslice__ (self, i, j)
 
def __setslice__ (self, *args)
 
def __delslice__ (self, i, j)
 
def __delitem__ (self, *args)
 
def __getitem__ (self, *args)
 
def __setitem__ (self, *args)
 
def pop (self)
 
def append (self, x)
 
def empty (self)
 
def size (self)
 
def swap (self, v)
 
def begin (self)
 
def end (self)
 
def rbegin (self)
 
def rend (self)
 
def clear (self)
 
def get_allocator (self)
 
def pop_back (self)
 
def erase (self, *args)
 
def __init__ (self, *args)
 
def push_back (self, x)
 
def front (self)
 
def back (self)
 
def assign (self, n, x)
 
def resize (self, *args)
 
def insert (self, *args)
 
def reserve (self, n)
 
def capacity (self)
 

Static Public Attributes

 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
 
 iterator
 
 pop
 
 append
 
 empty
 
 size
 
 swap
 
 begin
 
 end
 
 rbegin
 
 rend
 
 clear
 
 get_allocator
 
 pop_back
 
 erase
 
 push_back
 
 front
 
 back
 
 assign
 
 resize
 
 insert
 
 reserve
 
 capacity
 

Detailed Description

Proxy of C++ std::vector<(ePtr<(eCecDevice)>)> class.

Constructor & Destructor Documentation

◆ __init__()

def enigma.eCecDevicePtrVector.__init__ (   self,
args 
)
__init__(std::vector<(ePtr<(eCecDevice)>)> self) -> eCecDevicePtrVector
__init__(std::vector<(ePtr<(eCecDevice)>)> self, eCecDevicePtrVector arg2) -> eCecDevicePtrVector
__init__(std::vector<(ePtr<(eCecDevice)>)> self, std::vector< ePtr< eCecDevice > >::size_type size) -> eCecDevicePtrVector
__init__(std::vector<(ePtr<(eCecDevice)>)> self, std::vector< ePtr< eCecDevice > >::size_type size, eCecDevicePtr value) -> eCecDevicePtrVector

Member Function Documentation

◆ __bool__()

def enigma.eCecDevicePtrVector.__bool__ (   self)
__bool__(eCecDevicePtrVector self) -> bool

◆ __delitem__()

def enigma.eCecDevicePtrVector.__delitem__ (   self,
args 
)
__delitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i)
__delitem__(eCecDevicePtrVector self, PySliceObject * slice)

◆ __delslice__()

def enigma.eCecDevicePtrVector.__delslice__ (   self,
  i,
  j 
)
__delslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j)

◆ __getitem__()

def enigma.eCecDevicePtrVector.__getitem__ (   self,
args 
)
__getitem__(eCecDevicePtrVector self, PySliceObject * slice) -> eCecDevicePtrVector
__getitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i) -> eCecDevicePtr

◆ __getslice__()

def enigma.eCecDevicePtrVector.__getslice__ (   self,
  i,
  j 
)
__getslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j) -> eCecDevicePtrVector

◆ __iter__()

def enigma.eCecDevicePtrVector.__iter__ (   self)

◆ __len__()

def enigma.eCecDevicePtrVector.__len__ (   self)
__len__(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type

◆ __nonzero__()

def enigma.eCecDevicePtrVector.__nonzero__ (   self)
__nonzero__(eCecDevicePtrVector self) -> bool

◆ __setitem__()

def enigma.eCecDevicePtrVector.__setitem__ (   self,
args 
)
__setitem__(eCecDevicePtrVector self, PySliceObject * slice, eCecDevicePtrVector v)
__setitem__(eCecDevicePtrVector self, PySliceObject * slice)
__setitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, eCecDevicePtr x)

◆ __setslice__()

def enigma.eCecDevicePtrVector.__setslice__ (   self,
args 
)
__setslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j)
__setslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j, eCecDevicePtrVector v)

◆ append()

def enigma.eCecDevicePtrVector.append (   self,
  x 
)
append(eCecDevicePtrVector self, eCecDevicePtr x)

◆ assign()

def enigma.eCecDevicePtrVector.assign (   self,
  n,
  x 
)
assign(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type n, eCecDevicePtr x)

◆ back()

def enigma.eCecDevicePtrVector.back (   self)
back(eCecDevicePtrVector self) -> eCecDevicePtr

◆ begin()

def enigma.eCecDevicePtrVector.begin (   self)
begin(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::iterator

◆ capacity()

def enigma.eCecDevicePtrVector.capacity (   self)
capacity(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type

◆ clear()

def enigma.eCecDevicePtrVector.clear (   self)
clear(eCecDevicePtrVector self)

◆ empty()

def enigma.eCecDevicePtrVector.empty (   self)
empty(eCecDevicePtrVector self) -> bool

◆ end()

def enigma.eCecDevicePtrVector.end (   self)
end(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::iterator

◆ erase()

def enigma.eCecDevicePtrVector.erase (   self,
args 
)
erase(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos) -> std::vector< ePtr< eCecDevice > >::iterator
erase(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator first, std::vector< ePtr< eCecDevice > >::iterator last) -> std::vector< ePtr< eCecDevice > >::iterator

◆ front()

def enigma.eCecDevicePtrVector.front (   self)
front(eCecDevicePtrVector self) -> eCecDevicePtr

◆ get_allocator()

def enigma.eCecDevicePtrVector.get_allocator (   self)
get_allocator(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::allocator_type

◆ insert()

def enigma.eCecDevicePtrVector.insert (   self,
args 
)
insert(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos, eCecDevicePtr x) -> std::vector< ePtr< eCecDevice > >::iterator
insert(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos, std::vector< ePtr< eCecDevice > >::size_type n, eCecDevicePtr x)

◆ iterator()

def enigma.eCecDevicePtrVector.iterator (   self)
iterator(eCecDevicePtrVector self) -> SwigPyIterator

◆ pop()

def enigma.eCecDevicePtrVector.pop (   self)
pop(eCecDevicePtrVector self) -> eCecDevicePtr

◆ pop_back()

def enigma.eCecDevicePtrVector.pop_back (   self)
pop_back(eCecDevicePtrVector self)

◆ push_back()

def enigma.eCecDevicePtrVector.push_back (   self,
  x 
)
push_back(eCecDevicePtrVector self, eCecDevicePtr x)

◆ rbegin()

def enigma.eCecDevicePtrVector.rbegin (   self)
rbegin(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::reverse_iterator

◆ rend()

def enigma.eCecDevicePtrVector.rend (   self)
rend(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::reverse_iterator

◆ reserve()

def enigma.eCecDevicePtrVector.reserve (   self,
  n 
)
reserve(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type n)

◆ resize()

def enigma.eCecDevicePtrVector.resize (   self,
args 
)
resize(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type new_size)
resize(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type new_size, eCecDevicePtr x)

◆ size()

def enigma.eCecDevicePtrVector.size (   self)
size(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type

◆ swap()

def enigma.eCecDevicePtrVector.swap (   self,
  v 
)
swap(eCecDevicePtrVector self, eCecDevicePtrVector v)

Member Data Documentation

◆ append

enigma.eCecDevicePtrVector.append
static

◆ assign

enigma.eCecDevicePtrVector.assign
static

◆ back

enigma.eCecDevicePtrVector.back
static

◆ begin

enigma.eCecDevicePtrVector.begin
static

◆ capacity

enigma.eCecDevicePtrVector.capacity
static

◆ clear

enigma.eCecDevicePtrVector.clear
static

◆ empty

enigma.eCecDevicePtrVector.empty
static

◆ end

enigma.eCecDevicePtrVector.end
static

◆ erase

enigma.eCecDevicePtrVector.erase
static

◆ front

enigma.eCecDevicePtrVector.front
static

◆ get_allocator

enigma.eCecDevicePtrVector.get_allocator
static

◆ insert

enigma.eCecDevicePtrVector.insert
static

◆ iterator

enigma.eCecDevicePtrVector.iterator
static

◆ pop

enigma.eCecDevicePtrVector.pop
static

◆ pop_back

enigma.eCecDevicePtrVector.pop_back
static

◆ push_back

enigma.eCecDevicePtrVector.push_back
static

◆ rbegin

enigma.eCecDevicePtrVector.rbegin
static

◆ rend

enigma.eCecDevicePtrVector.rend
static

◆ reserve

enigma.eCecDevicePtrVector.reserve
static

◆ resize

enigma.eCecDevicePtrVector.resize
static

◆ size

enigma.eCecDevicePtrVector.size
static

◆ swap

enigma.eCecDevicePtrVector.swap
static

◆ thisown

enigma.eCecDevicePtrVector.thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
static

The documentation for this class was generated from the following file: