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:

• usr/lib/enigma2/python/enigma.py