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

Public Member Functions

def iterator (self)
 
def __iter__ (self)
 
def __nonzero__ (self)
 
def __bool__ (self)
 
def __len__ (self)
 
def __iter__ (self)
 
def iterkeys (self)
 
def itervalues (self)
 
def iteritems (self)
 
def __getitem__ (self, key)
 
def __delitem__ (self, key)
 
def has_key (self, key)
 
def keys (self)
 
def values (self)
 
def items (self)
 
def __contains__ (self, key)
 
def key_iterator (self)
 
def value_iterator (self)
 
def __setitem__ (self, *args)
 
def asdict (self)
 
def __init__ (self, *args)
 
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 count (self, x)
 
def erase (self, *args)
 
def find (self, x)
 
def lower_bound (self, x)
 
def upper_bound (self, x)
 
def get (self, key, default=None)
 

Static Public Attributes

 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
 
 iterator
 
 has_key
 
 keys
 
 values
 
 items
 
 key_iterator
 
 value_iterator
 
 asdict
 
 empty
 
 size
 
 swap
 
 begin
 
 end
 
 rbegin
 
 rend
 
 clear
 
 get_allocator
 
 count
 
 erase
 
 find
 
 lower_bound
 
 upper_bound
 

Detailed Description

Proxy of C++ std::map<(std::string,boost::any)> class.

Constructor & Destructor Documentation

◆ __init__()

def enigma.PseudoDict.__init__ (   self,
args 
)
__init__(std::map<(std::string,boost::any)> self, std::less< std::string > const & arg2) -> PseudoDict
__init__(std::map<(std::string,boost::any)> self) -> PseudoDict
__init__(std::map<(std::string,boost::any)> self, PseudoDict arg2) -> PseudoDict

Member Function Documentation

◆ __bool__()

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

◆ __contains__()

def enigma.PseudoDict.__contains__ (   self,
  key 
)
__contains__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> bool

◆ __delitem__()

def enigma.PseudoDict.__delitem__ (   self,
  key 
)
__delitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key)

◆ __getitem__()

def enigma.PseudoDict.__getitem__ (   self,
  key 
)
__getitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> std::map< std::string,boost::any >::mapped_type const &

◆ __iter__() [1/2]

def enigma.PseudoDict.__iter__ (   self)

◆ __iter__() [2/2]

def enigma.PseudoDict.__iter__ (   self)

◆ __len__()

def enigma.PseudoDict.__len__ (   self)
__len__(PseudoDict self) -> std::map< std::string,boost::any >::size_type

◆ __nonzero__()

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

◆ __setitem__()

def enigma.PseudoDict.__setitem__ (   self,
args 
)
__setitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key)
__setitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key, std::map< std::string,boost::any >::mapped_type const & x)

◆ asdict()

def enigma.PseudoDict.asdict (   self)
asdict(PseudoDict self) -> PyObject *

◆ begin()

def enigma.PseudoDict.begin (   self)
begin(PseudoDict self) -> std::map< std::string,boost::any >::iterator

◆ clear()

def enigma.PseudoDict.clear (   self)
clear(PseudoDict self)

◆ count()

def enigma.PseudoDict.count (   self,
  x 
)
count(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::size_type

◆ empty()

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

◆ end()

def enigma.PseudoDict.end (   self)
end(PseudoDict self) -> std::map< std::string,boost::any >::iterator

◆ erase()

def enigma.PseudoDict.erase (   self,
args 
)
erase(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::size_type
erase(PseudoDict self, std::map< std::string,boost::any >::iterator position)
erase(PseudoDict self, std::map< std::string,boost::any >::iterator first, std::map< std::string,boost::any >::iterator last)

◆ find()

def enigma.PseudoDict.find (   self,
  x 
)
find(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator

◆ get()

def enigma.PseudoDict.get (   self,
  key,
  default = None 
)

◆ get_allocator()

def enigma.PseudoDict.get_allocator (   self)
get_allocator(PseudoDict self) -> std::map< std::string,boost::any >::allocator_type

◆ has_key()

def enigma.PseudoDict.has_key (   self,
  key 
)
has_key(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> bool

◆ items()

def enigma.PseudoDict.items (   self)
items(PseudoDict self) -> PyObject *

◆ iterator()

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

◆ iteritems()

def enigma.PseudoDict.iteritems (   self)

◆ iterkeys()

def enigma.PseudoDict.iterkeys (   self)

◆ itervalues()

def enigma.PseudoDict.itervalues (   self)

◆ key_iterator()

def enigma.PseudoDict.key_iterator (   self)
key_iterator(PseudoDict self) -> SwigPyIterator

◆ keys()

def enigma.PseudoDict.keys (   self)
keys(PseudoDict self) -> PyObject *

◆ lower_bound()

def enigma.PseudoDict.lower_bound (   self,
  x 
)
lower_bound(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator

◆ rbegin()

def enigma.PseudoDict.rbegin (   self)
rbegin(PseudoDict self) -> std::map< std::string,boost::any >::reverse_iterator

◆ rend()

def enigma.PseudoDict.rend (   self)
rend(PseudoDict self) -> std::map< std::string,boost::any >::reverse_iterator

◆ size()

def enigma.PseudoDict.size (   self)
size(PseudoDict self) -> std::map< std::string,boost::any >::size_type

◆ swap()

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

◆ upper_bound()

def enigma.PseudoDict.upper_bound (   self,
  x 
)
upper_bound(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator

◆ value_iterator()

def enigma.PseudoDict.value_iterator (   self)
value_iterator(PseudoDict self) -> SwigPyIterator

◆ values()

def enigma.PseudoDict.values (   self)
values(PseudoDict self) -> PyObject *

Member Data Documentation

◆ asdict

enigma.PseudoDict.asdict
static

◆ begin

enigma.PseudoDict.begin
static

◆ clear

enigma.PseudoDict.clear
static

◆ count

enigma.PseudoDict.count
static

◆ empty

enigma.PseudoDict.empty
static

◆ end

enigma.PseudoDict.end
static

◆ erase

enigma.PseudoDict.erase
static

◆ find

enigma.PseudoDict.find
static

◆ get_allocator

enigma.PseudoDict.get_allocator
static

◆ has_key

enigma.PseudoDict.has_key
static

◆ items

enigma.PseudoDict.items
static

◆ iterator

enigma.PseudoDict.iterator
static

◆ key_iterator

enigma.PseudoDict.key_iterator
static

◆ keys

enigma.PseudoDict.keys
static

◆ lower_bound

enigma.PseudoDict.lower_bound
static

◆ rbegin

enigma.PseudoDict.rbegin
static

◆ rend

enigma.PseudoDict.rend
static

◆ size

enigma.PseudoDict.size
static

◆ swap

enigma.PseudoDict.swap
static

◆ thisown

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

◆ upper_bound

enigma.PseudoDict.upper_bound
static

◆ value_iterator

enigma.PseudoDict.value_iterator
static

◆ values

enigma.PseudoDict.values
static

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