AnyMap¶

class cppmicroservices::AnyMap¶

A map data structure with support for compound keys.

This class adds convenience functions on top of the any_map class. The any_map is a recursive data structure, and its values can be retrieved via standard map functions or by using a dotted key notation specifying a compound key.

See: any_map

Inherits from cppmicroservices::any_map

Public Functions

AnyMap(map_type type)¶

AnyMap(const ordered_any_map &m)¶

AnyMap(ordered_any_map &&m)¶

AnyMap(const unordered_any_map &m)¶

AnyMap(unordered_any_map &&m)¶

AnyMap(const unordered_any_cimap &m)¶

AnyMap(unordered_any_cimap &&m)¶

map_type GetType() const¶

Get the underlying STL container type.

Return: The STL container type holding the map data.

const mapped_type &AtCompoundKey(const key_type &key) const¶

Get a key’s value, using a compound key notation.

A compound key consists of one or more key names, concatenated with the ‘.’ (dot) character. Each key except the last requires the referenced Any object to be of type AnyMap or std::vector<Any>. Containers of type std::vector<Any> are indexed using 0-based numerical key names.

For example, a AnyMap object holding data of the following layout

{
  one: 1,
  two: "two",
  three: {
    a: "anton",
    b: [ 3, 8 ]
  }
}

can be queried using the following notation:

map.AtCompoundKey("one");       // returns Any(1)
map.AtCompoundKey("three.a");   // returns Any(std::string("anton"))
map.AtCompoundKey("three.b.1"); // returns Any(8)

Return

A reference to the key’s value.

Parameters

key: The key hierachy to query.

Exceptions

std::invalid_argument: if the Any value for a given key is not of type AnyMap or std::vector<Any>.
std::out_of_range: if the key is not found or a numerical index would fall out of the range of an int type.

mapped_type AtCompoundKey(const key_type &key, mapped_type defaultValue) const¶

Return a key’s value, using a compound key notation if the key is found in the map or return the provided default value if the key is not found.

A compound key consists of one or more key names, concatenated with the ‘.’ (dot) character. Each key except the last requires the referenced Any object to be of type AnyMap or std::vector<Any>. Containers of type std::vector<Any> are indexed using 0-based numerical key names.

For example, a AnyMap object holding data of the following layout

{
  one: 1,
  two: "two",
  three: {
    a: "anton",
    b: [ 3, 8 ]
  }
}

can be queried using the following notation:

map.AtCompoundKey("one", Any());       // returns Any(1)
map.AtCompoundKey("four", Any());       // returns Any()
map.AtCompoundKey("three.a", Any());          // returns Any(std::string("anton"))
map.AtCompoundKey("three.c", Any());          // returns Any()
map.AtCompoundKey("three.b.1", Any());        // returns Any(8)
map.AtCompoundKey("three.b.4", Any());        // returns Any()

Return

A copy of the key’s value.

Parameters

key: The key hierachy to query.
defaultValue: is the value to be returned if the key is not found

class cppmicroservices::any_map¶

A map data structure which wraps different STL map types.

This is a convenience class providing a STL associative container interface for different underlying container types. Supported underlying types are

any_map::ordered_any_map (a STL map)
any_map::unordered_any_map (a STL unordered map)
any_map::unordered_any_cimap (a STL unordered map with case insensitive key comparison)

This class provides most of the STL functions for associated containers, including forward iterators. It is typically not instantiated by clients directly, but obtained via framework API calls, returning an AnyMap sub-class instance.

See: AnyMap

Subclassed by cppmicroservices::AnyMap

Public Types

enum map_type¶

Values:

ORDERED_MAP¶

UNORDERED_MAP¶

UNORDERED_MAP_CASEINSENSITIVE_KEYS¶

using key_type = std::string¶

using mapped_type = Any ¶

using value_type = std::pair<const key_type, mapped_type>¶

using size_type = std::size_t¶

using difference_type = std::ptrdiff_t¶

using reference = value_type&¶

using const_reference = const value_type&¶

using pointer = value_type *¶

using const_pointer = const value_type *¶

using ordered_any_map = std::map<std::string, Any>¶

using unordered_any_map = std::unordered_map<std::string, Any>¶

using unordered_any_cimap = std::unordered_map<std::string, Any, detail::any_map_cihash, detail::any_map_ciequal>¶

using iterator = iter ¶

using const_iterator = const_iter ¶

Public Functions

any_map(map_type type)¶

any_map(const ordered_any_map &m)¶

any_map(ordered_any_map &&m)¶

any_map(const unordered_any_map &m)¶

any_map(unordered_any_map &&m)¶

any_map(const unordered_any_cimap &m)¶

any_map(unordered_any_cimap &&m)¶

any_map(const any_map &m)¶

any_map &operator=(const any_map &m)¶

any_map(any_map &&m)¶

any_map &operator=(any_map &&m)¶

~any_map()¶

iter begin()¶

const_iter begin() const¶

const_iter cbegin() const¶

iter end()¶

const_iter end() const¶

const_iter cend() const¶

bool empty() const¶

size_type size() const¶

size_type count(const key_type &key) const¶

void clear()¶

mapped_type &at(const key_type &key)¶

const mapped_type &at(const key_type &key) const¶

mapped_type &operator[](const key_type &key)¶

mapped_type &operator[](key_type &&key)¶

std::pair<iterator, bool> insert(const value_type &value)¶

template <class... Args>
std::pair<iterator, bool> emplace(Args&&... args)¶

const_iterator find(const key_type &key) const¶: return the iterator to the value referenced by key

size_type erase(const key_type &key)¶

Erase entry for value for ‘key’.

Return

the number of elements erased.

Parameters

key: the key for the entry to Erase

bool operator==(const any_map &rhs) const¶

Compare the content of this map with those of rhs.

Return

bool true rhs contains the same content as this

Parameters

rhs: an any_map to compare

bool operator!=(const any_map &rhs) const¶

Public Members

ordered_any_map *o¶

unordered_any_map *uo¶

unordered_any_cimap *uoci¶

Protected Attributes

map_type type¶

class const_iter¶

Inherits from cppmicroservices::any_map::iterator_base

Public Types

using reference = any_map::const_reference ¶

using pointer = any_map::const_pointer ¶

using iterator = const_iter ¶

Public Functions

const_iter()¶

const_iter(const iterator &it)¶

const_iter(const iter &it)¶

~const_iter()¶

const_iter(ociter &&it)¶

const_iter(uociter &&it, iter_type type)¶

reference operator*() const¶

pointer operator->() const¶

iterator &operator++()¶

iterator operator++(int)¶

bool operator==(const iterator &x) const¶

bool operator!=(const iterator &x) const¶

Public Members

ociter *o¶

uociter *uo¶

uocciiter *uoci¶

class iter¶

Inherits from cppmicroservices::any_map::iterator_base

Public Types

using reference = any_map::reference ¶

using pointer = any_map::pointer ¶

using iterator = iter ¶

Public Functions

iter()¶

iter(const iter &it)¶

~iter()¶

iter(oiter &&it)¶

iter(uoiter &&it, iter_type type)¶

reference operator*() const¶

pointer operator->() const¶

iterator &operator++()¶

iterator operator++(int)¶

bool operator==(const iterator &x) const¶

bool operator!=(const iterator &x) const¶

Public Members

oiter *o¶

uoiter *uo¶

uociiter *uoci¶