bdljsn Namespace Reference

Classes
class	Error
class	Json
class	JsonArray
class	JsonNull
class	JsonNumber
class	JsonObject
struct	JsonTestSuiteUtil
struct	JsonType
struct	JsonUtil
class	Location
struct	NumberUtil
struct	NumberUtil_ImpUtil
struct	NumberUtil_IsSigned
class	ReadOptions
struct	StringUtil
class	Tokenizer
class	WriteOptions
struct	WriteStyle

Functions
bool	operator== (const Error &lhs, const Error &rhs)
bool	operator!= (const Error &lhs, const Error &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Error &object)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlgorithm, const Error &object)
void	swap (Error &a, Error &b)
bsl::ostream &	operator<< (bsl::ostream &stream, const JsonArray &object)
bool	operator== (const JsonArray &lhs, const JsonArray &rhs)
bool	operator!= (const JsonArray &lhs, const JsonArray &rhs)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlg, const JsonArray &object)
void	swap (JsonArray &a, JsonArray &b)
bsl::ostream &	operator<< (bsl::ostream &stream, const JsonObject &object)
bool	operator== (const JsonObject &lhs, const JsonObject &rhs)
bool	operator!= (const JsonObject &lhs, const JsonObject &rhs)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlg, const JsonObject &object)
void	swap (JsonObject &a, JsonObject &b)
bsl::ostream &	operator<< (bsl::ostream &stream, const Json &object)
bool	operator== (const Json &lhs, const Json &rhs)
bool	operator!= (const Json &lhs, const Json &rhs)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlg, const Json &object)
void	swap (Json &a, Json &b)
bool	operator== (const JsonNull &lhs, const JsonNull &rhs)
bool	operator!= (const JsonNull &lhs, const JsonNull &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const JsonNull &object)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlgorithm, const JsonNull &object)
void	swap (JsonNull &a, JsonNull &b)
bsl::ostream &	operator<< (bsl::ostream &stream, const JsonNumber &object)
bool	operator== (const JsonNumber &lhs, const JsonNumber &rhs)
bool	operator!= (const JsonNumber &lhs, const JsonNumber &rhs)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlgorithm, const JsonNumber &object)
void	swap (JsonNumber &a, JsonNumber &b)
bsl::ostream &	operator<< (bsl::ostream &stream, JsonType::Enum value)
bool	operator== (const Location &lhs, const Location &rhs)
bool	operator!= (const Location &lhs, const Location &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Location &object)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlg, const Location &object)
void	swap (Location &a, Location &b)
bool	operator== (const ReadOptions &lhs, const ReadOptions &rhs)
bool	operator!= (const ReadOptions &lhs, const ReadOptions &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const ReadOptions &rhs)
bool	operator== (const WriteOptions &lhs, const WriteOptions &rhs)
bool	operator!= (const WriteOptions &lhs, const WriteOptions &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const WriteOptions &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, WriteStyle::Enum value)

Function Documentation

hashAppend() [1/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlg,
		const Json &	object
	)

Invoke the specified hashAlg on the attributes of the specified object.

hashAppend() [2/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlg,
		const JsonArray &	object
	)

Invoke the specified hashAlg on the attributes of the specified object.

hashAppend() [3/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlg,
		const JsonObject &	object
	)

Invoke the specified hashAlg on the attributes of the specified object.

hashAppend() [4/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlg,
		const Location &	object
	)

Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for Location.

hashAppend() [5/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlgorithm,
		const Error &	object
	)

Pass the specified object to the specified hashAlgorithm. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for ErroError.

hashAppend() [6/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlgorithm,
		const JsonNull &	object
	)

Pass the specified object to the specified hashAlgorithm. This function allows JsonNull objects to be hashable using bsl::hash. Note that object always as the same value so, for a given state of hashAppend, the effect of calling hashAppend is always the same.

hashAppend() [7/7]

template<class HASHALG >

void bdljsn::hashAppend	(	HASHALG &	hashAlgorithm,
		const JsonNumber &	object
	)

