bdld Namespace Reference

Classes
class	Datum
struct	Datum_Helpers
struct	Datum_IntMapHeader
struct	Datum_MakeDependent
struct	Datum_MapHeader
class	DatumArrayBuilder
class	DatumArrayRef
class	DatumBinaryRef
class	DatumError
class	DatumIntMapBuilder
class	DatumIntMapEntry
class	DatumIntMapRef
class	DatumMaker
class	DatumMapBuilder
class	DatumMapEntry
class	DatumMapOwningKeysBuilder
class	DatumMapRef
class	DatumMutableArrayRef
class	DatumMutableIntMapRef
class	DatumMutableMapOwningKeysRef
class	DatumMutableMapRef
class	DatumUdt
struct	DatumUtil
class	ManagedDatum

Functions
bool	operator== (const Datum &lhs, const Datum &rhs)
bool	operator!= (const Datum &lhs, const Datum &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Datum &rhs)
template<class t_HASH_ALGORITHM >
void	hashAppend (t_HASH_ALGORITHM &hashAlgorithm, const Datum &datum)
bsl::ostream &	operator<< (bsl::ostream &stream, Datum::DataType rhs)
bool	operator== (const DatumArrayRef &lhs, const DatumArrayRef &rhs)
bool	operator!= (const DatumArrayRef &lhs, const DatumArrayRef &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumArrayRef &rhs)
bool	operator== (const DatumIntMapEntry &lhs, const DatumIntMapEntry &rhs)
bool	operator!= (const DatumIntMapEntry &lhs, const DatumIntMapEntry &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumIntMapEntry &rhs)
bool	operator== (const DatumIntMapRef &lhs, const DatumIntMapRef &rhs)
bool	operator!= (const DatumIntMapRef &lhs, const DatumIntMapRef &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumIntMapRef &rhs)
bool	operator== (const DatumMapEntry &lhs, const DatumMapEntry &rhs)
bool	operator!= (const DatumMapEntry &lhs, const DatumMapEntry &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumMapEntry &rhs)
bool	operator== (const DatumMapRef &lhs, const DatumMapRef &rhs)
bool	operator!= (const DatumMapRef &lhs, const DatumMapRef &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumMapRef &rhs)
bool	operator== (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bool	operator!= (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bool	operator< (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bool	operator> (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bool	operator<= (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bool	operator>= (const DatumBinaryRef &lhs, const DatumBinaryRef &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumBinaryRef &rhs)
bool	operator== (const DatumError &lhs, const DatumError &rhs)
bool	operator!= (const DatumError &lhs, const DatumError &rhs)
bool	operator< (const DatumError &lhs, const DatumError &rhs)
bool	operator<= (const DatumError &lhs, const DatumError &rhs)
bool	operator> (const DatumError &lhs, const DatumError &rhs)
bool	operator>= (const DatumError &lhs, const DatumError &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumError &rhs)
bool	operator== (const DatumUdt &lhs, const DatumUdt &rhs)
bool	operator!= (const DatumUdt &lhs, const DatumUdt &rhs)
bool	operator< (const DatumUdt &lhs, const DatumUdt &rhs)
bool	operator<= (const DatumUdt &lhs, const DatumUdt &rhs)
bool	operator> (const DatumUdt &lhs, const DatumUdt &rhs)
bool	operator>= (const DatumUdt &lhs, const DatumUdt &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const DatumUdt &rhs)
bool	operator== (const ManagedDatum &lhs, const ManagedDatum &rhs)
bool	operator!= (const ManagedDatum &lhs, const ManagedDatum &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const ManagedDatum &rhs)
void	swap (ManagedDatum &a, ManagedDatum &b)

Function Documentation

hashAppend()

template<class t_HASH_ALGORITHM >

void bdld::hashAppend	(	t_HASH_ALGORITHM &	hashAlgorithm,
		const Datum &	datum
	)

Invoke the specified hashAlgorithm on the value of the specified datum object. Note that the value of a User Defined Type in Datum is a combination of its type integer and the address (pointer value), not the actual value of the object that the pointer points to.

operator!=() [1/10]

bool bdld::operator!=	(	const Datum &	lhs,
		const Datum &	rhs
	)

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 bslmf::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.

operator!=() [2/10]

bool bdld::operator!=	(	const DatumArrayRef &	lhs,
		const DatumArrayRef &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumArrayRef objects have different values if they hold arrays of different lengths or invoking operator == returns false for at least one of the corresponding elements in the arrays.

operator!=() [3/10]

bool bdld::operator!=	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs and rhs have different values, and true otherwise. Two DatumBinaryRef objects have different values if they refer to arrays of bytes of different sizes or having a different content.

operator!=() [4/10]

bool bdld::operator!=	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if the specified lhs and rhs have different values and false otherwise. Two DatumError objects have different values if they have different error code or message values.

operator!=() [5/10]

bool bdld::operator!=	(	const DatumIntMapEntry &	lhs,
		const DatumIntMapEntry &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumIntMapEntry objects have different values if either the keys or values are not equal.

operator!=() [6/10]

bool bdld::operator!=	(	const DatumIntMapRef &	lhs,
		const DatumIntMapRef &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumIntMapRef objects have different values if they hold maps of different sizes or operator == returns false for at least one of the corresponding elements in the maps.

operator!=() [7/10]

bool bdld::operator!=	(	const DatumMapEntry &	lhs,
		const DatumMapEntry &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumMapEntry objects have different values if either the keys or values are not equal.

operator!=() [8/10]

bool bdld::operator!=	(	const DatumMapRef &	lhs,
		const DatumMapRef &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumMapRef objects have different values if they hold maps of different sizes or operator == returns false for at least one of the corresponding elements in the maps.

operator!=() [9/10]

bool bdld::operator!=	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if the specified lhs and rhs have different values, and false otherwise. Two DatumUdt objects have different values if they have different data or type values.

operator!=() [10/10]

bool bdld::operator!=	(	const ManagedDatum &	lhs,
		const ManagedDatum &	rhs
	)

Return true if the specified lhs and rhs ManagedDatum objects do not have the same value, and false otherwise. Two ManagedDatum objects do not have the same value if their corresponding managed Datum objects do not have the same value. See the function-level documentation of the Datum equality-comparison operators for details.

operator<() [1/3]

bool bdld::operator<	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs compares smaller than the specified rhs, and false otherwise. A byte comparision is performed using memcpy.

operator<() [2/3]

bool bdld::operator<	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if value of the specified lhs is less than value of the specified rhs and false otherwise. Value of lhs is less than value of rhs if error code value of lhs is less than error code value of rhs, or they have the same error code value and error message value of lhs is less than error message value of rhs.

operator<() [3/3]

bool bdld::operator<	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if value of the specified lhs is less than value of the specified rhs and false otherwise. Value of lhs is less than value of rhs, if data value of lhs is less than data value of rhs, or they have the same data value and type value of lhs is less than type value of rhs.

operator<<() [1/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const Datum &	rhs
	)

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.

operator<<() [2/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumArrayRef &	rhs
	)

Write the specified rhs value to the specified output stream in the format shown below:

[aa,bb,cc] - aa, bb and cc are the result of invoking operator `<<`
             on the individual elements in the array

and return a reference to the modifiable stream. The function will have no effect if the stream is not valid.

operator<<() [3/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumBinaryRef &	rhs
	)

Write the value of the specified rhs object to the specified output stream in a single-line format, and return a reference to the modifyable stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:

print(stream, 0, -1);

operator<<() [4/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumError &	rhs
	)

Write the value of the specified rhs object to the specified output stream in a single-line format, and return a reference to the modifyable stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:

print(stream, 0, -1);

Single line output format for the DatumError object is shown below:

error(n)
error(n,'msg')

(where n is the integer error code value and msg is the error message value in single quotes). Note that the first version will be output if there is no error message string.

operator<<() [5/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumIntMapEntry &	rhs
	)

Write the specified rhs value to the specified output stream in the format shown below:

(nnn,aa) - nnn is key integer, while aa is the result of invoking
           operator `<<` on the value

and return a reference to the modifiable stream. The function will have no effect if the stream is not valid.

operator<<() [6/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumIntMapRef &	rhs
	)

Write the specified rhs value to the specified output stream in the format shown below:

[ nnn = aa, mmm = bb] - nnn and mmm are key ints, while aa and bb
                        are the result of invoking operator `<<` on the
                        individual value elements in the map

and return a reference to the modifiable stream. The function will have no effect if the stream is not valid.

operator<<() [7/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumMapEntry &	rhs
	)

Write the specified rhs value to the specified output stream in the format shown below:

(abc,aa) - abc is key string, while aa is the result of invoking
           operator `<<` on the value

and return a reference to the modifiable stream. The function will have no effect if the stream is not valid.

operator<<() [8/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumMapRef &	rhs
	)

Write the specified rhs value to the specified output stream in the format shown below:

[ abc = aa, pqr = bb] - abc and pqr are key strings, while aa and bb
                        are the result of invoking operator '<<' on the
                        individual value elements in the map

and return a reference to the modifiable stream. The function will have no effect if the stream is not valid.

operator<<() [9/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const DatumUdt &	rhs
	)

Write the value of the specified rhs object to the specified output stream in a single-line format, and return a reference to the modifyable stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:

print(stream, 0, -1);

Single line output format for the DatumUdt object is shown below:

user-defined(<address>,type)

(where address is hex value of the pointer to the user-define object and type is the type of the user-defined object)

operator<<() [10/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		const ManagedDatum &	rhs
	)

Write the specified rhs value to the specified output stream and return a reference to the modifiable stream. This function has no effect if stream is not valid on entry. Note that this method invokes operator<< defined for Datum. See the function-level documentation of the operator<< defined for Datum for details of the format of the output.

operator<<() [11/11]

bsl::ostream & bdld::operator<<	(	bsl::ostream &	stream,
		Datum::DataType	rhs
	)

Write the string representation of the specified enumeration rhs to the specified stream in a single-line format, and return a reference to the modifiable stream. See dataTypeToAscii for what constitutes the string representation of a Datum::DataType value.

operator<=() [1/3]

bool bdld::operator<=	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs compares smaller than or equal to the specified rhs, and false otherwise. A byte comparision is performed using memcpy.

operator<=() [2/3]

bool bdld::operator<=	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if value of the specified lhs is less than or equal to value of the specified rhs and false otherwise. Value of lhs is less than or equal to value of rhs if error code value of lhs is less than or equal to error code value of rhs, or they have the same error code value and error message value of lhs is less than or equal to error message value of rhs.

operator<=() [3/3]

bool bdld::operator<=	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if value of the specified lhs is less than or equal to value of the specified rhs and false otherwise. Value of lhs is less than or equal to value of rhs, if data value of lhs is less than or equal to data value of rhs, or they have the same data value and type value of lhs is less than or equal to type value of rhs.

operator==() [1/10]

bool bdld::operator==	(	const Datum &	lhs,
		const Datum &	rhs
	)

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.

operator==() [2/10]

bool bdld::operator==	(	const DatumArrayRef &	lhs,
		const DatumArrayRef &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumArrayRef objects have the same value if they hold arrays of the same length and all the corresponding Datum objects in the two arrays also compare equal.

operator==() [3/10]

bool bdld::operator==	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumBinaryRef objects have the same value if they refer to arrays of bytes of the same size and having the same content.

operator==() [4/10]

bool bdld::operator==	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if the specified lhs and rhs have the same value and false otherwise. Two DatumError objects have the same value if they have same error code and message values.

operator==() [5/10]

bool bdld::operator==	(	const DatumIntMapEntry &	lhs,
		const DatumIntMapEntry &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumIntMapEntry objects have the same value if their keys and values compare equal.

operator==() [6/10]

bool bdld::operator==	(	const DatumIntMapRef &	lhs,
		const DatumIntMapRef &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumIntMapRef objects have the same value if they hold maps of the same size and all the corresponding DatumIntMapEntry elements in the two maps also compare equal.

operator==() [7/10]

bool bdld::operator==	(	const DatumMapEntry &	lhs,
		const DatumMapEntry &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumMapEntry objects have the same value if their keys and values compare equal.

operator==() [8/10]

bool bdld::operator==	(	const DatumMapRef &	lhs,
		const DatumMapRef &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumMapRef objects have the same value if they hold maps of the same size and all the corresponding DatumMapEntry elements in the two maps also compare equal.

operator==() [9/10]

bool bdld::operator==	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two DatumUdt objects have the same value if they have the same data and type values.

operator==() [10/10]

bool bdld::operator==	(	const ManagedDatum &	lhs,
		const ManagedDatum &	rhs
	)

Return true if the specified lhs and rhs ManagedDatum objects have the same value, and false otherwise. Two ManagedDatum objects have the same value if their corresponding managed Datum objects have the same value. See the function-level documentation of the Datum equality-comparison operators for details.

operator>() [1/3]

bool bdld::operator>	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs compares larger than the specified rhs, and false otherwise. A byte comparision is performed using memcpy.

operator>() [2/3]

bool bdld::operator>	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if value of the specified lhs is greater than value of the specified rhs and false otherwise. Value of lhs is greater than value of rhs if error code value of lhs is greater than error code value of rhs, or they have the same error code value and error message value of lhs is greater than error message value of rhs.

operator>() [3/3]

bool bdld::operator>	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if value of the specified lhs is greater than value of the specified rhs and false otherwise. Value of lhs is greater than value of rhs, if data value of lhs is greater than data value of rhs, or they have the same data value and type value of lhs is greater than type value of rhs.

operator>=() [1/3]

bool bdld::operator>=	(	const DatumBinaryRef &	lhs,
		const DatumBinaryRef &	rhs
	)

Return true if the specified lhs compares larger than or equal to the specified rhs, and false otherwise. A byte comparision is performed using memcpy.

operator>=() [2/3]

bool bdld::operator>=	(	const DatumError &	lhs,
		const DatumError &	rhs
	)

Return true if value of the specified lhs is greater than or equal to value of the specified rhs and false otherwise. Value of lhs is greater than or equal to value of rhs if error code value of lhs is greater than or equal to error code value of rhs, or they have the same error code value and error message value of lhs is greater than or equal to error message value of rhs.

operator>=() [3/3]

bool bdld::operator>=	(	const DatumUdt &	lhs,
		const DatumUdt &	rhs
	)

Return true if value of the specified lhs is greater than or equal to value of the specified rhs and false otherwise. Value of lhs is greater than or equal to value of rhs, if data value of lhs is greater than or equal to data value of rhs, or they have the same data value and type value of lhs is greater than or equal to type value of rhs.

swap()

void bdld::swap	(	ManagedDatum &	a,
		ManagedDatum &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise. Note that in case the allocators are different this function places a clone of a into b, and vice versa. See {Value Semantics} on details of the cloning that may happen.