Quick Links: |
#include <bdld_datum.h>
This class implements a mechanism that provides a space-efficient discriminated union that holds the value of ether scalar type or an aggregate of Datum
objects. The size of Datum
is 8 bytes (same as a double
) on 32-bit platforms and 16 bytes on 64-bit platforms. Separate representation are needed on 32 and 64 bit platforms because of the differing size of a pointer (a 64-bit pointer cannot reasonably be held in a 32-bit footprint).
Representation on a 32-bit Platforms: Values are stored inside an 8-byte unsigned char array (d_data
). Any double
value (including NaN and infinity values) can be stored inside Datum
. When storing a value of a type other than double
, the bits in d_data
that correspond to the exponent part of a double
value are set to 1, with the 4 bits in the fraction part used to indicate the type of value stored.
Representation on 64-bit platforms: Values are stored inside a 16 byte unsigned char array (d_data
) to store values. The type information is stored in the upper 2 bytes of the character array. Remaining 14 bytes are used to store the actual value or the pointer to the external memory that holds the value.
For details on the internal representations that are used for various types on 32 and 64 bit platforms, please see the implementation notes in bdld_datum.cpp
.
Datum objects are bitwise copyable and have trivial initialization, assignment and destruction. Only one of the copies of the same Datum
object can be passed to destroy
. The rest of those copies then become invalid and it is undefined behavior to deep-copy or destroy them. Although, these copies can be used on the left hand side of assignment.
Enumeration used to discriminate among the different externally- exposed types of values that can be stored inside Datum
.
anonymous enum |
bdld::Datum::Datum | ( | ) |
Create a datum having an uninitialized value. The behavior for every accessor method is undefined until this object is assigned a value.
bdld::Datum::Datum | ( | const Datum & | original | ) |
Create a datum having the value of the specified original
.
bdld::Datum::~Datum | ( | ) |
Destroy this object. Note that this method does not deallocate any dynamically allocated memory used by this object (see destroy
).
static Datum bdld::Datum::createArrayReference | ( | const Datum * | array, | |
SizeType | length, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum referring to the specified array
, having the specified length
, using the specified basicAllocator
to supply memory (if needed). array
is not copied, and is not freed when the returned object is destroyed with Datum::destroy
. The behavior is undefined unless array
contains at least length
elements. The behavior is also undefined unless 'length < UINT_MAX'.
static Datum bdld::Datum::createArrayReference | ( | const DatumArrayRef & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the specified value
, using the specified basicAllocator
to supply memory (if needed). The array referenced by value
is not copied, and is not freed if Datum::destroy
is called on the returned object. The behavior is undefined unless value.length() < UINT_MAX
.
static Datum bdld::Datum::createBoolean | ( | bool | value | ) | [static] |
Return, by value, a datum having the specified bool
value
.
static Datum bdld::Datum::createDate | ( | const bdlt::Date & | value | ) | [static] |
Return, by value, a datum having the specified Date
value
.
static Datum bdld::Datum::createDatetime | ( | const bdlt::Datetime & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the specified Datetime
value
, using the specified basicAllocator
to supply memory (if needed).
static Datum bdld::Datum::createDatetimeInterval | ( | const bdlt::DatetimeInterval & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum holding the specified DatetimeInterval
value
, using the specified basicAllocator
to supply memory (if needed).
static Datum bdld::Datum::createDecimal64 | ( | bdldfp::Decimal64 | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the specified Decimal64
value
, using the specified basicAllocator
to supply memory (if needed). Note that the argument is passed by value because it is assumed to be a fundamental type.
static Datum bdld::Datum::createDouble | ( | double | value | ) | [static] |
Return, by value, a datum having the specified double
value
. When value
is NaN this method guarantees only that a NaN value is stored. The sign and NaN payload bits of a NaN value
later retrieved by the theDouble
method are unspecified (see also Special Floating Point Values.
static Datum bdld::Datum::createError | ( | int | code | ) | [static] |
Return, by value, a datum having a DatumError
value with the specified code
.
static Datum bdld::Datum::createError | ( | int | code, | |
const bslstl::StringRef & | message, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having a DatumError
value with the specified code
and the specified message
, using the specified basicAllocator
to supply memory (if needed).
static Datum bdld::Datum::createInteger | ( | int | value | ) | [static] |
Return, by value, a datum having the specified int
value
.
static Datum bdld::Datum::createInteger64 | ( | bsls::Types::Int64 | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the specified Integer64
value
, using the specified basicAllocator
to supply memory (if needed).
static Datum bdld::Datum::createNull | ( | ) | [static] |
Return, by value, a datum having no value.
static Datum bdld::Datum::createStringRef | ( | const char * | string, | |
SizeType | length, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum that refers to the specified string
having the specified length
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless 0 != string || 0 == length
. The behavior is also undefined unless length < UINT_MAX
. Note that string
is not copied, and is not freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::createStringRef | ( | const char * | string, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum that refers to the specified string
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless string
points to a UTF-8 encoded c-string. The behavior is also undefined unless 'strlen(string) < UINT_MAX'. Note that string
is not copied, and is not freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::createStringRef | ( | const bslstl::StringRef & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the specified StringRef
value
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless value.length() < UINT_MAX
. Note that string
is not copied, and is not freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::createTime | ( | const bdlt::Time & | value | ) | [static] |
Return, by value, a datum having the specified Time
value
.
static Datum bdld::Datum::createUdt | ( | void * | data, | |
int | type | |||
) | [static] |
Return, by value, a datum having the DatumUdt
value with the specified data
and the specified type
values. The behavior is undefined unless 0 <= type <= 65535
. Note that data
is held, not owned. Also note that the content pointed to by data
object is not copied.
static Datum bdld::Datum::copyBinary | ( | const void * | value, | |
SizeType | size, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum referring to the copy of the specified value
of the specified size
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless size < UINT_MAX
. Note that the copy of the binary data is owned and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::copyString | ( | const char * | string, | |
SizeType | length, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum that refers to the copy of the specified string
having the specified length
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless 0 != string || 0 == length
. The behavior is also undefined unless length < UINT_MAX
. Note that the copied string is owned and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::copyString | ( | const bslstl::StringRef & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Return, by value, a datum having the copy of the specified StringRef
value
, using the specified basicAllocator
to supply memory (if needed). The behavior is undefined unless value.length() < UINT_MAX
. Note that the copied string is owned, and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::adoptArray | ( | const DatumMutableArrayRef & | array | ) | [static] |
Return, by value, a datum that refers to the specified array
. The behavior is undefined unless array
was created using createUninitializedArray
method. The behavior is also undefined unless each element in the held datum array has been assigned a value and the array's length has been set accordingly. Note that the adopted array is owned and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::adoptIntMap | ( | const DatumMutableIntMapRef & | intMap | ) | [static] |
Return, by value, a datum that refers to the specified intMap
. The behavior is undefined unless map
was created using createUninitializedIntMap
method. The behavior is also undefined unless each element in the held map has been assigned a value and the size of the map has been set accordingly. Note that the adopted map is owned and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::adoptMap | ( | const DatumMutableMapRef & | map | ) | [static] |
Return, by value, a datum that refers to the specified map
. The behavior is undefined unless map
was created using createUninitializedMap
method. The behavior is also undefined unless each element in the held map has been assigned a value and the size of the map has been set accordingly. Note that the adopted map is owned and will be freed if Datum::destroy
is called on the returned object.
static Datum bdld::Datum::adoptMap | ( | const DatumMutableMapOwningKeysRef & | map | ) | [static] |
Return, by value, a datum that refers to the specified map
. The behavior is undefined unless map
was created using createUninitializedMapOwningKeys
method. The behavior is also undefined unless each element in the held map has been assigned a value and the size of the map has been set accordingly. The behavior is also undefined unless keys have been copied into the map. Note that the adopted map is owned and will be freed if Datum::destroy
is called on the returned object.
static void bdld::Datum::createUninitializedArray | ( | DatumMutableArrayRef * | result, | |
SizeType | capacity, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Load the specified result
with a reference to a newly created datum array having the specified capacity
, using the specified basicAllocator
to supply memory. The behavior is undefined if capacity
Datum
objects would exceed the addressable memory for the platform. Note that the caller is responsible for filling in elements into the datum array and setting its length accordingly. The number of elements in the datum array cannot exceed capacity
. Also note that any elements in the datum array that need dynamic memory must be allocated with basicAllocator
.
static void bdld::Datum::createUninitializedIntMap | ( | DatumMutableIntMapRef * | result, | |
SizeType | capacity, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Load the specified result
with a reference to a newly created datum int-map having the specified capacity
, using the specified basicAllocator
to supply memory. The behavior is undefined if capacity
DatumIntMapEntry
objects would exceed the addressable memory for the platform. Note that the caller is responsible for filling in elements into the datum int-map and setting its size accordingly. The number of elements in the datum int-map cannot exceed capacity
. Also note that any elements in the datum int-map that need dynamic memory, should also be allocated with basicAllocator
.
static void bdld::Datum::createUninitializedMap | ( | DatumMutableMapRef * | result, | |
SizeType | capacity, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Load the specified result
with a reference to a newly created datum map having the specified capacity
, using the specified basicAllocator
to supply memory. The behavior is undefined if capacity
DatumMapEntry
objects would exceed the addressable memory for the platform. Note that the caller is responsible for filling in elements into the datum map and setting its size accordingly. The number of elements in the datum map cannot exceed capacity
. Also note that any elements in the datum map that need dynamic memory, should also be allocated with basicAllocator
.
static void bdld::Datum::createUninitializedMap | ( | DatumMutableMapOwningKeysRef * | result, | |
SizeType | capacity, | |||
SizeType | keysCapacity, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Load the specified result
with a reference to a newly created datum-key-owning map having the specified capacity
and keysCapacity
, using the specified basicAllocator
to supply memory. The behavior is undefined if capacity
DatumMapEntry
objects plus keysCapacity
would exceed the addressable memory for the platform. Note that the caller is responsible for filling in elements into the datum-key-owning map, copying the keys into it, and setting its size accordingly. The number of elements in the datum-key-owning map cannot exceed capacity
and total size of all the keys cannot exceed keysCapacity
. Also note that any elements in the datum-key-owning map that need dynamic memory, should also be allocated with basicAllocator
.
static char* bdld::Datum::createUninitializedString | ( | Datum * | result, | |
SizeType | length, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
Load the specified result
with a reference to a newly created character buffer of the specified length
, using the specified basicAllocator
to supply memory, and return the address of this buffer. The behavior is undefined unless length < UINT_MAX
. Note that the caller is responsible for initializing the returned buffer with a UTF-8 encoded string.
static const char* bdld::Datum::dataTypeToAscii | ( | DataType | type | ) | [static] |
Return the non-modifiable string representation corresponding to the specified type
, if it exists, and a unique (error) string otherwise. The string representation of type
matches its corresponding enumerator name with the e_
prefix elided.
For example:
bsl::cout << bdld::Datum::dataTypeToAscii(bdld::Datum::e_NIL);
will print the following on standard output:
NIL
Note that specifying a type
that does not match any of the enumerators will result in a string representation that is distinct from any of those corresponding to the enumerators, but is otherwise unspecified.
static void bdld::Datum::destroy | ( | const Datum & | value, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Deallocate any memory that was previously allocated within the specified value
using the specified basicAllocator
. If the value
contains an adopted array of datums, destroy
is called on each array element. If the value
contains an adopted map of datums, destroy
is called on each map element. The behavior is undefined unless all dynamically allocated memory owned by value
was allocated using basicAllocator
, and has not previously been released by a call to destroy
, either on this object, or on another object referring to same contents as this object (i.e., only one copy of a Datum
object can be destroyed). The behavior is also undefined if value
has an uninitialized or partially initialized array or map (created using createUninitializedArray
, createUninitializedMap
or createUninitializeMapOwningKeys
). Note that after this operation completes, value
is left in an uninitialized state, and must be assigned a new value before being accessed again.
static void bdld::Datum::disposeUninitializedArray | ( | const DatumMutableArrayRef & | array, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Deallocate the memory used by the specified array
(but not memory allocated for its contained elements) using the specified basicAllocator
. This method does not destroy individual array elements and the memory allocated for those elements must be explicitly deallocated before calling this method. The behavior is undefined unless array
was created with createUninitializedArray
using basicAllocator
.
static void bdld::Datum::disposeUninitializedIntMap | ( | const DatumMutableIntMapRef & | intMap, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Deallocate the memory used by the specified intMap
(but not memory allocated for its contained elements) using the specified basicAllocator
. This method does not destroy individual map elements and the memory allocated for those elements must be explicitly deallocated before calling this method. The behavior is undefined unless map
was created with createUninitializedIntMap
using basicAllocator
.
static void bdld::Datum::disposeUninitializedMap | ( | const DatumMutableMapRef & | map, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
static void bdld::Datum::disposeUninitializedMap | ( | const DatumMutableMapOwningKeysRef & | map, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
Deallocate the memory used by the specified map
(but not memory allocated for its contained elements) using the specified basicAllocator
. This method does not destroy individual map elements and the memory allocated for those elements must be explicitly deallocated before calling this method. The behavior is undefined unless map
was created with createUninitializedMap
using basicAllocator
.
bdld::Datum::BSLMF_NESTED_TRAIT_DECLARATION | ( | Datum | , | |
bsl::is_trivially_copyable | ||||
) |
bdld::Datum::BSLMF_NESTED_TRAIT_DECLARATION | ( | Datum | , | |
bsl::is_trivially_default_constructible | ||||
) |
bdld::Datum::BSLMF_NESTED_TRAIT_DECLARATION | ( | Datum | , | |
bslmf::IsBitwiseMoveable | ||||
) |
bdld::Datum::BSLMF_NESTED_TRAIT_DECLARATION | ( | Datum | , | |
bdlb::HasPrintMethod | ||||
) |
Assign to this object the value of the specified rhs
object. Note that this method's definition is compiler generated.
void bdld::Datum::apply | ( | BDLD_VISITOR & | visitor | ) | const |
Apply the specified visitor
to the current value represented by this object by passing held value to the visitor
object's operator()
overload.
Datum bdld::Datum::clone | ( | bslma::Allocator * | basicAllocator | ) | const |
Return a datum holding a "deep-copy" of this object, using the specified basicAllocator
to supply memory. This method creates an independent deep-copy of the data of this object, including any referenced data, with the exception of User Defined Types. For further information see Deep Copying.
bool bdld::Datum::isArray | ( | ) | const |
Return true
if this object represents an array of Datum
s and false
otherwise.
bool bdld::Datum::isBinary | ( | ) | const |
Return true
if this object represents a binary value and false
otherwise.
bool bdld::Datum::isBoolean | ( | ) | const |
Return true
if this object represents a boolean value and false
otherwise.
bool bdld::Datum::isDate | ( | ) | const |
Return true
if this object represents a bdlt::Date
value and false
otherwise.
bool bdld::Datum::isDatetime | ( | ) | const |
Return true
if this object represents a bdlt::Datetime
value and false
otherwise.
bool bdld::Datum::isDatetimeInterval | ( | ) | const |
Return true
if this object represents a bdlt::DatetimeInterval
value and false
otherwise.
bool bdld::Datum::isDecimal64 | ( | ) | const |
Return true
if this object represents a bdlfpd::Decimal64
value and false
otherwise.
bool bdld::Datum::isDouble | ( | ) | const |
Return true
if this object represents a double
value and false
otherwise.
bool bdld::Datum::isError | ( | ) | const |
Return true
if this object represents a DatumError
value and false
otherwise.
bool bdld::Datum::isExternalReference | ( | ) | const |
Return true
if this object represents a reference to an externally managed array, string or user-defined object and false
otherwise. If this method returns false
, calling destroy
on this object will release the memory used by the array, string, or used-defined object as well as any meta-data directly used by this datum (e.g., length information); otherwise (if this method returns true
) calling destroy
on this object will release any allocated meta-data, but will not impact the externally managed array, string, or user-defined object.
bool bdld::Datum::isInteger | ( | ) | const |
Return true
if this object represents an integer value and false
otherwise.
bool bdld::Datum::isInteger64 | ( | ) | const |
Return true
if this object represents a Int64
value and false
otherwise.
bool bdld::Datum::isIntMap | ( | ) | const |
Return true
if this object represents a map of datums that are keyed by 32-bit int values and false
otherwise.
bool bdld::Datum::isMap | ( | ) | const |
Return true
if this object represents a map of datums that are keyed by string values and false
otherwise.
bool bdld::Datum::isNull | ( | ) | const |
Return true
if this object represents no value and false
otherwise.
bool bdld::Datum::isString | ( | ) | const |
Return true
if this object represents a string value and false
otherwise.
bool bdld::Datum::isTime | ( | ) | const |
Return true
if this object represents a bdlt::Time
value and false
otherwise.
bool bdld::Datum::isUdt | ( | ) | const |
Return true
if this object represents a DatumUdt
value and false
otherwise.
DatumArrayRef bdld::Datum::theArray | ( | ) | const |
Return the array value represented by this object as a DatumArrayRef
object. The behavior is undefined unless this object actually represents an array of datums.
DatumBinaryRef bdld::Datum::theBinary | ( | ) | const |
Return the binary reference represented by this object as a DatumBinaryRef
object. The behavior is undefined unless this object actually represents a binary reference.
bool bdld::Datum::theBoolean | ( | ) | const |
Return the boolean value represented by this object. The behavior is undefined unless this object actually represents a bool
value.
bdlt::Date bdld::Datum::theDate | ( | ) | const |
Return the date value represented by this object as a bdlt::Date
object. The behavior is undefined unless this object actually represents a date value.
bdlt::Datetime bdld::Datum::theDatetime | ( | ) | const |
Return the date+time value represented by this object as a bdlt::Datetime
object. The behavior is undefined unless this object actually represents date+time value.
bdlt::DatetimeInterval bdld::Datum::theDatetimeInterval | ( | ) | const |
Return the date+time interval value represented by this object as a bdlt::DatetimeInterval
. The behavior is undefined unless this object actually represents a date+time interval value.
bdldfp::Decimal64 bdld::Datum::theDecimal64 | ( | ) | const |
Return the decimal floating point value represented by this object as a bdlfpd::Decimal64
value. The behavior is undefined unless this object actually represents a decimal floating point value.
double bdld::Datum::theDouble | ( | ) | const |
Return the double value represented by this object. The behavior is undefined unless this object actually represents a double value. If the returned value is NaN this method guarantees only that a NaN value will be returned. The sign and NaN payload bits of NaN values returned are unspecified (see also Special Floating Point Values.
DatumError bdld::Datum::theError | ( | ) | const |
Return the error value represented by this object as a DatumError
value. The behavior is undefined unless this object actually represents an error value.
int bdld::Datum::theInteger | ( | ) | const |
Return the integer value represented by this object. The behavior is undefined unless this object actually represents an integer value.
bsls::Types::Int64 bdld::Datum::theInteger64 | ( | ) | const |
Return the 64-bit integer value represented by this object as a Int64
value. The behavior is undefined unless this object actually represents a 64-bit integer value.
DatumIntMapRef bdld::Datum::theIntMap | ( | ) | const |
Return the int-map value represented by this object as a DatumIntMapRef
object. The behavior is undefined unless this object actually represents an int-map of datums.
DatumMapRef bdld::Datum::theMap | ( | ) | const |
Return the map value represented by this object as a DatumMapRef
object. The behavior is undefined unless this object actually represents a map of datums.
bslstl::StringRef bdld::Datum::theString | ( | ) | const |
Return the string value represented by this object as a bslstl::StringRef
object. The behavior is undefined unless this object actually represents a string value.
bdlt::Time bdld::Datum::theTime | ( | ) | const |
Return the time value represented by this object as a bdlt::Time
object. The behavior is undefined unless this object actually represents a time value.
DatumUdt bdld::Datum::theUdt | ( | ) | const |
Return the user-defined object represented by this object as a DatumUdt
object. The behavior is undefined unless this object actually represents a user-defined object.
DataType bdld::Datum::type | ( | ) | const |
Return the type of value represented by this object as one of the enumeration values defined in DataType
.
bsl::ostream& bdld::Datum::print | ( | bsl::ostream & | stream, | |
int | level = 0 , |
|||
int | spacesPerLevel = 4 | |||
) | const |
Write the value of this object to the specified output stream
in a human-readable format, and return a reference to the modifiable stream
. Optionally specify an initial indentation level
, whose absolute value is incremented recursively for nested objects. If level
is specified, optionally specify spacesPerLevel
, whose absolute value indicates the number of spaces per indentation level for this and all of its nested objects. If level
is negative, suppress indentation of the first line. If spacesPerLevel
is negative, format the entire output on one line, suppressing all but the initial indentation (as governed by level
). If stream
is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, and can change without notice.
static void bdld::Datum::createUninitializedMapOwningKeys | ( | DatumMutableMapOwningKeysRef * | result, | |
SizeType | capacity, | |||
SizeType | keysCapacity, | |||
bslma::Allocator * | basicAllocator | |||
) | [static] |
[!DEPRECATED!] Use createUninitializedMap
instead.
static Datum bdld::Datum::adoptMapOwningKeys | ( | const DatumMutableMapOwningKeysRef & | mapping | ) | [static] |
[!DEPRECATED!] Use adoptMap
instead.
static void bdld::Datum::disposeUninitializedMapOwningKeys | ( | const DatumMutableMapOwningKeysRef & | mapping, | |
bslma::Allocator * | basicAllocator | |||
) | [static] |
[!DEPRECATED!] Use disposeUninitializedMap
instead.
Return true
if the specified lhs
and rhs
represent the same value, and false
otherwise. Two datums (not holding strings and user- defined objects) represent the same value if they have the same type of value stored inside them and invoking ==
operator on the stored values returns true
. Two datums holding strings are equal if the strings have the same length and and values at each respective character position are also same. Two datums holding user-defined objects are equal if the user-defined objects have the same pointer and type values. Two nil
datums are always equal. Two Datum
objects holding NaN
values are never equal. Two datums that hold arrays of datums have the same value if the underlying arrays have the same length and invoking ==
operator on each corresponding element returns true
. Two datums that hold maps of datums have the same value if the underlying maps have the same size and each corresponding pair of elements in the maps have the same keys and invoking ==
operator on the values returns true
.
Return true
if the specified lhs
and rhs
datums do not represent the same value, and false
otherwise. Two datums do not represent the same value if they do not hold values of the same type, or they hold values of the same type but invoking ==
operator on the stored values returns false
. Two strings do not have the same value if they have different lengths or values at one of the respective character position are not the same. Two DatumUdt
objects are not equal if they have different pointer or type values. Two bdemf_Nil
values are always equal. Two datums with NaN
values are never equal. Two datums that hold arrays of datums have different values if the underlying arrays have different lengths or invoking ==
operator on at least one of the corresponding pair of contained elements returns false
. Two datums that hold maps of datums have different values if the underlying maps have different sizes or at least one of the corresponding pair of elements in the maps have different keys or invoking ==
operator on the values returns false
.
bsl::ostream& operator<< | ( | bsl::ostream & | stream, | |
const Datum & | rhs | |||
) | [friend] |
Write the specified rhs
value to the specified output stream
in the format shown in the second column in the table below (based on the type of value stored, indicated by the first column):
null - nil bool - true/false DatumError - error(code)/error(code, 'msg') where 'code' is the integer error code and 'msg' is the error description message int - plain integer value Int64 - plain Int64 value double - plain double value string - plain double-quoted string value array - [ elem0, ..., elemN] where elem1..elemN are output for individual array elements int-map - [key0 = val0, ..., keyN = valN] where keyX and valX are respectively key and value of the map entry elements of the map map - [key0 = val0, ..., keyN = valN] where keyX and valX are respectively key and value of the map entry elements of the map bdlt::Date - ddMONyyyy bdlt::Time - hh:mm:ss.sss bdlt::Datetime - ddMONyyyy_hh:mm:ss.sss bdlt::DatetimeInterval - sDD_HH:MM:SS.SSS (where s is the sign(+/-)) DatumUdt - user-defined(address,type) where 'address' is a hex encoded pointer to the user-defined object and 'type' is its type
and return a reference to the modifiable stream
. The function will have no effect if the specified stream
is not valid.
TypedAccess bdld::Datum::d_as |