Pass the specified object to the specified hashAlgorithm. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for JsonNumber.

operator!=() [1/9]

bool bdljsn::operator!=	(	const Error &	lhs,
		const Error &	rhs
	)

Return true if the specified lhs and rhs attribute objects do not have the same value, and false otherwise. Two attribute objects do not have the same value if one or more respective attributes differ in values.

operator!=() [2/9]

bool bdljsn::operator!=	(	const Json &	lhs,
		const Json &	rhs
	)

Return false if the specified lhs and rhs objects have the same value, and true otherwise. Two Json objects lhs and rhs have the same value if they hold objects of the same type, and those objects have the same value.

operator!=() [3/9]

bool bdljsn::operator!=	(	const JsonArray &	lhs,
		const JsonArray &	rhs
	)

Return false if the specified lhs and rhs objects have the same value, and true otherwise. Two JsonArray objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs.

operator!=() [4/9]

bool bdljsn::operator!=	(	const JsonNull &	lhs,
		const JsonNull &	rhs
	)

Return false (unconditionally) as the specified lhs and rhs cannot have the different values.

operator!=() [5/9]

bool bdljsn::operator!=	(	const JsonNumber &	lhs,
		const JsonNumber &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two JsonNumber objects do not have the same value if their value attributes are not the same.

operator!=() [6/9]

bool bdljsn::operator!=	(	const JsonObject &	lhs,
		const JsonObject &	rhs
	)

Return false if the specified lhs and rhs objects have the same value, and true otherwise. Two JsonObject objects have the same value if they have the same number of Member objects, and for each Member object that is contained in lhs there is a key-value pair contained in rhs having the same value, and vice versa.

operator!=() [7/9]

bool bdljsn::operator!= ( const Location &  lhs, const Location &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects do not have the same value, and false otherwise. Two attribute objects do not have the same value if one or more respective attributes differ in values.

operator!=() [8/9]

bool bdljsn::operator!= ( const ReadOptions &  lhs, const ReadOptions &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects do not have the same value, and false otherwise. Two attribute objects do not have the same value if one or more respective attributes do not have the same value.

operator!=() [9/9]

bool bdljsn::operator!= ( const WriteOptions &  lhs, const WriteOptions &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects do not have the same value, and false otherwise. Two attribute objects do not have the same value if one or more respective attributes differ in values.

operator<<() [1/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const Error &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a non-const reference to stream. 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. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.

operator<<() [2/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const Json &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to 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<<() [3/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const JsonArray &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to 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 & bdljsn::operator<<	(	bsl::ostream &	stream,
		const JsonNull &	object
	)

Write "null" – the invariant value of the specified object – to the specified output stream in a single-line format and return a reference to stream. Note that this method has the same behavior as

object.print(stream, 0, -1);

operator<<() [5/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const JsonNumber &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a non-const reference to stream. 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. Also note that this method has the same behavior as object.print(stream, 0, -1).

operator<<() [6/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const JsonObject &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to 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<<() [7/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		const Location &	object
	)

Write the value of the specified object to the specified output stream in a single-line format, and return a non-const reference to stream. 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. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.

operator<<() [8/11]

bsl::ostream & bdljsn::operator<< ( bsl::ostream &  stream, const ReadOptions &  rhs  )

inline

Format the specified rhs to the specified output stream in a single line format and return a non-const reference to stream.

operator<<() [9/11]

bsl::ostream & bdljsn::operator<< ( bsl::ostream &  stream, const WriteOptions &  rhs  )

inline

Format the specified rhs to the specified output stream and return a non-const reference stream.

operator<<() [10/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		JsonType::Enum	value
	)

Write the string representation of the specified enumeration value to the specified output stream in a single-line format, and return a reference to stream. See toAscii for what constitutes the string representation of a bdljsn::JsonType::Enum value. Note that this method has the same behavior as

bdljsn::JsonType::print(stream, value, 0, -1);

operator<<() [11/11]

bsl::ostream & bdljsn::operator<<	(	bsl::ostream &	stream,
		WriteStyle::Enum	value
	)

Write the string representation of the specified enumeration value to the specified output stream in a single-line format, and return a reference to stream. See toAscii for what constitutes the string representation of a bdljsn::WriteStyle::Enum value. Note that this method has the same behavior as

bdljsn::WriteStyle::print(stream, value, 0, -1);

operator==() [1/9]

bool bdljsn::operator==	(	const Error &	lhs,
		const Error &	rhs
	)

Return true if the specified lhs and rhs attribute objects have the same value, and false otherwise. Two attribute objects have the same value if each respective attribute has the same value.

operator==() [2/9]

bool bdljsn::operator==	(	const Json &	lhs,
		const Json &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Json objects lhs and rhs have the same value if they hold objects of the same type, and those objects have the same value.

operator==() [3/9]

bool bdljsn::operator==	(	const JsonArray &	lhs,
		const JsonArray &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two JsonArray objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs.

operator==() [4/9]

bool bdljsn::operator==	(	const JsonNull &	lhs,
		const JsonNull &	rhs
	)

Return true (unconditionally) as the specified lhs and rhs must have the same value.

operator==() [5/9]

bool bdljsn::operator==	(	const JsonNumber &	lhs,
		const JsonNumber &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two JsonNumber objects have the same value if their value attributes are the same.

operator==() [6/9]

bool bdljsn::operator==	(	const JsonObject &	lhs,
		const JsonObject &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two JsonObject objects have the same value if they have the same number of Member objects, and for each Member object that is contained in lhs there is a key-value pair contained in rhs having the same value, and vice versa.

operator==() [7/9]

bool bdljsn::operator== ( const Location &  lhs, const Location &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects have the same value, and false otherwise. Two attribute objects have the same value if each respective attribute has the same value.

operator==() [8/9]

bool bdljsn::operator== ( const ReadOptions &  lhs, const ReadOptions &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects have the same value, and false otherwise. Two attribute objects have the same value if each respective attribute has the same value.

operator==() [9/9]

bool bdljsn::operator== ( const WriteOptions &  lhs, const WriteOptions &  rhs  )

inline

Return true if the specified lhs and rhs attribute objects have the same value, and false otherwise. Two attribute objects have the same value if each respective attribute has the same value.

swap() [1/7]

void bdljsn::swap	(	Error &	a,
		Error &	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.

swap() [2/7]

void bdljsn::swap	(	Json &	a,
		Json &	b
	)

Exchange the value of the specified a Json object with that of the specified b Json object. If an exception is thrown, both objects are left in valid but unspecified states. This operation guarantees O[1] complexity. The behavior is undefined unless a was created with the same allocator as b.

swap() [3/7]

void bdljsn::swap	(	JsonArray &	a,
		JsonArray &	b
	)

Exchange the value of the specified a JsonArray with that of the specified b JsonArray. This function provides the no-throw exception-safety guarantee. This operation has O[1] complexity if a was created with the same allocator as b; otherwise, it has O[n+m] complexity, where n and m are the number of elements in a and b, respectively.

swap() [4/7]

void bdljsn::swap	(	JsonNull &	a,
		JsonNull &	b
	)

Exchange the values of the specified a and b objects. This exception provides the no-throw exception-safety guarantee. Note that, since a and b have the same value (a class invariant), this operation is a no-op.

swap() [5/7]

void bdljsn::swap	(	JsonNumber &	a,
		JsonNumber &	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.

swap() [6/7]

void bdljsn::swap	(	JsonObject &	a,
		JsonObject &	b
	)

Exchange the value of the specified a JsonObject with that of the specified b JsonObject. This function provides the no-throw exception-safety guarantee. This operation has O[1] complexity if a was created with the same allocator as b; otherwise, it has O[n+m] complexity, where n and m are the number of elements in a and b, respectively.

swap() [7/7]

void bdljsn::swap	(	Location &	a,
		Location &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee.