blpapi Namespace Reference [Component blpapi_abstractsession, Component blpapi_constant, Component blpapi_correlationid, Component blpapi_datetime, Component blpapi_diagnosticsutil, Component blpapi_element, Component blpapi_error, Component blpapi_event, Component blpapi_eventdispatcher, Component blpapi_eventformatter, Component blpapi_exception, Component blpapi_highresolutionclock, Component blpapi_identity, Component blpapi_logging, Component blpapi_message, Component blpapi_name, Component blpapi_providersession, Component blpapi_request, Component blpapi_resolutionlist, Component blpapi_schema, Component blpapi_service, Component blpapi_session, Component blpapi_sessionoptions, Component blpapi_streamproxy, Component blpapi_subscriptionlist, Component blpapi_timepoint, Component blpapi_topic, Component blpapi_topiclist, Component blpapi_types, Component blpapi_versioninfo]

Classes
class	AbstractSession
class	Constant
class	ConstantList
class	CorrelationId
struct	DatetimeParts
class	Datetime
struct	DatetimeUtil
class	DiagnosticsUtil
class	Element
class	Event
class	EventQueue
class	MessageIterator
class	EventDispatcher
class	EventFormatter
class	Exception
class	DuplicateCorrelationIdException
class	InvalidStateException
class	InvalidArgumentException
class	InvalidConversionException
class	IndexOutOfRangeException
class	FieldNotFoundException
class	UnknownErrorException
class	UnsupportedOperationException
class	NotFoundException
class	ExceptionUtil
struct	HighResolutionClock
class	Identity
struct	Logging
class	Message
class	Name
class	ProviderEventHandler
class	ServiceRegistrationOptions
class	ProviderSession
class	Request
class	RequestRef
class	ResolutionList
struct	SchemaStatus
class	SchemaElementDefinition
class	SchemaTypeDefinition
class	Operation
class	Service
class	EventHandler
class	Session
class	SubscriptionIterator
class	SessionOptions
struct	StreamProxyOstream
class	SubscriptionList
struct	TimePointUtil
class	Topic
class	TopicList
struct	DataType
class	VersionInfo
Typedefs
typedef Identity	UserHandle
typedef blpapi_TimePoint_t	TimePoint
typedef blpapi_Bool_t	Bool
typedef blpapi_Char_t	Char
typedef blpapi_UChar_t	UChar
typedef blpapi_Int16_t	Int16
typedef blpapi_UInt16_t	UInt16
typedef blpapi_Int32_t	Int32
typedef blpapi_UInt32_t	UInt32
typedef blpapi_Int64_t	Int64
typedef blpapi_UInt64_t	UInt64
typedef blpapi_Float32_t	Float32
typedef blpapi_Float64_t	Float64
Functions
bool	operator== (const CorrelationId &lhs, const CorrelationId &rhs)
bool	operator!= (const CorrelationId &lhs, const CorrelationId &rhs)
bool	operator< (const CorrelationId &lhs, const CorrelationId &rhs)
bool	operator== (const Datetime &lhs, const Datetime &rhs)
bool	operator!= (const Datetime &lhs, const Datetime &rhs)
bool	operator< (const Datetime &lhs, const Datetime &rhs)
bool	operator<= (const Datetime &lhs, const Datetime &rhs)
bool	operator> (const Datetime &lhs, const Datetime &rhs)
bool	operator>= (const Datetime &lhs, const Datetime &rhs)
std::ostream &	operator<< (std::ostream &stream, const Datetime &datetime)
std::ostream &	operator<< (std::ostream &stream, const Element &element)
std::ostream &	operator<< (std::ostream &stream, const Message &message)
bool	operator== (const Name &lhs, const Name &rhs)
bool	operator!= (const Name &lhs, const Name &rhs)
bool	operator== (const Name &lhs, const char *rhs)
bool	operator!= (const Name &lhs, const char *rhs)
bool	operator== (const char *lhs, const Name &rhs)
bool	operator!= (const char *lhs, const Name &rhs)
bool	operator< (const Name &lhs, const Name &rhs)
bool	operator<= (const Name &lhs, const Name &rhs)
bool	operator> (const Name &lhs, const Name &rhs)
bool	operator>= (const Name &lhs, const Name &rhs)
std::ostream &	operator<< (std::ostream &stream, const Name &name)
static void	providerEventHandlerProxy (blpapi_Event_t *event, blpapi_ProviderSession_t *session, void *userData)
std::ostream &	operator<< (std::ostream &stream, const Request &request)
std::ostream &	operator<< (std::ostream &stream, const SchemaElementDefinition &element)
std::ostream &	operator<< (std::ostream &stream, const SchemaTypeDefinition &typeDef)
std::ostream &	operator<< (std::ostream &stream, const Service &service)
void	eventHandlerAdapter (blpapi_Event_t *event, blpapi_Session_t *, void *userData)
int	OstreamWriter (const char *data, int length, void *stream)
bool	operator== (Topic const &lhs, Topic const &rhs)
bool	operator!= (Topic const &lhs, Topic const &rhs)
bool	operator< (Topic const &lhs, Topic const &rhs)
std::ostream &	operator<< (std::ostream &stream, const VersionInfo &rhs)

