bdljsn Namespace Reference [Component bdljsn_error, Component bdljsn_json, Component bdljsn_jsonliterals, Component bdljsn_jsonnull, Component bdljsn_jsonnumber, Component bdljsn_jsontype, Component bdljsn_jsonutil, Component bdljsn_location, Component bdljsn_numberutil, Component bdljsn_readoptions, Component bdljsn_stringutil, Component bdljsn_tokenizer, Component bdljsn_writeoptions, Component bdljsn_writestyle]

Classes
class	Error
class	JsonArray
class	JsonObject
class	Json
class	JsonNull
class	JsonNumber
struct	JsonType
struct	JsonUtil
class	Location
struct	NumberUtil
struct	NumberUtil_IsSigned
struct	NumberUtil_ImpUtil
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

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.

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.

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.

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.

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.

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);

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.

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.

template<class HASHALG >

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

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

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.

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);

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.

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.

template<class HASHALG >

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

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

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.

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);

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.

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.

template<class HASHALG >

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

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

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.

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

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

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

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

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);

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.

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.

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).

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.

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.

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.

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.

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);

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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);