EdbusDict Class Reference

Dictionary container for D-Bus types. More...

#include <edelib/EdbusDict.h>

Inheritance diagram for EdbusDict:

Public Types
typedef EdbusContainer < EdbusDictEntry > ::const_iterator	const_iterator
Public Types inherited from EdbusContainer< EdbusDictEntry >
typedef list< EdbusDictEntry > ::iterator	iterator
typedef list< EdbusDictEntry > ::const_iterator	const_iterator

Public Member Functions
void	append (const EdbusData &key, const EdbusData &value)
void	clear (void)
void	remove (const EdbusData &key)
EdbusData	find (const EdbusData &key)
bool	operator== (const EdbusDict &other)
bool	operator!= (const EdbusDict &other)
EdbusDataType	key_type (void)
EdbusDataType	value_type (void)
bool	value_type_is_container (void)
const_iterator	begin (void) const
const_iterator	end (void) const
unsigned int	size (void) const

Additional Inherited Members
Protected Member Functions inherited from EdbusContainer< EdbusDictEntry >
void	dispose (void)
void	unhook (void)
	EdbusContainer ()
	EdbusContainer (const EdbusContainer &other)
	~EdbusContainer ()
EdbusContainer &	operator= (const EdbusContainer &other)
Protected Attributes inherited from EdbusContainer< EdbusDictEntry >
EdbusContainerPrivate *	impl

Detailed Description

Dictionary container for D-Bus types.

EdbusDict is a dictionary container (or map in STL). Data is stored in key//value pairs so data search and fetching is done via it's key association.

Stored data will be unique by key: if you add key//value pair and later add another pair with already added key (or to use better term: assign a new value with aleady known key), previous value will be overriden.

Note

Adding (or updating) pairs (via append()) is not efficient like in e.g. STL map; it is more or less linear operation assuring uniqueness; D-Bus protocol can tolerate, but not prefer duplicate keys in dictionary. Dict's in D-Bus are often used to contain a small number of elements so this is not a big deal :)

Class use implicit sharing.

EdbusDict uses EdbusData as base type which means you can put any type EdbusData can hold as value. On other hand, D-Bus specification restricts key types to be only basic D-Bus types (

See Also

Edbus::basic_type()).

If you try to add non-basic D-Bus type as key, it will be ignored.

Todo:

This should be assertion

Each instance of EdbusDict object will have the same types for the keys and the same types for the values. This means that if you add in freshly created EdbusDict object a key as int32_t and value as string, all further adding is expecting that types too. On other hand, if you try to add a key with different type (in dict that already have few keys with e.g. int32_t), entry (key and value) will be ignored.

This will summarize the thing:

*   EdbusDict d;
*   d.append(EdbusData::to_string("foo"), EdbusData::to_int32(4));
*   // now d will accept only keys of type string and values of type int32_t
*
*   // ok, it will be added
*   d.append(EdbusData::to_string("baz"), EdbusData::to_int32(5));
*
*   // not ok, values are different type; it will not be added
*   d.append(EdbusData::to_string("baz"), EdbusData::to_bool(true));
* 

Besides using find() to get a content, you can use iterator too.

See Also

EdbusDictIterator Iterator points to the EdbusDictEntry which have two members, each EdbusData type. This means that you should use is_ members to check key and value types.

This is a sample of listing dict content, without type checks:

*   EdbusDict d;
*   d.append("foo", 4);
*   d.append("baz", 12);
*
*   EdbusDict::const_iterator it = d.begin(), it_end = d.end();
*   while(it != it_end) {
*     printf("key: %s value: %i\n", (*it).key.to_string(), (*it).value.to_int32());
*     ++it;
*   }
* 

Member Typedef Documentation

typedef EdbusContainer<EdbusDictEntry>::const_iterator const_iterator

Declares EdbusDict iterator

Member Function Documentation

void append	(	const EdbusData &	key,
		const EdbusData &	value
	)

Assign value with the key and add it. If key already exists, previous value will be overriden with the new one.

Parameters

key	is key in basic D-Bus type
value	is any value EdbusData can hold

const_iterator begin

(

void

)

const

Returns iterator at the dict start. It points to the first element

void clear

(

void

)

Clear content

const_iterator end

(

void

)

const

Returns iterator at the dict end. It does not points to the last element, but element after the last, and you must not dereferce it

EdbusData find

(

const EdbusData &

key

)

Find and retrieve value associated with this key. If value is not found, it will retrieve invalid EdbusData type (EDBUS_TYPE_INVALID).

See Also

EdbusData

Returns

associated value or invalid type

Parameters

key	is key//value pair to be searched

EdbusDataType key_type

(

void

)

Returns type of keys stored in dict

bool operator!= ( const EdbusDict &  other )

inline

Compares if two dicts are not equal

bool operator==

(

const EdbusDict &

other

)

Compares if two dicts are equal

void remove

(

const EdbusData &

key

)

Remove value and key for the dict. If key is not found, it will do nothing

Parameters

key	is key to be removed with it's value

unsigned int size

(

void

)

const

Returns size of dict content. This is a constant operation

EdbusDataType value_type

(

void

)

Returns type of values stored in dict

bool value_type_is_container

(

void

)

Return true if value type is container (EdbusDict or EdbusList)

---

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

• edelib/EdbusDict.h