---

Typedef Documentation

typedef Identity blpapi::UserHandle

typedef blpapi_TimePoint_t blpapi::TimePoint

typedef blpapi_Bool_t blpapi::Bool

typedef blpapi_Char_t blpapi::Char

typedef blpapi_UChar_t blpapi::UChar

typedef blpapi_Int16_t blpapi::Int16

typedef blpapi_UInt16_t blpapi::UInt16

typedef blpapi_Int32_t blpapi::Int32

typedef blpapi_UInt32_t blpapi::UInt32

typedef blpapi_Int64_t blpapi::Int64

typedef blpapi_UInt64_t blpapi::UInt64

typedef blpapi_Float32_t blpapi::Float32

typedef blpapi_Float64_t blpapi::Float64

---

Function Documentation

bool blpapi::operator==	(	const CorrelationId &	lhs,
		const CorrelationId &	rhs
	)			[inline]

Return true if the specified lhs and rhs CorrelationId objects contain the same value. Return false otherwise. Two CorrelationId objects contain the same value if the result of valueType() is the same and the result of asPointer() or asInteger() as appropriate is also the same.

bool blpapi::operator!=	(	const CorrelationId &	lhs,
		const CorrelationId &	rhs
	)			[inline]

Equivalent to !(lhs==rhs).

bool blpapi::operator<	(	const CorrelationId &	lhs,
		const CorrelationId &	rhs
	)			[inline]

Return true if the value of the specified lhs CorrelationId object is less than the value of the specified rhs CorrelationId object. Return false otherwise. The operator takes account of the value of the CorrelationId as well as its valueType() to ensure a consistent ordering amongst CorrelationIds regardless of whether they are generated by the API or the user. The operator is provided solely for convenience for operations such as insertion into ordered containers.

bool blpapi::operator==	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two Datetime objects have the same value if they have the same parts set, and the same values for each of those parts.

bool blpapi::operator!=	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

Return true if the specified lhs and rhs do not have the same value, and false otherwise. Two Datetime objects have the same value if they have the same parts set, and the same values for each of those parts.

bool blpapi::operator<	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

bool blpapi::operator<=	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

bool blpapi::operator>	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

bool blpapi::operator>=	(	const Datetime &	lhs,
		const Datetime &	rhs
	)

Compare the specified lhs and rhs. The ordering used is temporal, with earlier moments comparing less than later moments, in the case that lhs.parts() == rhs.parts() and parts() is one of DATE, TIME, TIMEFRACSECONDS, DATE | TIME, and DATE | TIMEFRACSECONDS; the ordering in all other cases is unspecified, but guaranteed stable within process.

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Datetime &	datetime
	)

Write the value of the specified datetime 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);

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Element &	element
	)

Write the value of the specified element 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);

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Message &	message
	)

Write the value of the specified message 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 blpapi::operator==	(	const Name &	lhs,
		const Name &	rhs
	)

Return true if the specified lhs and rhs name objects have the same value, and false otherwise. Two Name objects a and b have the same value if and only if strcmp(a.string(), b.string()) == 0.

bool blpapi::operator!=	(	const Name &	lhs,
		const Name &	rhs
	)

Return false if the specified lhs and rhs name objects have the same value, and true otherwise. Two Name objects a and b have the same value if and only if strcmp(a.string(), b.string()) == 0. Note that lhs != rhs is equivalent to !(lhs==rhs).

