clang::mrdocs::dom::Object
A container of key and value pairs.
Types
Name |
Description |
The type of an element. |
|
A pointer to an element. |
|
A reference to an element. |
|
A signed integral type. |
|
The implementation type. |
|
A pointer to an element. |
|
A reference to an element. |
|
An unsigned integral type used for indexes and sizes. |
|
The type of storage used by the default implementation. |
Member Functions
Name |
Description |
|
Constructor. |
|
Destructor. |
Assignment. |
|
Return the element at a given index. |
|
Return true if the container is empty. |
|
Return true if a key exists. |
|
Return the element with the specified key |
|
Return the implementation used by this object. |
|
Set or replace the value for a given key. |
|
Return the number of elements. |
|
Swap two objects. |
|
Return the type key. |
|
Invoke the visitor for each key/value pair |
Friends
Name |
Description |
Return a diagnostic string. |
|
Compare two objects for precedence. |
|
Compare two objects for equality. |
|
Swap two objects. |
Non-Member Functions
Name |
Description |
Return a new dom::Object based on a lazy object implementation. |
|
Return a new dom::Object based on a transformed lazy array implementation. |
|
Return a new object using a custom implementation. |
|
Create child data objects. |
Description
Objects are a collection of properties, which are equivalent to key‐value pairs. Property values can be any type, including other Objects, allowing for the creation of arbitrarily complex data structures.
An Object is a non‐primitive (or reference) type, meaning that they are not copied when assigned or passed as a parameter. Instead, the reference is copied, and the original value is shared.
These reference types are modeled after JavaScript "Objects". All non‐primitive types (Object types) are derived from Object in JavaScript. This means types such as Array and Function represent a relevant selection of built‐in types that would derive from Object in JavaScript.
Properties
Objects are a collection of properties, which are
equivalent to key-value pairs. There are two
kinds of properties:
@li Data properties: Associates a key with a value.
@li Accessor properties: Associates a key with
one of two accessor functions (`get` and `set`),
which are used to retrieve or set the value.
The internal representation of objects can determine
how properties are stored and the type of properties
being represented.
Properties can also be enumerable or non-enumerable.
An enumerable property is one that is iterated by
the `visit` function. Non-enumerable properties can
only be accessed by name with the `get` and `set`
functions.Created with MrDocs