bool blpapi::operator==	(	const Name &	lhs,
		const char *	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. A Name object a and a null-terminated string b have the same value if and only if strcmp(a.string(), b) == 0. The behavior is undefined unless rhs is a null-terminated string.

bool blpapi::operator!=	(	const Name &	lhs,
		const char *	rhs
	)

Return false if the specified lhs and rhs have the same value, and true otherwise. A Name object a and a null-terminated string b have the same value if and only if strcmp(a.string(), b) == 0. The behavior is undefined unless rhs is a null-terminated string.

bool blpapi::operator==	(	const char *	lhs,
		const Name &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. A Name object a and a null-terminated string b have the same value if and only if strcmp(a.string(), b) == 0. The behavior is undefined unless lhs is a null-terminated string.

bool blpapi::operator!=	(	const char *	lhs,
		const Name &	rhs
	)

Return false if the specified lhs and rhs have the same value, and true otherwise. A Name object a and a null-terminated string b have the same value if and only if strcmp(a.string(), b) == 0. The behavior is undefined unless lhs is a null-terminated string.

bool blpapi::operator<	(	const Name &	lhs,
		const Name &	rhs
	)

Return true if the specified lhs is ordered before the specified rhs, and false otherwise. The ordering used is stable within the lifetime of a single process and is compatible with operator==(const Name&, const Name&), however this order is neither guaranteed to be consistent across different processes (including repeated runs of the same process), nor guaranteed to be lexical (i.e. compatible with strcmp).

bool blpapi::operator<=	(	const Name &	lhs,
		const Name &	rhs
	)

Return false if the specified rhs is ordered before the specified lhs, and true otherwise. The ordering used is stable within the lifetime of a single process and is compatible with operator==(const Name&, const Name&), however this order is neither guaranteed to be consistent across different processes (including repeated runs of the same process), nor guaranteed to be lexical (i.e. compatible with strcmp).

bool blpapi::operator>	(	const Name &	lhs,
		const Name &	rhs
	)

Return true if the specified rhs is ordered before the specified lhs, and false otherwise. The ordering used is stable within the lifetime of a single process and is compatible with operator==(const Name&, const Name&), however this order is neither guaranteed to be consistent across different processes (including repeated runs of the same process), nor guaranteed to be lexical (i.e. compatible with strcmp).

bool blpapi::operator>=	(	const Name &	lhs,
		const Name &	rhs
	)

Return false if the specified lhs is ordered before the specified rhs, and true otherwise. The ordering used is stable within the lifetime of a single process and is compatible with operator==(const Name&, const Name&), however this order is neither guaranteed to be consistent across different processes (including repeated runs of the same process), nor guaranteed to be lexical (i.e. compatible with strcmp).

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Name &	name
	)

Write the value of the specified name object to the specified output stream, and return a reference to stream. Note that this human-readable format is not fully specified and can change without notice.

static void blpapi::providerEventHandlerProxy	(	blpapi_Event_t *	event,
		blpapi_ProviderSession_t *	session,
		void *	userData
	)			[static]

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Request &	request
	)

Write the value of the specified request 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);

================ class RequestRef ================

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const SchemaElementDefinition &	element
	)

Write the value of the specified element 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);

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const SchemaTypeDefinition &	typeDef
	)

Write the value of the specified typeDef 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);

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const Service &	service
	)

Write the value of the specified service 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);

void blpapi::eventHandlerAdapter	(	blpapi_Event_t *	event,
		blpapi_Session_t *	,
		void *	userData
	)

Adapter blpapi_EventHandler_t implementation that dispatches the specified event to a blpapi::Session pointed by userData.

int blpapi::OstreamWriter	(	const char *	data,
		int	length,
		void *	stream
	)			[inline]

bool blpapi::operator==	(	Topic const &	lhs,
		Topic const &	rhs
	)

bool blpapi::operator!=	(	Topic const &	lhs,
		Topic const &	rhs
	)

bool blpapi::operator<	(	Topic const &	lhs,
		Topic const &	rhs
	)

std::ostream& blpapi::operator<<	(	std::ostream &	stream,
		const VersionInfo &	rhs
	)

Output the specified rhs to the specified stream in a human-readable format. Note that the exact details of this format are not specified and may be differ between different library versions.