SPL Namespace Reference

C++ classes for writing operators. More...

Namespaces
	Functions
	C++ counterparts of SPL native functions.
	Meta
	C++ classes for type introspection.

Classes
class	AutoMutex
	Class that provides an RAII handler for critical sections. More...
class	AutoPortMutex
	Class that provides an RAII handler for critical sections in port processing. More...
class	AutoSetWindow
	Class that provides an RAII handler for a code block. More...
class	AutoSpinLock
	Class that provides an RAII handler for critical sections. More...
class	AutoWindowDataAcquirer
	Class that provides an RAII handler for window data access. More...
class	BList
	Class that defines a reflective interface for the bounded list type. More...
class	blist
	Class that represents bounded size list type. More...
class	blob
	Class that represents blob primitive type. More...
class	BMap
	Class that defines a reflective interface for the bounded map type. More...
class	bmap
	Class that represents bounded size map type. More...
class	BSet
	Class that defines a reflective interface for the bounded set type. More...
class	bset
	Class that represents bounded size set type. More...
class	BString
	Class that defines reflective interfaces for bounded strings. More...
class	bstring
	Class that represents bounded size rstring type. More...
class	ByteBuffer
	Class that serves as the base for the NativeByteBuffer and NetworkByteBuffer classes. More...
class	Checkpoint
	Class that represents an individual checkpoint i.e. a snapshot of the state of the operator when the checkpoint is created. More...
class	CheckpointContext
	Class that represents a checkpointing context for an operator. More...
class	Collection
	Class that serves as an interface for the List, Map, and Set classes. More...
class	ConnectionNotification
	Notification emitted by a ControlPlaneConnector. More...
class	ConsistentRegionContext
	This is an optional context that can be acquired by using the CONSISTENT_REGION string defined in OptionalContext. An operator has a ConsistentRegionContext when it belongs to a consistent region. More...
class	ConsistentRegionPermit
	Class that provides an RAII handler for consistent region permits. More...
struct	const_bmap_iterator
struct	const_bset_iterator
class	ConstListIterator
	Class that serves as a constant iterator for reflective list iteration. More...
class	ConstMapIterator
	Class that serves as a constant iterator for reflective map iteration. More...
class	ConstSetIterator
	Class that serves as a constant iterator for reflective set iteration. More...
class	ConstTupleAttribute
	Class that serves as a reflective interface for const tuple attributes. More...
class	ConstTupleIterator
	Class that serves as an iterator for reflective const tuple iteration. More...
class	ConstValueHandle
	Class for reflective manipulation of const values of spl types. More...
class	ControlPlaneConnection
	Used for communicating with the Job Control Plane (JCP). More...
class	ControlPlaneConnector
	Used for establishing a connection to the Job Control Plane (JCP). More...
class	CountWindowPolicy
	Class that represents a count based window policy. More...
class	CV
	Class that implements a wrapper for a pthread conditional variable. More...
class	DataStoreException
	Class that represents runtime exceptions thrown by Checkpointing APIs. More...
class	DeltaWindowPolicy
	Class that represents a delta based window policy. More...
class	Enum
	Class that serves as a reflective interface for the enumeration types. More...
class	EventTimeContext
	Event-time optional context interface for an SPL Operator. More...
class	FilterExpression
	Class that represents a filter expression clause for import specifications. More...
class	FormattableMessage
class	FormattableMessage0
class	FormattableMessage1
class	FormattableMessage10
class	FormattableMessage2
class	FormattableMessage3
class	FormattableMessage4
class	FormattableMessage5
class	FormattableMessage6
class	FormattableMessage7
class	FormattableMessage8
class	FormattableMessage9
class	interval
	Class that represents an interval. More...
class	List
	Class that defines reflective interfaces for lists. More...
class	list
	Class that represents a list type (extends from std::vector). More...
class	ListIterator
	Class that serves as an iterator for reflective list iteration. More...
class	map
	Class that represents a map type (extends from std::unordered_map). More...
class	Map
	Class that defines reflective interfaces for maps. More...
class	MapIterator
	Class that serves as an iterator for reflective map iteration. More...
class	Metric
	Class that represents a metric object, used for port, operator, and pe metrics. More...
class	Mutex
	Class that provides a wrapper for a pthread mutex. More...
class	NativeByteBuffer
	Class that represents a binary serialization buffer, using native byte ordering. More...
class	NetworkByteBuffer
	Class that represents a binary serialization buffer, using network byte ordering. More...
class	Notification
	Represents a notification emitted by an MBean. More...
class	NotificationFilter
	Interface which should be implemented by a class acting as a notification filter. More...
class	NotificationListener
	Interface which should be implemented by a class that wants to receive notifications. More...
class	Operator
	Class that serves as the base class of all SPL primitive operators. More...
class	OperatorContext
	Class that represents the context of an operator. More...
class	OperatorInputPort
	Class that represents an operator input port. More...
class	OperatorMetrics
	Class that represents operator metrics. More...
class	OperatorOutputPort
	Class that represents an operator output port. More...
class	OperatorPort
	Class that forms a common base for operator ports. More...
class	OperatorThread
	Class that represents an operator thread. More...
class	optional
class	Optional
	Class that defines reflective interfaces for optionals. More...
class	OptionalContext
	Class that serves as a base for all optional operator contexts. More...
class	ParameterValue
	Class representing one parameter value at runtime. More...
class	PartitionAgePartitionEvictionPolicy
	Eviction policy based on the age of partition. More...
class	PartitionCountPartitionEvictionPolicy
	Partitions should be evicted when there are too many partitions. More...
class	PartitionEvictionPolicy
	Class that represents when partitions should be evicted from the window. More...
class	PEMetrics
	Class that represents PE metrics. More...
class	ProcessingElement
	Class that represents a processing element. More...
class	Punctuation
	Class that represents a punctuation. More...
class	PunctWindowPolicy
	Class that represents a punctuation based window policy. More...
class	rstring
class	RWMutex
	Class that provides a wrapper for a pthread rwlock. More...
class	set
	Class that represents a set type (extends from std::unordered_set). More...
class	Set
	Class that defines reflective interfaces for sets. More...
class	SetIterator
	Class that serves as an iterator for reflective set iteration. More...
class	SlidingWindow
	Class that represents a sliding window. More...
class	SlidingWindowImpl
class	SpinLock
	Class that provides a wrapper for a pthread mutex. More...
struct	spl_cast
class	SPLControlBeanException
	Represents exceptions thrown by MBeans registered with the Job Control Plane. More...
class	SPLControlBeanNotFoundException
	The specified MBean is not registered with the Job Control Plane. More...
class	SPLControlException
	Root of all the exceptions thrown by the SPL runtime control. More...
class	SPLListenerNotFoundException
	The specified listener is not registered with the Job Control Plane. More...
class	SPLRuntimeDeserializationException
	Class that represents SPL runtime type deserialization exceptions. More...
class	SPLRuntimeException
	Class that represents SPL runtime exceptions. More...
class	SPLRuntimeInvalidArgumentException
	Class that represents SPL runtime invalid argument exceptions. More...
class	SPLRuntimeInvalidCheckpointException
	Class that represents SPL runtime invalid checkpoint exceptions. More...
class	SPLRuntimeInvalidIndexException
	Class that represents SPL runtime invalid index exceptions. More...
class	SPLRuntimeInvalidMetricException
	Class that represents SPL runtime invalid metric exceptions. More...
class	SPLRuntimeInvalidOperationException
	Class that represents SPL runtime invalid operation exceptions. Thrown when an unsupported operation is invoked. More...
class	SPLRuntimeInvalidSlidingWindowException
	Class that represents SPL runtime invalid sliding window exceptions. More...
class	SPLRuntimeInvalidTumblingWindowException
	Class that represents SPL runtime invalid tumbling window exceptions. More...
class	SPLRuntimeIOException
	Indicates that an exception has occurred when executing an I/O operation. More...
class	SPLRuntimeMissingDataDirectory
	Class that represents a missing data directory. More...
class	SPLRuntimeNullValueAccess
	Class that represents an access to an optional type that has a null value. More...
class	SPLRuntimeOperatorException
	Class that represents SPL runtime operator exceptions. More...
class	SPLRuntimeSerializationException
	Class that represents SPL runtime type serialization exceptions. More...
class	SPLRuntimeStreamPropertyException
	Class that represents SPL runtime stream property exceptions. More...
class	SPLRuntimeSubscriptionException
	Class that represents SPL runtime subscription exceptions. More...
class	SPLRuntimeSubscriptionInvalidClauseException
	Class that represents SPL runtime subscription invalid clause exceptions. More...
class	SPLRuntimeSubscriptionInvalidLiteralException
	Class that represents SPL runtime subscription invalid literal exceptions. More...
class	SPLRuntimeSubscriptionNoSubscriptWithInException
	Class that represents SPL runtime subscription no subscript can be used with the 'In' operator exceptions. More...
class	SPLRuntimeTypeMismatchException
	Class that represents SPL runtime type mismatch exceptions. More...
class	StateHandler
	Class that serves as a handler for operator state. The handler is used when the operator is checkpointing or is in a consistent region. More...
class	StreamProperty
	Class that represents a stream property. More...
class	StreamPropertyCollection
	Class that represents a stream property collection. More...
class	SubscriptionExpression
	Class that represents a subscription expression clause for import specifications. More...
class	Thread
	Class that implements a wrapper for a pthread thread. More...
class	TimeIntervalWindow
	Window which collects tuples into window time intervals defined over specific event-time intervals. More...
class	TimeIntervalWindowOptions
	Provides configuration options for an event-time window with fixed duration window time intervals. More...
class	TimeIntervalWindowPane
	Window which stores tuples with an event time which falls within a specified interval. More...
class	timestamp
	Class that represents a timestamp type. More...
class	TimeUtils
	Time-related utilities. More...
class	TimeWindowPolicy
	Class that represents a time based window policy. More...
class	TriggerInfoProvider
	Interface which provides information about an event-time window, observable within the WindowEvent handler code. More...
class	TumblingWindow
	Class that represents a tumbling window. More...
class	TumblingWindowImpl
class	TumblingWindowSummarizer
	Class that defines an interface for tumbling window summarizers. More...
class	Tuple
	Class that serves as a reflective interface for the tuple types. More...
class	TupleAttribute
	Class that serves as a reflective interface for tuple attributes. More...
class	TupleCountPartitionEvictionPolicy
	Partitions should be evicted when there are too many tuples. More...
class	TupleIterator
	Class that serves as an iterator for reflective tuple iteration. More...
class	ustring
	Class that represents a ustring primitive type. More...
class	ValueHandle
	Class for reflective manipulation of values of SPL types. More...
class	Window
	Common base for window classes with template parameters. More...
class	WindowEvent
	Class that defines an interface for window events. More...
class	WindowImpl
class	WindowPolicy
	Class that represents the eviction policies or the trigger policies of a window. More...
class	WindowTracker
	Class for tracking which window is active at any time. More...
class	xml
	Class that represents an xml type. More...

Typedefs
using	ControlPlaneConnectionPtr = std::shared_ptr< ControlPlaneConnection >
	Defines a shared pointer to a ControlPlaneConnection instance. More...
using	FilterExpressionPtr = std::shared_ptr< FilterExpression >
using	SubscriptionExpressionPtr = std::shared_ptr< SubscriptionExpression >
typedef std::complex< float32 >	complex32
typedef std::complex< float64 >	complex64
typedef ibm::decimal::decimal32	decimal32
typedef ibm::decimal::decimal64	decimal64
typedef ibm::decimal::decimal128	decimal128
using	float32 = float
using	float64 = double
typedef _<... >	boolean
typedef _<... >	int8
typedef _<... >	uint8
typedef int16_t	int16
typedef int32_t	int32
typedef int64_t	int64
typedef uint16_t	uint16
typedef uint32_t	uint32
typedef uint64_t	uint64
using	RString = std::string
	Class that represents an rstring primitive type, based on std::string. More...
using	timestamp_interval = interval< timestamp >
using	Watermark = timestamp
	Watermarks are inserted into event-time streams. Data used for keeping track of the time progress of event time streams. More...
using	ControlPlaneConnectorPtr = std::shared_ptr< ControlPlaneConnector >

Enumerations
enum	AdjustDirection { UP, DOWN }

Functions
std::ostream &	operator<< (std::ostream &out, const EventTimeContext::WatermarkMode value)
	Serialize the specified value. More...
std::ostream &	operator<< (std::ostream &ostr, const FilterExpression &v)
std::ostream &	operator<< (std::ostream &ostr, FilterExpression::Kind v)
std::ostream &	operator<< (std::ostream &ostr, FilterExpression::Op v)
std::ostream &	operator<< (std::ostream &ostr, const FilterExpression::Literal &v)
std::ostream &	operator<< (std::ostream &ostr, FilterExpression::ArithmeticOp v)
std::ostream &	operator<< (std::ostream &, const FilterExpression::Literal::Kind v)
std::ostream &	operator<< (std::ostream &ostr, Punctuation const &punct)
std::istream &	operator>> (std::istream &istr, Punctuation &punct)
std::ostream &	operator<< (std::ostream &ostr, StreamProperty const &sp)
std::ostream &	operator<< (std::ostream &ostr, StreamPropertyCollection const &spc)
std::ostream &	operator<< (std::ostream &ostr, const SubscriptionExpression &v)
std::ostream &	operator<< (std::ostream &ostr, SubscriptionExpression::Kind v)
std::ostream &	operator<< (std::ostream &ostr, SubscriptionExpression::Op v)
std::ostream &	operator<< (std::ostream &ostr, const SubscriptionExpression::Literal &v)
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const char *&str)
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const char *str)
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, char *&str)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const T *&value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const T *value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, T *&value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, std::shared_ptr< T > &value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, std::shared_ptr< T > &value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const std::shared_ptr< T > &value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, const T *&value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const std::deque< T > &value)
template<class T >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, std::deque< T > &value)
template<class K , class V >
SPL::ByteBuffer< Checkpoint > &	operator<< (SPL::ByteBuffer< Checkpoint > &ckpt, const std::unordered_map< K, V > &value)
template<class K , class V >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, std::unordered_map< K, V > &value)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, char const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, char &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, bool const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, bool &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, int8_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, int8_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, int16_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, int16_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, int32_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, int32_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, int64_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, int64_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, uint8_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, uint8_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, uint16_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, uint16_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, uint32_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, uint32_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, uint64_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, uint64_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, float const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, float &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, double const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, double &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, long double const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, long double &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, USTRING_BB_TYPE const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, USTRING_BB_TYPE &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, char *const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, char *&val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, char const *const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, char const *&val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, void *const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, void *&val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, void const *const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, void const *&val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, char16_t const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, char16_t &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, std::string const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::string &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, RSTRING_BB_TYPE const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, RSTRING_BB_TYPE &val)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::vector< T > &vec)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::vector< T > &vec)
template<class S , class K , class V >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::pair< K, V > &pr)
template<class S , class K , class V >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::pair< K, V > &pr)
template<class S , class K , class V >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::unordered_map< K, V > &map)
template<class S , class K , class V >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::unordered_map< K, V > &map)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::unordered_set< T > &set)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::unordered_set< T > &set)
template<class S , class K , class V >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::map< K, V > &map)
template<class S , class K , class V >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::map< K, V > &map)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, char const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, char &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, bool const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, bool &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, int8_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, int8_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, int16_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, int16_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, int32_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, int32_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, int64_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, int64_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, uint8_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, uint8_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, uint16_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, uint16_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, uint32_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, uint32_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, uint64_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, uint64_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, float const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, float &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, double const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, double &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, long double const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, long double &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, char *const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, char *&val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, char const *const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, char const *&val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, USTRING_BB_TYPE const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, USTRING_BB_TYPE &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, RSTRING_BB_TYPE const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, RSTRING_BB_TYPE &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, void *const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, void *&val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, void const *const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, void const *&val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, char16_t const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, char16_t &val)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, std::string const &val)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::string &val)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::vector< T > &vec)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::vector< T > &vec)
template<class K , class V >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::pair< K, V > &pr)
template<class K , class V >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::pair< K, V > &pr)
template<class K , class V >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::unordered_map< K, V > &map)
template<class K , class V >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::unordered_map< K, V > &map)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::unordered_set< T > &set)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::unordered_set< T > &set)
template<class K , class V >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::map< K, V > &map)
template<class K , class V >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::map< K, V > &map)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, char const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, char &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, bool const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, bool &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, int8_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, int8_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, int16_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, int16_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, int32_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, int32_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, int64_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, int64_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, uint8_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, uint8_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, uint16_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, uint16_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, uint32_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, uint32_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, uint64_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, uint64_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, float const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, float &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, double const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, double &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, long double const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, long double &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, char *const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, char *&val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, char const *const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, char const *&val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, USTRING_BB_TYPE const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, USTRING_BB_TYPE &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, RSTRING_BB_TYPE const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, RSTRING_BB_TYPE &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, void *const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, void *&val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, void const *const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, void const *&val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, char16_t const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, char16_t &val)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, std::string const &val)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::string &val)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::vector< T > &vec)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::vector< T > &vec)
template<class K , class V >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::pair< K, V > &pr)
template<class K , class V >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::pair< K, V > &pr)
template<class K , class V >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::unordered_map< K, V > &map)
template<class K , class V >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::unordered_map< K, V > &map)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::unordered_set< T > &set)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::unordered_set< T > &set)
template<class K , class V >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::map< K, V > &map)
template<class K , class V >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::map< K, V > &map)
bool	operator== (const Optional &lhs, const Optional &rhs)
bool	operator!= (const Optional &lhs, const Optional &rhs)
std::ostream &	operator<< (std::ostream &ostr, const Optional &x)
std::istream &	operator>> (std::istream &istr, Optional &x)
template<class T , int32_t size>
std::ostream &	serializeWithPrecision (std::ostream &ostr, const blist< T, size > &x)
template<class T , int32_t size>
std::ostream &	operator<< (std::ostream &ostr, const blist< T, size > &x)
template<class T , int32_t size>
std::istream &	operator>> (std::istream &istr, blist< T, size > &x)
template<class T , int32_t size>
void	deserializeWithSuffix (std::istream &istr, blist< T, size > &x)
template<class T , int32_t size>
void	deserializeWithNanAndInfs (std::istream &istr, blist< T, size > &x, bool withSuffix=false)
template<class S , class T , int32_t size>
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const blist< T, size > &x)
template<class T , int32_t size>
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const blist< T, size > &x)
template<class T , int32_t size>
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const blist< T, size > &x)
template<class S , class T , int32_t size>
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, blist< T, size > &x)
template<class T , int32_t size>
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, blist< T, size > &x)
template<class T , int32_t size>
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, blist< T, size > &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const blob &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const blob &x)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const blob &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, blob &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, blob &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, blob &x)
std::ostream &	operator<< (std::ostream &ostr, const blob &x)
std::istream &	operator>> (std::istream &istr, blob &x)
template<class K , class V , int32_t msize>
std::ostream &	serializeWithPrecision (std::ostream &ostr, const bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
std::ostream &	operator<< (std::ostream &ostr, const bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
std::istream &	operator>> (std::istream &istr, bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
void	deserializeWithSuffix (std::istream &istr, bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
void	deserializeWithNanAndInfs (std::istream &istr, bmap< K, V, msize > &x, bool withSuffix=false)
template<class S , class K , class V , int32_t msize>
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const bmap< K, V, msize > &x)
template<class S , class K , class V , int32_t msize>
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, bmap< K, V, msize > &x)
template<class K , class V , int32_t msize>
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, bmap< K, V, msize > &x)
template<class K , int32_t msize>
std::ostream &	serializeWithPrecision (std::ostream &ostr, const bset< K, msize > &x)
template<class K , int32_t msize>
std::ostream &	operator<< (std::ostream &ostr, const bset< K, msize > &x)
template<class K , int32_t msize>
std::istream &	operator>> (std::istream &istr, bset< K, msize > &x)
template<class K , int32_t msize>
void	deserializeWithSuffix (std::istream &istr, bset< K, msize > &x)
template<class K , int32_t msize>
void	deserializeWithNanAndInfs (std::istream &istr, bset< K, msize > &x, bool withSuffix=false)
template<class S , class K , int32_t msize>
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const bset< K, msize > &x)
template<class K , int32_t msize>
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const bset< K, msize > &x)
template<class K , int32_t msize>
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const bset< K, msize > &x)
template<class S , class K , int32_t msize>
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, bset< K, msize > &x)
template<class K , int32_t msize>
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, bset< K, msize > &x)
template<class K , int32_t msize>
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, bset< K, msize > &x)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const BString &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const BString &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const BString &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, BString &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, BString &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, BString &x)
std::ostream &	operator<< (std::ostream &ostr, const BString &x)
std::istream &	operator>> (std::istream &istr, BString &x)
template<int32_t size>
std::ostream &	operator<< (std::ostream &ostr, const bstring< size > &x)
template<int32_t size>
std::istream &	operator>> (std::istream &istr, bstring< size > &x)
template<int32_t size>
VirtualByteBuffer &	operator<< (VirtualByteBuffer &buf, const bstring< size > &x)
template<int32_t size>
VirtualByteBuffer &	operator>> (VirtualByteBuffer &buf, bstring< size > &x)
template<class S , int32_t size>
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const bstring< size > &x)
template<int32_t size>
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const bstring< size > &x)
template<int32_t size>
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const bstring< size > &x)
template<class S , int32_t size>
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, bstring< size > &x)
template<int32_t size>
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, bstring< size > &x)
template<int32_t size>
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, bstring< size > &x)
template<class Stream , int32_t size>
Stream &	serializeUnquoted (Stream &stm, SPL::bstring< size > const &str)
bool	operator== (const Collection &lhs, const Collection &rhs)
bool	operator!= (const Collection &lhs, const Collection &rhs)
std::ostream &	serializeWithPrecision (std::ostream &ostr, const Collection &x)
std::ostream &	operator<< (std::ostream &ostr, const Collection &x)
std::istream &	operator>> (std::istream &istr, Collection &x)
void	deserializeWithSuffix (std::istream &istr, Collection &x)
std::ostream &	serializeWithPrecision (std::ostream &s, complex32 const &v)
std::ostream &	serializeWithPrecision (std::ostream &s, complex64 const &v)
template<class Buffer , class T >
void	extractIntoComplex (Buffer &buf, std::complex< T > &x)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const std::complex< T > &x)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const std::complex< T > &x)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const std::complex< T > &x)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, std::complex< T > &x)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, std::complex< T > &x)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, std::complex< T > &x)
std::ostream &	serializeWithPrecision (std::ostream &s, decimal32 const &v)
std::ostream &	serializeWithPrecision (std::ostream &s, decimal64 const &v)
std::ostream &	serializeWithPrecision (std::ostream &s, decimal128 const &v)
template<class BufferType >
ByteBuffer< BufferType > &	operator<< (ByteBuffer< BufferType > &buf, const decimal32 &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const decimal32 &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const decimal32 &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, decimal32 &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, decimal32 &x)
template<class BufferType >
ByteBuffer< BufferType > &	operator>> (ByteBuffer< BufferType > &buf, decimal32 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator<< (ByteBuffer< NetworkByteBuffer > &buf, const decimal32 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator<< (ByteBuffer< NativeByteBuffer > &buf, const decimal32 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator>> (ByteBuffer< NetworkByteBuffer > &buf, decimal32 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator>> (ByteBuffer< NativeByteBuffer > &buf, decimal32 &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const decimal64 &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const decimal64 &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, decimal64 &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, decimal64 &x)
template<class BufferType >
ByteBuffer< BufferType > &	operator<< (ByteBuffer< BufferType > &buf, const decimal64 &x)
template<class BufferType >
ByteBuffer< BufferType > &	operator>> (ByteBuffer< BufferType > &buf, decimal64 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator<< (ByteBuffer< NetworkByteBuffer > &buf, const decimal64 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator<< (ByteBuffer< NativeByteBuffer > &buf, const decimal64 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator>> (ByteBuffer< NetworkByteBuffer > &buf, decimal64 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator>> (ByteBuffer< NativeByteBuffer > &buf, decimal64 &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const decimal128 &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const decimal128 &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, decimal128 &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, decimal128 &x)
template<class BufferType >
ByteBuffer< BufferType > &	operator<< (ByteBuffer< BufferType > &buf, const decimal128 &x)
template<class BufferType >
ByteBuffer< BufferType > &	operator>> (ByteBuffer< BufferType > &buf, decimal128 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator<< (ByteBuffer< NetworkByteBuffer > &buf, const decimal128 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator<< (ByteBuffer< NativeByteBuffer > &buf, const decimal128 &x)
template<>
ByteBuffer< NativeByteBuffer > &	operator>> (ByteBuffer< NativeByteBuffer > &buf, decimal128 &x)
template<>
ByteBuffer< NetworkByteBuffer > &	operator>> (ByteBuffer< NetworkByteBuffer > &buf, decimal128 &x)
void	deserializeWithSuffix (std::istream &s, decimal32 &v)
void	deserializeWithSuffix (std::istream &s, decimal64 &v)
void	deserializeWithSuffix (std::istream &s, decimal128 &v)
void	deserializeWithNanAndInfs (std::istream &s, decimal32 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, decimal64 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, decimal128 &v, bool withSuffix=false)
bool	operator== (const Enum &lhs, const Enum &rhs)
bool	operator!= (const Enum &lhs, const Enum &rhs)
std::ostream &	operator<< (std::ostream &ostr, const Enum &x)
std::istream &	operator>> (std::istream &istr, Enum &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const Enum &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const Enum &x)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const Enum &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, Enum &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, Enum &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, Enum &x)
std::ostream &	serializeWithPrecision (std::ostream &s, float32 const &v)
std::ostream &	serializeWithPrecision (std::ostream &s, float64 const &v)
void	deserializeWithSuffix (std::istream &s, float32 &v)
void	deserializeWithSuffix (std::istream &s, float64 &v)
void	deserializeWithNanAndInfs (std::istream &s, float32 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, float64 &v, bool withSuffix=false)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const boolean &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const boolean &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const boolean &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, boolean &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, boolean &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, boolean &x)
std::ostream &	operator<< (std::ostream &ostr, const boolean &x)
std::istream &	operator>> (std::istream &istr, boolean &x)
void	deserializeWithSuffix (std::istream &s, int8 &v)
void	deserializeWithSuffix (std::istream &s, int16 &v)
void	deserializeWithSuffix (std::istream &s, int32 &v)
void	deserializeWithSuffix (std::istream &s, int64 &v)
void	deserializeWithSuffix (std::istream &s, uint16 &v)
void	deserializeWithSuffix (std::istream &s, uint32 &v)
void	deserializeWithSuffix (std::istream &s, uint64 &v)
void	deserializeWithNanAndInfs (std::istream &s, int8 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, int16 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, int32 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, int64 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, uint16 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, uint32 &v, bool withSuffix=false)
void	deserializeWithNanAndInfs (std::istream &s, uint64 &v, bool withSuffix=false)
template<class T >
std::ostream &	serializeWithPrecision (std::ostream &ostr, const list< T > &x)
template<class T >
std::ostream &	operator<< (std::ostream &ostr, const list< T > &x)
template<class T >
std::istream &	operator>> (std::istream &istr, list< T > &x)
template<class T >
void	deserializeWithSuffix (std::istream &istr, list< T > &x)
template<class T >
void	deserializeWithNanAndInfs (std::istream &istr, list< T > &x, bool withSuffix=false)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const list< T > &x)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const list< T > &x)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const list< T > &x)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, list< T > &x)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, list< T > &x)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, list< T > &x)
template<class K , class V >
std::ostream &	serializeWithPrecision (std::ostream &ostr, const map< K, V > &x)
template<class K , class V >
std::ostream &	operator<< (std::ostream &ostr, const map< K, V > &x)
template<class K , class V >
std::istream &	operator>> (std::istream &istr, map< K, V > &x)
template<class K , class V >
void	deserializeWithSuffix (std::istream &istr, map< K, V > &x)
template<class K , class V >
void	deserializeWithNanAndInfs (std::istream &istr, map< K, V > &x, bool withSuffix=false)
template<class K , class V >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const map< K, V > &x)
template<class K , class V >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const map< K, V > &x)
template<class S , class K , class V >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const map< K, V > &x)
template<class S , class K , class V >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, map< K, V > &x)
template<class K , class V >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, map< K, V > &x)
template<class K , class V >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, map< K, V > &x)
template<class T >
SPL::list< T >	dotPlus (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotPlus (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotPlus (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotPlus (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotPlus (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotPlus (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotPlus (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotPlus (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotPlus (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotPlus (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotPlus (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotPlus (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotMinus (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotMinus (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotMinus (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotMinus (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotMinus (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotMinus (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotMinus (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotMinus (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotMinus (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotMinus (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotMinus (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotMinus (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotTimes (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotTimes (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotTimes (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotTimes (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotTimes (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotTimes (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotTimes (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotTimes (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotTimes (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotTimes (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotTimes (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotTimes (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotDivides (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotDivides (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotDivides (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotDivides (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotDivides (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotDivides (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotDivides (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotDivides (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotDivides (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotDivides (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotDivides (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotDivides (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotModulus (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotModulus (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotModulus (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotModulus (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotModulus (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotModulus (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotModulus (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotModulus (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotModulus (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotModulus (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotModulus (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotModulus (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotAnd (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotAnd (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotAnd (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotAnd (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotAnd (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotAnd (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotAnd (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotAnd (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotAnd (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotAnd (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotAnd (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotAnd (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotOr (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotOr (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotOr (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotOr (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotOr (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotOr (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotOr (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotOr (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotOr (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotOr (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotOr (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotOr (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotXor (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotXor (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotXor (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotXor (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotXor (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotXor (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotXor (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotXor (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotXor (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotXor (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotXor (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotXor (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotLshift (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotLshift (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotLshift (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotLshift (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotLshift (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotLshift (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotLshift (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotLshift (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotLshift (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotLshift (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotLshift (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotLshift (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	dotRshift (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotRshift (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotRshift (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotRshift (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	dotRshift (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T,N >	dotRshift (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	dotRshift (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotRshift (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotRshift (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotRshift (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	dotRshift (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T,N >	dotRshift (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator+ (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator+ (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator+ (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator+ (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator+ (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator+ (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator+ (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator+ (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator+ (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator+ (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator+ (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator+ (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator- (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator- (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator- (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator- (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator- (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator- (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator- (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator- (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator- (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator- (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator- (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator- (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator* (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator* (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator* (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator* (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator* (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator* (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator* (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator* (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator* (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator* (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator* (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator* (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator/ (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator/ (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator/ (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator/ (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator/ (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator/ (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator/ (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator/ (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator/ (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator/ (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator/ (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator/ (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator% (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator% (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator% (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator% (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator% (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator% (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator% (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator% (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator% (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator% (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator% (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator% (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator& (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator& (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator& (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator& (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator& (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator& (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator& (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator& (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator& (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator& (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator& (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator& (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator| (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator| (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator| (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator| (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator| (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator| (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator| (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator| (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator| (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator| (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator| (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator| (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator^ (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator^ (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator^ (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator^ (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator^ (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator^ (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator^ (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator^ (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator^ (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator^ (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator^ (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator^ (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator<< (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator<< (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator<< (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator<< (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator<< (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator<< (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator<< (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator<< (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator<< (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator<< (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator<< (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator<< (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T >	operator>> (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator>> (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator>> (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator>> (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T >	operator>> (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N >	operator>> (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T >	operator>> (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator>> (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator>> (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator>> (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T >	operator>> (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N >	operator>> (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotEqual (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotEqual (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotEqual (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotEqual (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotEqual (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotEqual (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotEqual (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotEqual (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotEqual (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotEqual (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotEqual (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotEqual (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotNotEqual (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotNotEqual (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotNotEqual (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotNotEqual (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotNotEqual (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotNotEqual (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotNotEqual (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotNotEqual (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotNotEqual (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotNotEqual (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotNotEqual (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotNotEqual (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterThan (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterThan (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterThan (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterThan (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterThan (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterThan (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterThan (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterThan (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterThan (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterThan (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterThan (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterThan (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterEqual (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterEqual (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterEqual (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterEqual (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotGreaterEqual (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotGreaterEqual (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterEqual (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterEqual (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterEqual (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterEqual (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotGreaterEqual (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotGreaterEqual (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessThan (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessThan (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessThan (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessThan (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessThan (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessThan (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessThan (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessThan (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessThan (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessThan (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessThan (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessThan (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessEqual (const SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessEqual (const SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessEqual (const T &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessEqual (const T &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< SPL::boolean >	dotLessEqual (const SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< SPL::boolean,N >	dotLessEqual (const SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessEqual (const SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessEqual (const SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessEqual (const T &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessEqual (const T &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, SPL::boolean >	dotLessEqual (const SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, SPL::boolean,N >	dotLessEqual (const SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignPlus (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignPlus (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignPlus (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignPlus (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignPlus (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignPlus (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignPlus (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignPlus (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignMinus (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignMinus (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignMinus (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignMinus (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignMinus (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignMinus (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignMinus (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignMinus (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignTimes (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignTimes (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignTimes (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignTimes (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignTimes (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignTimes (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignTimes (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignTimes (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignDivides (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignDivides (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignDivides (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignDivides (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignDivides (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignDivides (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignDivides (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignDivides (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignModulus (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignModulus (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignModulus (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignModulus (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignModulus (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignModulus (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignModulus (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignModulus (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignAnd (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignAnd (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignAnd (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignAnd (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignAnd (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignAnd (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignAnd (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignAnd (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignOr (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignOr (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignOr (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignOr (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignOr (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignOr (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignOr (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignOr (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignLshift (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignLshift (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignLshift (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignLshift (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignLshift (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignLshift (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignLshift (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignLshift (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignRshift (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignRshift (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignRshift (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignRshift (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignRshift (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignRshift (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignRshift (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignRshift (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
void	assignXor (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
void	assignXor (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
void	assignXor (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
void	assignXor (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
void	assignXor (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
void	assignXor (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
void	assignXor (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
void	assignXor (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator+= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator+= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator+= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator+= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator+= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator+= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator+= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator+= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator-= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator-= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator-= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator-= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator-= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator-= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator-= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator-= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator*= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator*= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator*= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator*= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator*= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator*= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator*= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator*= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator/= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator/= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator/= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator/= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator/= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator/= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator/= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator/= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator%= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator%= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator%= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator%= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator%= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator%= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator%= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator%= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator&= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator&= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator&= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator&= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator&= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator&= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator&= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator&= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator|= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator|= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator|= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator|= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator|= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator|= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator|= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator|= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator<<= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator<<= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator<<= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator<<= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator<<= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator<<= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator<<= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator<<= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator>>= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator>>= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator>>= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator>>= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator>>= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator>>= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator>>= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator>>= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
SPL::list< T > &	operator^= (SPL::list< T > &lhs, const SPL::list< T > &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator^= (SPL::blist< T, N > &lhs, const SPL::blist< T, N > &rhs)
template<class T >
SPL::list< T > &	operator^= (SPL::list< T > &lhs, const T &rhs)
template<class T , int32_t N>
SPL::blist< T, N > &	operator^= (SPL::blist< T, N > &lhs, const T &rhs)
template<class K , class T >
SPL::map< K, T > &	operator^= (SPL::map< K, T > &lhs, const SPL::map< K, T > &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator^= (SPL::bmap< K, T, N > &lhs, const SPL::bmap< K, T, N > &rhs)
template<class K , class T >
SPL::map< K, T > &	operator^= (SPL::map< K, T > &lhs, const T &rhs)
template<class K , class T , int32_t N>
SPL::bmap< K, T, N > &	operator^= (SPL::bmap< K, T, N > &lhs, const T &rhs)
template<class T >
std::ostream &	operator<< (std::ostream &ostr, const optional< T > &val)
template<class T >
std::istream &	operator>> (std::istream &istr, optional< T > &val)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, optional< T > &val)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const optional< T > &val)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, optional< T > const &val)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, optional< T > &val)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, optional< T > const &val)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, optional< T > &val)
template<class T >
void	deserializeWithNanAndInfs (std::istream &istr, optional< T > &val, bool withSuffix=false)
template<class K >
std::ostream &	serializeWithPrecision (std::ostream &ostr, const set< K > &x)
template<class K >
std::ostream &	operator<< (std::ostream &ostr, const set< K > &x)
template<class K >
std::istream &	operator>> (std::istream &istr, set< K > &x)
template<class K >
void	deserializeWithSuffix (std::istream &istr, set< K > &x)
template<class K >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const set< K > &x)
template<class K >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const set< K > &x)
template<class S , class K >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const set< K > &x)
template<class S , class K >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, set< K > &x)
template<class K >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, set< K > &x)
template<class K >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, set< K > &x)
rstring	operator+ (rstring const &lhs, rstring const &rhs)
rstring	operator+ (rstring const &lhs, char rhs)
rstring	operator+ (rstring const &lhs, RString const &rhs)
rstring	operator+ (RString const &lhs, rstring const &rhs)
rstring	operator+ (rstring const &lhs, char const *rhs)
rstring	operator+ (char const *lhs, rstring const &rhs)
ustring	operator+ (ustring const &lhs, ustring const &rhs)
ustring	operator+ (ustring const &lhs, rstring const &rhs)
ustring	operator+ (rstring const &lhs, ustring const &rhs)
rstring	operator+ (rstring &&lhs, rstring const &rhs)
rstring	operator+ (rstring const &lhs, rstring &&rhs)
rstring	operator+ (rstring &&lhs, rstring &&rhs)
rstring	operator+ (RString &&lhs, rstring &&rhs)
rstring	operator+ (RString &&lhs, rstring const &rhs)
rstring	operator+ (RString const &lhs, rstring &&rhs)
rstring	operator+ (rstring &&lhs, RString &&rhs)
rstring	operator+ (rstring const &lhs, RString &&rhs)
rstring	operator+ (rstring &&lhs, RString const &rhs)
rstring	operator+ (const char *lhs, rstring &&rhs)
rstring	operator+ (rstring &&lhs, const char *rhs)
std::ostream &	operator<< (std::ostream &ostr, const ustring &x)
std::istream &	operator>> (std::istream &istr, ustring &x)
std::ostream &	operator<< (std::ostream &ostr, const rstring &x)
std::istream &	operator>> (std::istream &istr, rstring &x)
template<class Stream >
Stream &	serializeUnquoted (Stream &stm, SPL::rstring const &str)
template<class Stream >
Stream &	serializeUnquoted (Stream &stm, SPL::ustring const &str)
VirtualByteBuffer &	operator<< (VirtualByteBuffer &sbuf, rstring const &val)
VirtualByteBuffer &	operator>> (VirtualByteBuffer &sbuf, rstring &val)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, rstring const &val)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, rstring &val)
std::ostream &	operator<< (std::ostream &ostr, const timestamp &x)
std::istream &	operator>> (std::istream &istr, timestamp &x)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const timestamp &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const timestamp &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const timestamp &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, timestamp &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, timestamp &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, timestamp &x)
bool	operator== (const Tuple &lhs, const Tuple &rhs)
bool	operator!= (const Tuple &lhs, const Tuple &rhs)
std::ostream &	serializeWithPrecision (std::ostream &ostr, const Tuple &x)
void	deserializeWithSuffix (std::istream &istr, Tuple &x)
void	deserializeWithNanAndInfs (std::istream &istr, Tuple &x, bool withSuffix=false)
std::ostream &	operator<< (std::ostream &ostr, const Tuple &x)
std::istream &	operator>> (std::istream &istr, Tuple &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const Tuple &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, Tuple &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const Tuple &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, Tuple &x)
template<class T >
size_t	getSerializedSize (T const &x)
std::ostream &	operator<< (std::ostream &ostr, const xml &x)
std::istream &	operator>> (std::istream &istr, xml &x)
template<class S >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &buf, const xml &x)
NetworkByteBuffer &	operator<< (NetworkByteBuffer &buf, const xml &x)
NativeByteBuffer &	operator<< (NativeByteBuffer &buf, const xml &x)
template<class S >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &buf, xml &x)
NetworkByteBuffer &	operator>> (NetworkByteBuffer &buf, xml &x)
NativeByteBuffer &	operator>> (NativeByteBuffer &buf, xml &x)
std::ostream &	operator<< (std::ostream &ostr, const FormattableMessage &msg)
template<typename T >
std::ostream &	operator<< (std::ostream &stream, const interval< T > &i)
timestamp	operator% (timestamp const &l, timestamp const &r)
	Modulo operator for timestamps. More...
std::ostream &	operator<< (std::ostream &o, Notification const &n)

Detailed Description

C++ classes for writing operators.

C++ classes for accessing Parameter values at runtime.

Typedef Documentation

ControlPlaneConnectorPtr

using SPL::ControlPlaneConnectorPtr = typedef std::shared_ptr<ControlPlaneConnector>

Defines a shared pointer to a ControlPlaneConnection instance.

FilterExpressionPtr

using SPL::FilterExpressionPtr = typedef std::shared_ptr<FilterExpression>

SubscriptionExpressionPtr

using SPL::SubscriptionExpressionPtr = typedef std::shared_ptr<SubscriptionExpression>

complex32

typedef std::complex< float32 > SPL::complex32

complex64

typedef std::complex< float64 > SPL::complex64

decimal32

typedef ibm::decimal::decimal32 SPL::decimal32

decimal64

typedef ibm::decimal::decimal64 SPL::decimal64

decimal128

typedef ibm::decimal::decimal128 SPL::decimal128

float32

using SPL::float32 = typedef float

float64

using SPL::float64 = typedef double

boolean

typedef _<...> SPL::boolean

int8

typedef _<...> SPL::int8

uint8

typedef _<...> SPL::uint8

int16

typedef int16_t SPL::int16

int32

typedef int32_t SPL::int32

int64

typedef int64_t SPL::int64

uint16

typedef uint16_t SPL::uint16

uint32

typedef uint32_t SPL::uint32

uint64

typedef uint64_t SPL::uint64

RString

using SPL::RString = typedef std::string

Class that represents an rstring primitive type, based on std::string.

The operators << and >> are overloaded for rstring class, such that the character serialization and deserialization for rstring use the SPL string literal format. This way any string that is serialized to a character stream can be deserialized unambiguously.

An rstring can be cast to std::string& to get the non-literal based serialization and deserialization behavior.

                        ostream & ostr = ...
                    

                        SPL::rstring abc = "ab c";
                    

                        ostr << abc; // writes: "ab c"
                    

                        ostr << static_cast<std::string&>(abc); // writes: ab c
                    

                        ostr << abc.c_str(); // writes: ab c
                    

                        ostr << abc.string(); // writes: ab c
                    

                        assert(abc[0]=='a'); // " is about serialization, not part of the content
                    

timestamp_interval

using SPL::timestamp_interval = typedef interval<timestamp>

Interval template specialization for SPL::timestamp elements. It is assumed that all the timestamps of an interval have the same machineId.

Watermark

using SPL::Watermark = typedef timestamp

Watermarks are inserted into event-time streams. Data used for keeping track of the time progress of event time streams.

Enumeration Type Documentation

AdjustDirection

enum SPL::AdjustDirection

Enumerator
UP
DOWN

Function Documentation

operator<<() [1/198]

std::ostream& SPL::operator<< ( std::ostream &  o, Notification const &  n  )

inline

Print internal state through the << operator.

Parameters

o	output stream.
n	The Notification object.

operator<<() [2/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const FilterExpression &	v
	)

operator<<() [3/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		FilterExpression::Kind	v
	)

operator<<() [4/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		FilterExpression::Op	v
	)

operator<<() [5/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const FilterExpression::Literal &	v
	)

operator<<() [6/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		FilterExpression::ArithmeticOp	v
	)

operator<<() [7/198]

std::ostream& SPL::operator<<	(	std::ostream &	,
		const FilterExpression::Literal::Kind	v
	)

operator<<() [8/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		Punctuation const &	punct
	)

operator>>() [1/181]

std::istream& SPL::operator>>	(	std::istream &	istr,
		Punctuation &	punct
	)

operator<<() [9/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, StreamProperty const &  sp  )

inline

operator<<() [10/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, StreamPropertyCollection const &  spc  )

inline

operator<<() [11/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const SubscriptionExpression &	v
	)

operator<<() [12/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		SubscriptionExpression::Kind	v
	)

operator<<() [13/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		SubscriptionExpression::Op	v
	)

operator<<() [14/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const SubscriptionExpression::Literal &	v
	)

operator<<() [15/198]

SPL::ByteBuffer<Checkpoint>& SPL::operator<< ( SPL::ByteBuffer< Checkpoint > &  ckpt, const char *&  str  )

inline

Add/serialize a NULL-terminated string to the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
str	a NULL-terminated string

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator<<() [16/198]

SPL::ByteBuffer<Checkpoint>& SPL::operator<< ( SPL::ByteBuffer< Checkpoint > &  ckpt, const char *  str  )

inline

Add/serialize a NULL-terminated string to the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
str	a NULL-terminated string

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator>>() [2/181]

SPL::ByteBuffer<Checkpoint>& SPL::operator>> ( SPL::ByteBuffer< Checkpoint > &  ckpt, char *&  str  )

inline

Get/deserialize a NULL-terminated string from the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
str	return a NULL-terminated string extracted from the Checkpoint

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for checkpointing or if data cannot be extracted from Checkpoint

operator<<() [17/198]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator<<	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		const T *&	value
	)

Add/serialize data pointed by the given pointer to the Checkpoint. The type T must be serializable to ByteBuffer<Checkpoint>.

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	a pointer

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator<<() [18/198]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator<<	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		const T *	value
	)

Add/serialize data pointed by the given pointer to the Checkpoint. The type T must be serializable to ByteBuffer<Checkpoint>.

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	a pointer

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator>>() [3/181]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator>>	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		T *&	value
	)

Extract/de-serialize data of type T from the Checkpoint. The type T must be de-serializable from ByteBuffer<Checkpoint>. The caller is responsible for de-allocating the memory returned by value with delete.

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	return the data extracted from the Checkpoint

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for checkpointing or if data cannot be extracted from Checkpoint or if memory allocation fails

operator<<() [19/198]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator<<	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		std::shared_ptr< T > &	value
	)

operator>>() [4/181]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator>>	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		std::shared_ptr< T > &	value
	)

operator<<() [20/198]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator<<	(	SPL::ByteBuffer< Checkpoint > &	ckpt,
		const std::shared_ptr< T > &	value
	)

operator>>() [5/181]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator>> ( SPL::ByteBuffer< Checkpoint > &  ckpt, const T *&  value  )

inline

Extract/de-serialize data of type const T from the Checkpoint. The type T must be de-serializable from ByteBuffer<Checkpoint>. The caller is responsible for de-allocating the memory returned by value with delete.

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	return the data extracted from the Checkpoint

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for checkpointing or if data cannot be extracted from Checkpoint or if memory allocation fails

operator<<() [21/198]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator<< ( SPL::ByteBuffer< Checkpoint > &  ckpt, const std::deque< T > &  value  )

inline

Add/serialize an std::deque to the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	an std::deque

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator>>() [6/181]

template<class T >

SPL::ByteBuffer<Checkpoint>& SPL::operator>> ( SPL::ByteBuffer< Checkpoint > &  ckpt, std::deque< T > &  value  )

inline

Extract/de-serialize an std::deque from the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	return the std::deque extracted from the Checkpoint

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for checkpointing or if data cannot be extracted from Checkpoint

operator<<() [22/198]

template<class K , class V >

SPL::ByteBuffer<Checkpoint>& SPL::operator<< ( SPL::ByteBuffer< Checkpoint > &  ckpt, const std::unordered_map< K, V > &  value  )

inline

Add/serialize an std::unordered_map to the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	an std::unordered_map

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for restoring or if the given data cannot be added to Checkpoint

operator>>() [7/181]

template<class K , class V >

SPL::ByteBuffer<Checkpoint>& SPL::operator>> ( SPL::ByteBuffer< Checkpoint > &  ckpt, std::unordered_map< K, V > &  value  )

inline

Extract/de-serialize an std::unordered_map from the Checkpoint

Parameters

ckpt	the ByteBuffer<Checkpoint> instance
value	return the std::unordered_map extracted from the Checkpoint

Returns

the ByteBuffer<Checkpoint> instance

Exceptions

DataStoreException

if the Checkpoint is used for checkpointing or if data cannot be extracted from Checkpoint

operator<<() [23/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, char const &  val  )

inline

operator>>() [8/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, char &  val  )

inline

operator<<() [24/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, bool const &  val  )

inline

operator>>() [9/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, bool &  val  )

inline

operator<<() [25/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, int8_t const &  val  )

inline

operator>>() [10/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, int8_t &  val  )

inline

operator<<() [26/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, int16_t const &  val  )

inline

operator>>() [11/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, int16_t &  val  )

inline

operator<<() [27/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, int32_t const &  val  )

inline

operator>>() [12/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, int32_t &  val  )

inline

operator<<() [28/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, int64_t const &  val  )

inline

operator>>() [13/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, int64_t &  val  )

inline

operator<<() [29/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, uint8_t const &  val  )

inline

operator>>() [14/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, uint8_t &  val  )

inline

operator<<() [30/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, uint16_t const &  val  )

inline

operator>>() [15/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, uint16_t &  val  )

inline

operator<<() [31/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, uint32_t const &  val  )

inline

operator>>() [16/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, uint32_t &  val  )

inline

operator<<() [32/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, uint64_t const &  val  )

inline

operator>>() [17/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, uint64_t &  val  )

inline

operator<<() [33/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, float const &  val  )

inline

operator>>() [18/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, float &  val  )

inline

operator<<() [34/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, double const &  val  )

inline

operator>>() [19/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, double &  val  )

inline

operator<<() [35/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, long double const &  val  )

inline

operator>>() [20/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, long double &  val  )

inline

operator<<() [36/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, USTRING_BB_TYPE const &  val  )

inline

operator>>() [21/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, USTRING_BB_TYPE &  val  )

inline

operator<<() [37/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, char *const &  val  )

inline

operator>>() [22/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, char *&  val  )

inline

operator<<() [38/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, char const *const &  val  )

inline

operator>>() [23/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, char const *&  val  )

inline

operator<<() [39/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, void *const &  val  )

inline

operator>>() [24/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, void *&  val  )

inline

operator<<() [40/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, void const *const &  val  )

inline

operator>>() [25/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, void const *&  val  )

inline

operator<<() [41/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, char16_t const &  val  )

inline

operator>>() [26/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, char16_t &  val  )

inline

operator<<() [42/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, std::string const &  val  )

inline

operator>>() [27/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::string &  val  )

inline

operator<<() [43/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, RSTRING_BB_TYPE const &  val  )

inline

operator>>() [28/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, RSTRING_BB_TYPE &  val  )

inline

operator<<() [44/198]

template<class S , class T >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const std::vector< T > &  vec  )

inline

operator>>() [29/181]

template<class S , class T >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::vector< T > &  vec  )

inline

operator<<() [45/198]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const std::pair< K, V > &  pr  )

inline

operator>>() [30/181]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::pair< K, V > &  pr  )

inline

operator<<() [46/198]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const std::unordered_map< K, V > &  map  )

inline

operator>>() [31/181]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::unordered_map< K, V > &  map  )

inline

operator<<() [47/198]

template<class S , class T >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const std::unordered_set< T > &  set  )

inline

operator>>() [32/181]

template<class S , class T >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::unordered_set< T > &  set  )

inline

operator<<() [48/198]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const std::map< K, V > &  map  )

inline

operator>>() [33/181]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, std::map< K, V > &  map  )

inline

operator<<() [49/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, char const &  val  )

inline

operator>>() [34/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, char &  val  )

inline

operator<<() [50/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, bool const &  val  )

inline

operator>>() [35/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, bool &  val  )

inline

operator<<() [51/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, int8_t const &  val  )

inline

operator>>() [36/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, int8_t &  val  )

inline

operator<<() [52/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, int16_t const &  val  )

inline

operator>>() [37/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, int16_t &  val  )

inline

operator<<() [53/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, int32_t const &  val  )

inline

operator>>() [38/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, int32_t &  val  )

inline

operator<<() [54/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, int64_t const &  val  )

inline

operator>>() [39/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, int64_t &  val  )

inline

operator<<() [55/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, uint8_t const &  val  )

inline

operator>>() [40/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, uint8_t &  val  )

inline

operator<<() [56/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, uint16_t const &  val  )

inline

operator>>() [41/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, uint16_t &  val  )

inline

operator<<() [57/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, uint32_t const &  val  )

inline

operator>>() [42/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, uint32_t &  val  )

inline

operator<<() [58/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, uint64_t const &  val  )

inline

operator>>() [43/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, uint64_t &  val  )

inline

operator<<() [59/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, float const &  val  )

inline

operator>>() [44/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, float &  val  )

inline

operator<<() [60/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, double const &  val  )

inline

operator>>() [45/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, double &  val  )

inline

operator<<() [61/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, long double const &  val  )

inline

operator>>() [46/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, long double &  val  )

inline

operator<<() [62/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, char *const &  val  )

inline

operator>>() [47/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, char *&  val  )

inline

operator<<() [63/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, char const *const &  val  )

inline

operator>>() [48/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, char const *&  val  )

inline

operator<<() [64/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, USTRING_BB_TYPE const &  val  )

inline

operator>>() [49/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, USTRING_BB_TYPE &  val  )

inline

operator<<() [65/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, RSTRING_BB_TYPE const &  val  )

inline

operator>>() [50/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, RSTRING_BB_TYPE &  val  )

inline

operator<<() [66/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, void *const &  val  )

inline

operator>>() [51/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, void *&  val  )

inline

operator<<() [67/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, void const *const &  val  )

inline

operator>>() [52/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, void const *&  val  )

inline

operator<<() [68/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, char16_t const &  val  )

inline

operator>>() [53/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, char16_t &  val  )

inline

operator<<() [69/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, std::string const &  val  )

inline

operator>>() [54/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::string &  val  )

inline

operator<<() [70/198]

template<class T >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const std::vector< T > &  vec  )

inline

operator>>() [55/181]

template<class T >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::vector< T > &  vec  )

inline

operator<<() [71/198]

template<class K , class V >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const std::pair< K, V > &  pr  )

inline

operator>>() [56/181]

template<class K , class V >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::pair< K, V > &  pr  )

inline

operator<<() [72/198]

template<class K , class V >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const std::unordered_map< K, V > &  map  )

inline

operator>>() [57/181]

template<class K , class V >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::unordered_map< K, V > &  map  )

inline

operator<<() [73/198]

template<class T >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const std::unordered_set< T > &  set  )

inline

operator>>() [58/181]

template<class T >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::unordered_set< T > &  set  )

inline

operator<<() [74/198]

template<class K , class V >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const std::map< K, V > &  map  )

inline

operator>>() [59/181]

template<class K , class V >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, std::map< K, V > &  map  )

inline

operator<<() [75/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, char const &  val  )

inline

operator>>() [60/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, char &  val  )

inline

operator<<() [76/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, bool const &  val  )

inline

operator>>() [61/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, bool &  val  )

inline

operator<<() [77/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, int8_t const &  val  )

inline

operator>>() [62/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, int8_t &  val  )

inline

operator<<() [78/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, int16_t const &  val  )

inline

operator>>() [63/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, int16_t &  val  )

inline

operator<<() [79/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, int32_t const &  val  )

inline

operator>>() [64/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, int32_t &  val  )

inline

operator<<() [80/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, int64_t const &  val  )

inline

operator>>() [65/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, int64_t &  val  )

inline

operator<<() [81/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, uint8_t const &  val  )

inline

operator>>() [66/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, uint8_t &  val  )

inline

operator<<() [82/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, uint16_t const &  val  )

inline

operator>>() [67/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, uint16_t &  val  )

inline

operator<<() [83/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, uint32_t const &  val  )

inline

operator>>() [68/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, uint32_t &  val  )

inline

operator<<() [84/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, uint64_t const &  val  )

inline

operator>>() [69/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, uint64_t &  val  )

inline

operator<<() [85/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, float const &  val  )

inline

operator>>() [70/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, float &  val  )

inline

operator<<() [86/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, double const &  val  )

inline

operator>>() [71/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, double &  val  )

inline

operator<<() [87/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, long double const &  val  )

inline

operator>>() [72/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, long double &  val  )

inline

operator<<() [88/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, char *const &  val  )

inline

operator>>() [73/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, char *&  val  )

inline

operator<<() [89/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, char const *const &  val  )

inline

operator>>() [74/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, char const *&  val  )

inline

operator<<() [90/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, USTRING_BB_TYPE const &  val  )

inline

operator>>() [75/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, USTRING_BB_TYPE &  val  )

inline

operator<<() [91/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, RSTRING_BB_TYPE const &  val  )

inline

operator>>() [76/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, RSTRING_BB_TYPE &  val  )

inline

operator<<() [92/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, void *const &  val  )

inline

operator>>() [77/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, void *&  val  )

inline

operator<<() [93/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, void const *const &  val  )

inline

operator>>() [78/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, void const *&  val  )

inline

operator<<() [94/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, char16_t const &  val  )

inline

operator>>() [79/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, char16_t &  val  )

inline

operator<<() [95/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, std::string const &  val  )

inline

operator>>() [80/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::string &  val  )

inline

operator<<() [96/198]

template<class T >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const std::vector< T > &  vec  )

inline

operator>>() [81/181]

template<class T >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::vector< T > &  vec  )

inline

operator<<() [97/198]

template<class K , class V >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const std::pair< K, V > &  pr  )

inline

operator>>() [82/181]

template<class K , class V >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::pair< K, V > &  pr  )

inline

operator<<() [98/198]

template<class K , class V >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const std::unordered_map< K, V > &  map  )

inline

operator>>() [83/181]

template<class K , class V >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::unordered_map< K, V > &  map  )

inline

operator<<() [99/198]

template<class T >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const std::unordered_set< T > &  set  )

inline

operator>>() [84/181]

template<class T >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::unordered_set< T > &  set  )

inline

operator<<() [100/198]

template<class K , class V >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const std::map< K, V > &  map  )

inline

operator>>() [85/181]

template<class K , class V >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, std::map< K, V > &  map  )

inline

operator==() [1/4]

bool SPL::operator== ( const Optional &  lhs, const Optional &  rhs  )

inline

operator!=() [1/4]

bool SPL::operator!= ( const Optional &  lhs, const Optional &  rhs  )

inline

operator<<() [101/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const Optional &  x  )

inline

operator>>() [86/181]

std::istream& SPL::operator>> ( std::istream &  istr, Optional &  x  )

inline

serializeWithPrecision() [1/15]

template<class T , int32_t size>

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const blist< T, size > &  x  )

inline

operator<<() [102/198]

template<class T , int32_t size>

std::ostream& SPL::operator<< ( std::ostream &  ostr, const blist< T, size > &  x  )

inline

operator>>() [87/181]

template<class T , int32_t size>

std::istream& SPL::operator>> ( std::istream &  istr, blist< T, size > &  x  )

inline

deserializeWithSuffix() [1/20]

template<class T , int32_t size>

void SPL::deserializeWithSuffix ( std::istream &  istr, blist< T, size > &  x  )

inline

deserializeWithNanAndInfs() [1/19]

template<class T , int32_t size>

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, blist< T, size > &  x, bool  withSuffix = false  )

inline

operator<<() [103/198]

template<class S , class T , int32_t size>

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const blist< T, size > &  x  )

inline

operator<<() [104/198]

template<class T , int32_t size>

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const blist< T, size > &  x  )

inline

operator<<() [105/198]

template<class T , int32_t size>

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const blist< T, size > &  x  )

inline

operator>>() [88/181]

template<class S , class T , int32_t size>

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, blist< T, size > &  x  )

inline

operator>>() [89/181]

template<class T , int32_t size>

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, blist< T, size > &  x  )

inline

operator>>() [90/181]

template<class T , int32_t size>

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, blist< T, size > &  x  )

inline

operator<<() [106/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const blob &  x  )

inline

operator<<() [107/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const blob &  x  )

inline

operator<<() [108/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const blob &  x  )

inline

operator>>() [91/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, blob &  x  )

inline

operator>>() [92/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, blob &  x  )

inline

operator>>() [93/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, blob &  x  )

inline

operator<<() [109/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const blob &  x  )

inline

operator>>() [94/181]

std::istream& SPL::operator>> ( std::istream &  istr, blob &  x  )

inline

serializeWithPrecision() [2/15]

template<class K , class V , int32_t msize>

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const bmap< K, V, msize > &  x  )

inline

operator<<() [110/198]

template<class K , class V , int32_t msize>

std::ostream& SPL::operator<< ( std::ostream &  ostr, const bmap< K, V, msize > &  x  )

inline

operator>>() [95/181]

template<class K , class V , int32_t msize>

std::istream& SPL::operator>> ( std::istream &  istr, bmap< K, V, msize > &  x  )

inline

deserializeWithSuffix() [2/20]

template<class K , class V , int32_t msize>

void SPL::deserializeWithSuffix ( std::istream &  istr, bmap< K, V, msize > &  x  )

inline

deserializeWithNanAndInfs() [2/19]

template<class K , class V , int32_t msize>

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, bmap< K, V, msize > &  x, bool  withSuffix = false  )

inline

operator<<() [111/198]

template<class S , class K , class V , int32_t msize>

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const bmap< K, V, msize > &  x  )

inline

operator<<() [112/198]

template<class K , class V , int32_t msize>

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const bmap< K, V, msize > &  x  )

inline

operator<<() [113/198]

template<class K , class V , int32_t msize>

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const bmap< K, V, msize > &  x  )

inline

operator>>() [96/181]

template<class S , class K , class V , int32_t msize>

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, bmap< K, V, msize > &  x  )

inline

operator>>() [97/181]

template<class K , class V , int32_t msize>

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, bmap< K, V, msize > &  x  )

inline

operator>>() [98/181]

template<class K , class V , int32_t msize>

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, bmap< K, V, msize > &  x  )

inline

serializeWithPrecision() [3/15]

template<class K , int32_t msize>

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const bset< K, msize > &  x  )

inline

operator<<() [114/198]

template<class K , int32_t msize>

std::ostream& SPL::operator<< ( std::ostream &  ostr, const bset< K, msize > &  x  )

inline

operator>>() [99/181]

template<class K , int32_t msize>

std::istream& SPL::operator>> ( std::istream &  istr, bset< K, msize > &  x  )

inline

deserializeWithSuffix() [3/20]

template<class K , int32_t msize>

void SPL::deserializeWithSuffix ( std::istream &  istr, bset< K, msize > &  x  )

inline

deserializeWithNanAndInfs() [3/19]

template<class K , int32_t msize>

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, bset< K, msize > &  x, bool  withSuffix = false  )

inline

operator<<() [115/198]

template<class S , class K , int32_t msize>

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const bset< K, msize > &  x  )

inline

operator<<() [116/198]

template<class K , int32_t msize>

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const bset< K, msize > &  x  )

inline

operator<<() [117/198]

template<class K , int32_t msize>

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const bset< K, msize > &  x  )

inline

operator>>() [100/181]

template<class S , class K , int32_t msize>

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, bset< K, msize > &  x  )

inline

operator>>() [101/181]

template<class K , int32_t msize>

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, bset< K, msize > &  x  )

inline

operator>>() [102/181]

template<class K , int32_t msize>

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, bset< K, msize > &  x  )

inline

operator<<() [118/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const BString &  x  )

inline

operator<<() [119/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const BString &  x  )

inline

operator<<() [120/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const BString &  x  )

inline

operator>>() [103/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, BString &  x  )

inline

operator>>() [104/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, BString &  x  )

inline

operator>>() [105/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, BString &  x  )

inline

operator<<() [121/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const BString &  x  )

inline

operator>>() [106/181]

std::istream& SPL::operator>> ( std::istream &  istr, BString &  x  )

inline

operator<<() [122/198]

template<int32_t size>

std::ostream& SPL::operator<< ( std::ostream &  ostr, const bstring< size > &  x  )

inline

operator>>() [107/181]

template<int32_t size>

std::istream& SPL::operator>> ( std::istream &  istr, bstring< size > &  x  )

inline

operator<<() [123/198]

template<int32_t size>

VirtualByteBuffer& SPL::operator<< ( VirtualByteBuffer &  buf, const bstring< size > &  x  )

inline

operator>>() [108/181]

template<int32_t size>

VirtualByteBuffer& SPL::operator>> ( VirtualByteBuffer &  buf, bstring< size > &  x  )

inline

operator<<() [124/198]

template<class S , int32_t size>

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const bstring< size > &  x  )

inline

operator<<() [125/198]

template<int32_t size>

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const bstring< size > &  x  )

inline

operator<<() [126/198]

template<int32_t size>

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const bstring< size > &  x  )

inline

operator>>() [109/181]

template<class S , int32_t size>

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, bstring< size > &  x  )

inline

operator>>() [110/181]

template<int32_t size>

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, bstring< size > &  x  )

inline

operator>>() [111/181]

template<int32_t size>

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, bstring< size > &  x  )

inline

serializeUnquoted() [1/3]

template<class Stream , int32_t size>

Stream& SPL::serializeUnquoted ( Stream &  stm, SPL::bstring< size > const &  str  )

inline

Serialize a bstring in unquoted form

Parameters

stm	the output stream object
str	the string to serialize

Returns

the output stream object

operator==() [2/4]

bool SPL::operator== ( const Collection &  lhs, const Collection &  rhs  )

inline

operator!=() [2/4]

bool SPL::operator!= ( const Collection &  lhs, const Collection &  rhs  )

inline

serializeWithPrecision() [4/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const Collection &  x  )

inline

operator<<() [127/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const Collection &  x  )

inline

operator>>() [112/181]

std::istream& SPL::operator>> ( std::istream &  istr, Collection &  x  )

inline

deserializeWithSuffix() [4/20]

void SPL::deserializeWithSuffix ( std::istream &  istr, Collection &  x  )

inline

serializeWithPrecision() [5/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, complex32 const &  v  )

inline

serializeWithPrecision() [6/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, complex64 const &  v  )

inline

extractIntoComplex()

template<class Buffer , class T >

void SPL::extractIntoComplex ( Buffer &  buf, std::complex< T > &  x  )

inline

operator<<() [128/198]

template<class T >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const std::complex< T > &  x  )

inline

operator<<() [129/198]

template<class T >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const std::complex< T > &  x  )

inline

operator<<() [130/198]

template<class S , class T >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const std::complex< T > &  x  )

inline

operator>>() [113/181]

template<class T >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, std::complex< T > &  x  )

inline

operator>>() [114/181]

template<class T >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, std::complex< T > &  x  )

inline

operator>>() [115/181]

template<class S , class T >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, std::complex< T > &  x  )

inline

serializeWithPrecision() [7/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, decimal32 const &  v  )

inline

serializeWithPrecision() [8/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, decimal64 const &  v  )

inline

serializeWithPrecision() [9/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, decimal128 const &  v  )

inline

operator<<() [131/198]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator<< ( ByteBuffer< BufferType > &  buf, const decimal32 &  x  )

inline

operator<<() [132/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const decimal32 &  x  )

inline

operator<<() [133/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const decimal32 &  x  )

inline

operator>>() [116/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, decimal32 &  x  )

inline

operator>>() [117/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, decimal32 &  x  )

inline

operator>>() [118/181]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator>> ( ByteBuffer< BufferType > &  buf, decimal32 &  x  )

inline

operator<<() [134/198]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator<< ( ByteBuffer< NetworkByteBuffer > &  buf, const decimal32 &  x  )

inline

operator<<() [135/198]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator<< ( ByteBuffer< NativeByteBuffer > &  buf, const decimal32 &  x  )

inline

operator>>() [119/181]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator>> ( ByteBuffer< NetworkByteBuffer > &  buf, decimal32 &  x  )

inline

operator>>() [120/181]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator>> ( ByteBuffer< NativeByteBuffer > &  buf, decimal32 &  x  )

inline

operator<<() [136/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const decimal64 &  x  )

inline

operator<<() [137/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const decimal64 &  x  )

inline

operator>>() [121/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, decimal64 &  x  )

inline

operator>>() [122/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, decimal64 &  x  )

inline

operator<<() [138/198]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator<< ( ByteBuffer< BufferType > &  buf, const decimal64 &  x  )

inline

operator>>() [123/181]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator>> ( ByteBuffer< BufferType > &  buf, decimal64 &  x  )

inline

operator<<() [139/198]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator<< ( ByteBuffer< NetworkByteBuffer > &  buf, const decimal64 &  x  )

inline

operator<<() [140/198]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator<< ( ByteBuffer< NativeByteBuffer > &  buf, const decimal64 &  x  )

inline

operator>>() [124/181]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator>> ( ByteBuffer< NetworkByteBuffer > &  buf, decimal64 &  x  )

inline

operator>>() [125/181]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator>> ( ByteBuffer< NativeByteBuffer > &  buf, decimal64 &  x  )

inline

operator<<() [141/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const decimal128 &  x  )

inline

operator<<() [142/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const decimal128 &  x  )

inline

operator>>() [126/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, decimal128 &  x  )

inline

operator>>() [127/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, decimal128 &  x  )

inline

operator<<() [143/198]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator<< ( ByteBuffer< BufferType > &  buf, const decimal128 &  x  )

inline

operator>>() [128/181]

template<class BufferType >

ByteBuffer<BufferType>& SPL::operator>> ( ByteBuffer< BufferType > &  buf, decimal128 &  x  )

inline

operator<<() [144/198]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator<< ( ByteBuffer< NetworkByteBuffer > &  buf, const decimal128 &  x  )

inline

operator<<() [145/198]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator<< ( ByteBuffer< NativeByteBuffer > &  buf, const decimal128 &  x  )

inline

operator>>() [129/181]

template<>

ByteBuffer<NativeByteBuffer>& SPL::operator>> ( ByteBuffer< NativeByteBuffer > &  buf, decimal128 &  x  )

inline

operator>>() [130/181]

template<>

ByteBuffer<NetworkByteBuffer>& SPL::operator>> ( ByteBuffer< NetworkByteBuffer > &  buf, decimal128 &  x  )

inline

deserializeWithSuffix() [5/20]

void SPL::deserializeWithSuffix ( std::istream &  s, decimal32 &  v  )

inline

deserializeWithSuffix() [6/20]

void SPL::deserializeWithSuffix ( std::istream &  s, decimal64 &  v  )

inline

deserializeWithSuffix() [7/20]

void SPL::deserializeWithSuffix ( std::istream &  s, decimal128 &  v  )

inline

deserializeWithNanAndInfs() [4/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, decimal32 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [5/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, decimal64 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [6/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, decimal128 &  v, bool  withSuffix = false  )

inline

operator==() [3/4]

bool SPL::operator== ( const Enum &  lhs, const Enum &  rhs  )

inline

operator!=() [3/4]

bool SPL::operator!= ( const Enum &  lhs, const Enum &  rhs  )

inline

operator<<() [146/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const Enum &  x  )

inline

operator>>() [131/181]

std::istream& SPL::operator>> ( std::istream &  istr, Enum &  x  )

inline

operator<<() [147/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const Enum &  x  )

inline

operator<<() [148/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const Enum &  x  )

inline

operator<<() [149/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const Enum &  x  )

inline

operator>>() [132/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, Enum &  x  )

inline

operator>>() [133/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, Enum &  x  )

inline

operator>>() [134/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, Enum &  x  )

inline

serializeWithPrecision() [10/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, float32 const &  v  )

inline

serializeWithPrecision() [11/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  s, float64 const &  v  )

inline

deserializeWithSuffix() [8/20]

void SPL::deserializeWithSuffix ( std::istream &  s, float32 &  v  )

inline

deserializeWithSuffix() [9/20]

void SPL::deserializeWithSuffix ( std::istream &  s, float64 &  v  )

inline

deserializeWithNanAndInfs() [7/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, float32 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [8/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, float64 &  v, bool  withSuffix = false  )

inline

operator<<() [150/198]

template<class S >

ByteBuffer< S > & SPL::operator<< ( ByteBuffer< S > &  sbuf, const boolean &  x  )

inline

operator<<() [151/198]

NetworkByteBuffer & SPL::operator<< ( NetworkByteBuffer &  sbuf, const boolean &  x  )

inline

operator<<() [152/198]

NativeByteBuffer & SPL::operator<< ( NativeByteBuffer &  sbuf, const boolean &  x  )

inline

operator>>() [135/181]

template<class S >

ByteBuffer< S > & SPL::operator>> ( ByteBuffer< S > &  sbuf, boolean &  x  )

inline

operator>>() [136/181]

NetworkByteBuffer & SPL::operator>> ( NetworkByteBuffer &  sbuf, boolean &  x  )

inline

operator>>() [137/181]

NativeByteBuffer & SPL::operator>> ( NativeByteBuffer &  sbuf, boolean &  x  )

inline

operator<<() [153/198]

std::ostream & SPL::operator<< ( std::ostream &  ostr, const boolean &  x  )

inline

operator>>() [138/181]

std::istream & SPL::operator>>	(	std::istream &	istr,
		boolean &	x
	)

deserializeWithSuffix() [10/20]

void SPL::deserializeWithSuffix ( std::istream &  s, int8 &  v  )

inline

deserializeWithSuffix() [11/20]

void SPL::deserializeWithSuffix ( std::istream &  s, int16 &  v  )

inline

deserializeWithSuffix() [12/20]

void SPL::deserializeWithSuffix ( std::istream &  s, int32 &  v  )

inline

deserializeWithSuffix() [13/20]

void SPL::deserializeWithSuffix ( std::istream &  s, int64 &  v  )

inline

deserializeWithSuffix() [14/20]

void SPL::deserializeWithSuffix ( std::istream &  s, uint16 &  v  )

inline

deserializeWithSuffix() [15/20]

void SPL::deserializeWithSuffix ( std::istream &  s, uint32 &  v  )

inline

deserializeWithSuffix() [16/20]

void SPL::deserializeWithSuffix ( std::istream &  s, uint64 &  v  )

inline

deserializeWithNanAndInfs() [9/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, int8 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [10/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, int16 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [11/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, int32 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [12/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, int64 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [13/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, uint16 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [14/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, uint32 &  v, bool  withSuffix = false  )

inline

deserializeWithNanAndInfs() [15/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  s, uint64 &  v, bool  withSuffix = false  )

inline

serializeWithPrecision() [12/15]

template<class T >

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const list< T > &  x  )

inline

operator<<() [154/198]

template<class T >

std::ostream& SPL::operator<< ( std::ostream &  ostr, const list< T > &  x  )

inline

operator>>() [139/181]

template<class T >

std::istream& SPL::operator>> ( std::istream &  istr, list< T > &  x  )

inline

deserializeWithSuffix() [17/20]

template<class T >

void SPL::deserializeWithSuffix ( std::istream &  istr, list< T > &  x  )

inline

deserializeWithNanAndInfs() [16/19]

template<class T >

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, list< T > &  x, bool  withSuffix = false  )

inline

operator<<() [155/198]

template<class S , class T >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const list< T > &  x  )

inline

operator<<() [156/198]

template<class T >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const list< T > &  x  )

inline

operator<<() [157/198]

template<class T >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const list< T > &  x  )

inline

operator>>() [140/181]

template<class S , class T >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, list< T > &  x  )

inline

operator>>() [141/181]

template<class T >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, list< T > &  x  )

inline

operator>>() [142/181]

template<class T >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, list< T > &  x  )

inline

serializeWithPrecision() [13/15]

template<class K , class V >

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const map< K, V > &  x  )

inline

operator<<() [158/198]

template<class K , class V >

std::ostream& SPL::operator<< ( std::ostream &  ostr, const map< K, V > &  x  )

inline

operator>>() [143/181]

template<class K , class V >

std::istream& SPL::operator>> ( std::istream &  istr, map< K, V > &  x  )

inline

deserializeWithSuffix() [18/20]

template<class K , class V >

void SPL::deserializeWithSuffix ( std::istream &  istr, map< K, V > &  x  )

inline

deserializeWithNanAndInfs() [17/19]

template<class K , class V >

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, map< K, V > &  x, bool  withSuffix = false  )

inline

operator<<() [159/198]

template<class K , class V >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const map< K, V > &  x  )

inline

operator<<() [160/198]

template<class K , class V >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const map< K, V > &  x  )

inline

operator<<() [161/198]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const map< K, V > &  x  )

inline

operator>>() [144/181]

template<class S , class K , class V >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, map< K, V > &  x  )

inline

operator>>() [145/181]

template<class K , class V >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, map< K, V > &  x  )

inline

operator>>() [146/181]

template<class K , class V >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, map< K, V > &  x  )

inline

dotPlus() [1/12]

template<class T >

SPL::list< T > SPL::dotPlus ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotPlus() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotPlus ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotPlus() [3/12]

template<class T >

SPL::list< T > SPL::dotPlus ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotPlus() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotPlus ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotPlus() [5/12]

template<class T >

SPL::list< T > SPL::dotPlus ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotPlus() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotPlus ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotPlus() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotPlus ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotPlus() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotPlus ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotPlus() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotPlus ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotPlus() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotPlus ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotPlus() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotPlus ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotPlus() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotPlus ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotMinus() [1/12]

template<class T >

SPL::list< T > SPL::dotMinus ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotMinus() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotMinus ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotMinus() [3/12]

template<class T >

SPL::list< T > SPL::dotMinus ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotMinus() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotMinus ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotMinus() [5/12]

template<class T >

SPL::list< T > SPL::dotMinus ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotMinus() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotMinus ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotMinus() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotMinus ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotMinus() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotMinus ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotMinus() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotMinus ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotMinus() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotMinus ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotMinus() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotMinus ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotMinus() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotMinus ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotTimes() [1/12]

template<class T >

SPL::list< T > SPL::dotTimes ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotTimes() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotTimes ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotTimes() [3/12]

template<class T >

SPL::list< T > SPL::dotTimes ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotTimes() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotTimes ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotTimes() [5/12]

template<class T >

SPL::list< T > SPL::dotTimes ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotTimes() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotTimes ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotTimes() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotTimes ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotTimes() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotTimes ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotTimes() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotTimes ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotTimes() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotTimes ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotTimes() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotTimes ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotTimes() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotTimes ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotDivides() [1/12]

template<class T >

SPL::list< T > SPL::dotDivides ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotDivides() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotDivides ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotDivides() [3/12]

template<class T >

SPL::list< T > SPL::dotDivides ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotDivides() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotDivides ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotDivides() [5/12]

template<class T >

SPL::list< T > SPL::dotDivides ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotDivides() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotDivides ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotDivides() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotDivides ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotDivides() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotDivides ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotDivides() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotDivides ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotDivides() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotDivides ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotDivides() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotDivides ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotDivides() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotDivides ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotModulus() [1/12]

template<class T >

SPL::list< T > SPL::dotModulus ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotModulus() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotModulus ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotModulus() [3/12]

template<class T >

SPL::list< T > SPL::dotModulus ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotModulus() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotModulus ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotModulus() [5/12]

template<class T >

SPL::list< T > SPL::dotModulus ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotModulus() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotModulus ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotModulus() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotModulus ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotModulus() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotModulus ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotModulus() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotModulus ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotModulus() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotModulus ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotModulus() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotModulus ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotModulus() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotModulus ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotAnd() [1/12]

template<class T >

SPL::list< T > SPL::dotAnd ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotAnd() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotAnd ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotAnd() [3/12]

template<class T >

SPL::list< T > SPL::dotAnd ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotAnd() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotAnd ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotAnd() [5/12]

template<class T >

SPL::list< T > SPL::dotAnd ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotAnd() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotAnd ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotAnd() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotAnd ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotAnd() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotAnd ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotAnd() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotAnd ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotAnd() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotAnd ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotAnd() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotAnd ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotAnd() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotAnd ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotOr() [1/12]

template<class T >

SPL::list< T > SPL::dotOr ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotOr() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotOr ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotOr() [3/12]

template<class T >

SPL::list< T > SPL::dotOr ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotOr() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotOr ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotOr() [5/12]

template<class T >

SPL::list< T > SPL::dotOr ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotOr() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotOr ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotOr() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotOr ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotOr() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotOr ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotOr() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotOr ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotOr() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotOr ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotOr() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotOr ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotOr() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotOr ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotXor() [1/12]

template<class T >

SPL::list< T > SPL::dotXor ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotXor() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotXor ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotXor() [3/12]

template<class T >

SPL::list< T > SPL::dotXor ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotXor() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotXor ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotXor() [5/12]

template<class T >

SPL::list< T > SPL::dotXor ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotXor() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotXor ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotXor() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotXor ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotXor() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotXor ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotXor() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotXor ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotXor() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotXor ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotXor() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotXor ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotXor() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotXor ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotLshift() [1/12]

template<class T >

SPL::list< T > SPL::dotLshift ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotLshift() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotLshift ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLshift() [3/12]

template<class T >

SPL::list< T > SPL::dotLshift ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotLshift() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotLshift ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLshift() [5/12]

template<class T >

SPL::list< T > SPL::dotLshift ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotLshift() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotLshift ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotLshift() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotLshift ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLshift() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotLshift ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLshift() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotLshift ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLshift() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotLshift ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLshift() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotLshift ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotLshift() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotLshift ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotRshift() [1/12]

template<class T >

SPL::list< T > SPL::dotRshift ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotRshift() [2/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotRshift ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotRshift() [3/12]

template<class T >

SPL::list< T > SPL::dotRshift ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotRshift() [4/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotRshift ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotRshift() [5/12]

template<class T >

SPL::list< T > SPL::dotRshift ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotRshift() [6/12]

template<class T , int32_t N>

SPL::blist< T ,N> SPL::dotRshift ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotRshift() [7/12]

template<class K , class T >

SPL::map<K, T > SPL::dotRshift ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotRshift() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotRshift ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotRshift() [9/12]

template<class K , class T >

SPL::map<K, T > SPL::dotRshift ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotRshift() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotRshift ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotRshift() [11/12]

template<class K , class T >

SPL::map<K, T > SPL::dotRshift ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotRshift() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, T ,N> SPL::dotRshift ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator+() [1/32]

template<class T >

SPL::list<T> SPL::operator+ ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator+() [2/32]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator+ ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator+() [3/32]

template<class T >

SPL::list<T> SPL::operator+ ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator+() [4/32]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator+ ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator+() [5/32]

template<class T >

SPL::list<T> SPL::operator+ ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator+() [6/32]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator+ ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator+() [7/32]

template<class K , class T >

SPL::map<K,T> SPL::operator+ ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator+() [8/32]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator+ ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator+() [9/32]

template<class K , class T >

SPL::map<K,T> SPL::operator+ ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator+() [10/32]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator+ ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator+() [11/32]

template<class K , class T >

SPL::map<K,T> SPL::operator+ ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator+() [12/32]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator+ ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator-() [1/12]

template<class T >

SPL::list<T> SPL::operator- ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator-() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator- ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator-() [3/12]

template<class T >

SPL::list<T> SPL::operator- ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator-() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator- ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator-() [5/12]

template<class T >

SPL::list<T> SPL::operator- ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator-() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator- ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator-() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator- ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator-() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator- ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator-() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator- ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator-() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator- ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator-() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator- ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator-() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator- ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator*() [1/12]

template<class T >

SPL::list<T> SPL::operator* ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator*() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator* ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator*() [3/12]

template<class T >

SPL::list<T> SPL::operator* ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator*() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator* ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator*() [5/12]

template<class T >

SPL::list<T> SPL::operator* ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator*() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator* ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator*() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator* ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator*() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator* ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator*() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator* ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator*() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator* ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator*() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator* ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator*() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator* ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator/() [1/12]

template<class T >

SPL::list<T> SPL::operator/ ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator/() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator/ ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator/() [3/12]

template<class T >

SPL::list<T> SPL::operator/ ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator/() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator/ ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator/() [5/12]

template<class T >

SPL::list<T> SPL::operator/ ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator/() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator/ ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator/() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator/ ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator/() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator/ ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator/() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator/ ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator/() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator/ ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator/() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator/ ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator/() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator/ ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator%() [1/13]

template<class T >

SPL::list<T> SPL::operator% ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator%() [2/13]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator% ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator%() [3/13]

template<class T >

SPL::list<T> SPL::operator% ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator%() [4/13]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator% ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator%() [5/13]

template<class T >

SPL::list<T> SPL::operator% ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator%() [6/13]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator% ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator%() [7/13]

template<class K , class T >

SPL::map<K,T> SPL::operator% ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator%() [8/13]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator% ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator%() [9/13]

template<class K , class T >

SPL::map<K,T> SPL::operator% ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator%() [10/13]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator% ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator%() [11/13]

template<class K , class T >

SPL::map<K,T> SPL::operator% ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator%() [12/13]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator% ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator&() [1/12]

template<class T >

SPL::list<T> SPL::operator & ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator&() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator & ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator&() [3/12]

template<class T >

SPL::list<T> SPL::operator & ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator&() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator & ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator&() [5/12]

template<class T >

SPL::list<T> SPL::operator & ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator&() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator & ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator&() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator & ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator&() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator & ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator&() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator & ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator&() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator & ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator&() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator & ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator&() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator & ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator|() [1/12]

template<class T >

SPL::list<T> SPL::operator| ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator|() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator| ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator|() [3/12]

template<class T >

SPL::list<T> SPL::operator| ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator|() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator| ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator|() [5/12]

template<class T >

SPL::list<T> SPL::operator| ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator|() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator| ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator|() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator| ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator|() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator| ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator|() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator| ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator|() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator| ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator|() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator| ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator|() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator| ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator^() [1/12]

template<class T >

SPL::list<T> SPL::operator^ ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator^() [2/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator^ ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator^() [3/12]

template<class T >

SPL::list<T> SPL::operator^ ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator^() [4/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator^ ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator^() [5/12]

template<class T >

SPL::list<T> SPL::operator^ ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator^() [6/12]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator^ ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator^() [7/12]

template<class K , class T >

SPL::map<K,T> SPL::operator^ ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator^() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator^ ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator^() [9/12]

template<class K , class T >

SPL::map<K,T> SPL::operator^ ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator^() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator^ ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator^() [11/12]

template<class K , class T >

SPL::map<K,T> SPL::operator^ ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator^() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator^ ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator<<() [162/198]

template<class T >

SPL::list<T> SPL::operator<< ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator<<() [163/198]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator<< ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator<<() [164/198]

template<class T >

SPL::list<T> SPL::operator<< ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator<<() [165/198]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator<< ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator<<() [166/198]

template<class T >

SPL::list<T> SPL::operator<< ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator<<() [167/198]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator<< ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator<<() [168/198]

template<class K , class T >

SPL::map<K,T> SPL::operator<< ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator<<() [169/198]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator<< ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator<<() [170/198]

template<class K , class T >

SPL::map<K,T> SPL::operator<< ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator<<() [171/198]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator<< ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator<<() [172/198]

template<class K , class T >

SPL::map<K,T> SPL::operator<< ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator<<() [173/198]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator<< ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator>>() [147/181]

template<class T >

SPL::list<T> SPL::operator>> ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator>>() [148/181]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator>> ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator>>() [149/181]

template<class T >

SPL::list<T> SPL::operator>> ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

operator>>() [150/181]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator>> ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator>>() [151/181]

template<class T >

SPL::list<T> SPL::operator>> ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

operator>>() [152/181]

template<class T , int32_t N>

SPL::blist<T,N> SPL::operator>> ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator>>() [153/181]

template<class K , class T >

SPL::map<K,T> SPL::operator>> ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator>>() [154/181]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator>> ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator>>() [155/181]

template<class K , class T >

SPL::map<K,T> SPL::operator>> ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator>>() [156/181]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator>> ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator>>() [157/181]

template<class K , class T >

SPL::map<K,T> SPL::operator>> ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator>>() [158/181]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N> SPL::operator>> ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotEqual() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotEqual ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotEqual() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotEqual ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotEqual() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotEqual ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotEqual() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotEqual ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotEqual() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotEqual ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotEqual() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotEqual ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotEqual() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotEqual ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotEqual() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotEqual ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotEqual() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotEqual ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotEqual() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotEqual ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotEqual() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotEqual ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotEqual() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotEqual ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotNotEqual() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotNotEqual ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotNotEqual() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotNotEqual ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotNotEqual() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotNotEqual ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotNotEqual() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotNotEqual ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotNotEqual() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotNotEqual ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotNotEqual() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotNotEqual ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotNotEqual() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotNotEqual ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotNotEqual() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotNotEqual ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotNotEqual() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotNotEqual ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotNotEqual() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotNotEqual ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotNotEqual() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotNotEqual ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotNotEqual() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotNotEqual ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotGreaterThan() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterThan ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotGreaterThan() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterThan ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotGreaterThan() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterThan ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotGreaterThan() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterThan ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotGreaterThan() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterThan ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotGreaterThan() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterThan ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotGreaterThan() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterThan ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotGreaterThan() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterThan ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotGreaterThan() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterThan ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotGreaterThan() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterThan ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotGreaterThan() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterThan ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotGreaterThan() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterThan ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotGreaterEqual() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterEqual ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotGreaterEqual() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterEqual ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotGreaterEqual() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterEqual ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotGreaterEqual() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterEqual ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotGreaterEqual() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotGreaterEqual ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotGreaterEqual() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotGreaterEqual ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotGreaterEqual() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterEqual ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotGreaterEqual() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterEqual ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotGreaterEqual() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterEqual ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotGreaterEqual() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterEqual ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotGreaterEqual() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotGreaterEqual ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotGreaterEqual() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotGreaterEqual ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotLessThan() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessThan ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotLessThan() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessThan ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLessThan() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessThan ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotLessThan() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessThan ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLessThan() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessThan ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotLessThan() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessThan ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotLessThan() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessThan ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLessThan() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessThan ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLessThan() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessThan ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLessThan() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessThan ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLessThan() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessThan ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotLessThan() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessThan ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

dotLessEqual() [1/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessEqual ( const SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

dotLessEqual() [2/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessEqual ( const SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLessEqual() [3/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessEqual ( const T &  lhs, const SPL::list< T > &  rhs  )

inline

dotLessEqual() [4/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessEqual ( const T &  lhs, const SPL::blist< T, N > &  rhs  )

inline

dotLessEqual() [5/12]

template<class T >

SPL::list< SPL::boolean > SPL::dotLessEqual ( const SPL::list< T > &  lhs, const T &  rhs  )

inline

dotLessEqual() [6/12]

template<class T , int32_t N>

SPL::blist< SPL::boolean ,N> SPL::dotLessEqual ( const SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

dotLessEqual() [7/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessEqual ( const SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLessEqual() [8/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessEqual ( const SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLessEqual() [9/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessEqual ( const T &  lhs, const SPL::map< K, T > &  rhs  )

inline

dotLessEqual() [10/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessEqual ( const T &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

dotLessEqual() [11/12]

template<class K , class T >

SPL::map<K, SPL::boolean > SPL::dotLessEqual ( const SPL::map< K, T > &  lhs, const T &  rhs  )

inline

dotLessEqual() [12/12]

template<class K , class T , int32_t N>

SPL::bmap<K, SPL::boolean ,N> SPL::dotLessEqual ( const SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignPlus() [1/8]

template<class T >

void SPL::assignPlus ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignPlus() [2/8]

template<class T , int32_t N>

void SPL::assignPlus ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignPlus() [3/8]

template<class T >

void SPL::assignPlus ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignPlus() [4/8]

template<class T , int32_t N>

void SPL::assignPlus ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignPlus() [5/8]

template<class K , class T >

void SPL::assignPlus ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignPlus() [6/8]

template<class K , class T , int32_t N>

void SPL::assignPlus ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignPlus() [7/8]

template<class K , class T >

void SPL::assignPlus ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignPlus() [8/8]

template<class K , class T , int32_t N>

void SPL::assignPlus ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignMinus() [1/8]

template<class T >

void SPL::assignMinus ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignMinus() [2/8]

template<class T , int32_t N>

void SPL::assignMinus ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignMinus() [3/8]

template<class T >

void SPL::assignMinus ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignMinus() [4/8]

template<class T , int32_t N>

void SPL::assignMinus ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignMinus() [5/8]

template<class K , class T >

void SPL::assignMinus ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignMinus() [6/8]

template<class K , class T , int32_t N>

void SPL::assignMinus ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignMinus() [7/8]

template<class K , class T >

void SPL::assignMinus ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignMinus() [8/8]

template<class K , class T , int32_t N>

void SPL::assignMinus ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignTimes() [1/8]

template<class T >

void SPL::assignTimes ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignTimes() [2/8]

template<class T , int32_t N>

void SPL::assignTimes ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignTimes() [3/8]

template<class T >

void SPL::assignTimes ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignTimes() [4/8]

template<class T , int32_t N>

void SPL::assignTimes ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignTimes() [5/8]

template<class K , class T >

void SPL::assignTimes ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignTimes() [6/8]

template<class K , class T , int32_t N>

void SPL::assignTimes ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignTimes() [7/8]

template<class K , class T >

void SPL::assignTimes ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignTimes() [8/8]

template<class K , class T , int32_t N>

void SPL::assignTimes ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignDivides() [1/8]

template<class T >

void SPL::assignDivides ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignDivides() [2/8]

template<class T , int32_t N>

void SPL::assignDivides ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignDivides() [3/8]

template<class T >

void SPL::assignDivides ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignDivides() [4/8]

template<class T , int32_t N>

void SPL::assignDivides ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignDivides() [5/8]

template<class K , class T >

void SPL::assignDivides ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignDivides() [6/8]

template<class K , class T , int32_t N>

void SPL::assignDivides ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignDivides() [7/8]

template<class K , class T >

void SPL::assignDivides ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignDivides() [8/8]

template<class K , class T , int32_t N>

void SPL::assignDivides ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignModulus() [1/8]

template<class T >

void SPL::assignModulus ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignModulus() [2/8]

template<class T , int32_t N>

void SPL::assignModulus ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignModulus() [3/8]

template<class T >

void SPL::assignModulus ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignModulus() [4/8]

template<class T , int32_t N>

void SPL::assignModulus ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignModulus() [5/8]

template<class K , class T >

void SPL::assignModulus ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignModulus() [6/8]

template<class K , class T , int32_t N>

void SPL::assignModulus ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignModulus() [7/8]

template<class K , class T >

void SPL::assignModulus ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignModulus() [8/8]

template<class K , class T , int32_t N>

void SPL::assignModulus ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignAnd() [1/8]

template<class T >

void SPL::assignAnd ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignAnd() [2/8]

template<class T , int32_t N>

void SPL::assignAnd ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignAnd() [3/8]

template<class T >

void SPL::assignAnd ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignAnd() [4/8]

template<class T , int32_t N>

void SPL::assignAnd ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignAnd() [5/8]

template<class K , class T >

void SPL::assignAnd ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignAnd() [6/8]

template<class K , class T , int32_t N>

void SPL::assignAnd ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignAnd() [7/8]

template<class K , class T >

void SPL::assignAnd ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignAnd() [8/8]

template<class K , class T , int32_t N>

void SPL::assignAnd ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignOr() [1/8]

template<class T >

void SPL::assignOr ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignOr() [2/8]

template<class T , int32_t N>

void SPL::assignOr ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignOr() [3/8]

template<class T >

void SPL::assignOr ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignOr() [4/8]

template<class T , int32_t N>

void SPL::assignOr ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignOr() [5/8]

template<class K , class T >

void SPL::assignOr ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignOr() [6/8]

template<class K , class T , int32_t N>

void SPL::assignOr ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignOr() [7/8]

template<class K , class T >

void SPL::assignOr ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignOr() [8/8]

template<class K , class T , int32_t N>

void SPL::assignOr ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignLshift() [1/8]

template<class T >

void SPL::assignLshift ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignLshift() [2/8]

template<class T , int32_t N>

void SPL::assignLshift ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignLshift() [3/8]

template<class T >

void SPL::assignLshift ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignLshift() [4/8]

template<class T , int32_t N>

void SPL::assignLshift ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignLshift() [5/8]

template<class K , class T >

void SPL::assignLshift ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignLshift() [6/8]

template<class K , class T , int32_t N>

void SPL::assignLshift ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignLshift() [7/8]

template<class K , class T >

void SPL::assignLshift ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignLshift() [8/8]

template<class K , class T , int32_t N>

void SPL::assignLshift ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignRshift() [1/8]

template<class T >

void SPL::assignRshift ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignRshift() [2/8]

template<class T , int32_t N>

void SPL::assignRshift ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignRshift() [3/8]

template<class T >

void SPL::assignRshift ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignRshift() [4/8]

template<class T , int32_t N>

void SPL::assignRshift ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignRshift() [5/8]

template<class K , class T >

void SPL::assignRshift ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignRshift() [6/8]

template<class K , class T , int32_t N>

void SPL::assignRshift ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignRshift() [7/8]

template<class K , class T >

void SPL::assignRshift ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignRshift() [8/8]

template<class K , class T , int32_t N>

void SPL::assignRshift ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

assignXor() [1/8]

template<class T >

void SPL::assignXor ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

assignXor() [2/8]

template<class T , int32_t N>

void SPL::assignXor ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

assignXor() [3/8]

template<class T >

void SPL::assignXor ( SPL::list< T > &  lhs, const T &  rhs  )

inline

assignXor() [4/8]

template<class T , int32_t N>

void SPL::assignXor ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

assignXor() [5/8]

template<class K , class T >

void SPL::assignXor ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

assignXor() [6/8]

template<class K , class T , int32_t N>

void SPL::assignXor ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

assignXor() [7/8]

template<class K , class T >

void SPL::assignXor ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

assignXor() [8/8]

template<class K , class T , int32_t N>

void SPL::assignXor ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator+=() [1/8]

template<class T >

SPL::list<T>& SPL::operator+= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator+=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator+= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator+=() [3/8]

template<class T >

SPL::list<T>& SPL::operator+= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator+=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator+= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator+=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator+= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator+=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator+= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator+=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator+= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator+=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator+= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator-=() [1/8]

template<class T >

SPL::list<T>& SPL::operator-= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator-=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator-= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator-=() [3/8]

template<class T >

SPL::list<T>& SPL::operator-= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator-=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator-= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator-=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator-= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator-=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator-= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator-=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator-= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator-=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator-= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator*=() [1/8]

template<class T >

SPL::list<T>& SPL::operator*= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator*=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator*= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator*=() [3/8]

template<class T >

SPL::list<T>& SPL::operator*= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator*=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator*= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator*=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator*= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator*=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator*= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator*=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator*= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator*=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator*= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator/=() [1/8]

template<class T >

SPL::list<T>& SPL::operator/= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator/=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator/= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator/=() [3/8]

template<class T >

SPL::list<T>& SPL::operator/= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator/=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator/= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator/=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator/= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator/=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator/= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator/=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator/= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator/=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator/= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator%=() [1/8]

template<class T >

SPL::list<T>& SPL::operator%= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator%=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator%= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator%=() [3/8]

template<class T >

SPL::list<T>& SPL::operator%= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator%=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator%= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator%=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator%= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator%=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator%= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator%=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator%= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator%=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator%= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator&=() [1/8]

template<class T >

SPL::list<T>& SPL::operator &= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator&=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator &= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator&=() [3/8]

template<class T >

SPL::list<T>& SPL::operator &= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator&=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator &= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator&=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator &= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator&=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator &= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator&=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator &= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator&=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator &= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator|=() [1/8]

template<class T >

SPL::list<T>& SPL::operator|= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator|=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator|= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator|=() [3/8]

template<class T >

SPL::list<T>& SPL::operator|= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator|=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator|= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator|=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator|= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator|=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator|= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator|=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator|= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator|=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator|= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator<<=() [1/8]

template<class T >

SPL::list<T>& SPL::operator<<= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator<<=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator<<= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator<<=() [3/8]

template<class T >

SPL::list<T>& SPL::operator<<= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator<<=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator<<= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator<<=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator<<= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator<<=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator<<= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator<<=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator<<= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator<<=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator<<= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator>>=() [1/8]

template<class T >

SPL::list<T>& SPL::operator>>= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator>>=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator>>= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator>>=() [3/8]

template<class T >

SPL::list<T>& SPL::operator>>= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator>>=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator>>= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator>>=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator>>= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator>>=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator>>= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator>>=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator>>= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator>>=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator>>= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator^=() [1/8]

template<class T >

SPL::list<T>& SPL::operator^= ( SPL::list< T > &  lhs, const SPL::list< T > &  rhs  )

inline

operator^=() [2/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator^= ( SPL::blist< T, N > &  lhs, const SPL::blist< T, N > &  rhs  )

inline

operator^=() [3/8]

template<class T >

SPL::list<T>& SPL::operator^= ( SPL::list< T > &  lhs, const T &  rhs  )

inline

operator^=() [4/8]

template<class T , int32_t N>

SPL::blist<T,N>& SPL::operator^= ( SPL::blist< T, N > &  lhs, const T &  rhs  )

inline

operator^=() [5/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator^= ( SPL::map< K, T > &  lhs, const SPL::map< K, T > &  rhs  )

inline

operator^=() [6/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator^= ( SPL::bmap< K, T, N > &  lhs, const SPL::bmap< K, T, N > &  rhs  )

inline

operator^=() [7/8]

template<class K , class T >

SPL::map<K,T>& SPL::operator^= ( SPL::map< K, T > &  lhs, const T &  rhs  )

inline

operator^=() [8/8]

template<class K , class T , int32_t N>

SPL::bmap<K,T,N>& SPL::operator^= ( SPL::bmap< K, T, N > &  lhs, const T &  rhs  )

inline

operator<<() [174/198]

template<class T >

std::ostream& SPL::operator<< ( std::ostream &  ostr, const optional< T > &  val  )

inline

operator>>() [159/181]

template<class T >

std::istream& SPL::operator>> ( std::istream &  istr, optional< T > &  val  )

inline

operator>>() [160/181]

template<class S , class T >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, optional< T > &  val  )

inline

operator<<() [175/198]

template<class S , class T >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const optional< T > &  val  )

inline

operator<<() [176/198]

template<class T >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, optional< T > const &  val  )

inline

operator>>() [161/181]

template<class T >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, optional< T > &  val  )

inline

operator<<() [177/198]

template<class T >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, optional< T > const &  val  )

inline

operator>>() [162/181]

template<class T >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, optional< T > &  val  )

inline

deserializeWithNanAndInfs() [18/19]

template<class T >

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, optional< T > &  val, bool  withSuffix = false  )

inline

serializeWithPrecision() [14/15]

template<class K >

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const set< K > &  x  )

inline

operator<<() [178/198]

template<class K >

std::ostream& SPL::operator<< ( std::ostream &  ostr, const set< K > &  x  )

inline

operator>>() [163/181]

template<class K >

std::istream& SPL::operator>> ( std::istream &  istr, set< K > &  x  )

inline

deserializeWithSuffix() [19/20]

template<class K >

void SPL::deserializeWithSuffix ( std::istream &  istr, set< K > &  x  )

inline

operator<<() [179/198]

template<class K >

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  sbuf, const set< K > &  x  )

inline

operator<<() [180/198]

template<class K >

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  sbuf, const set< K > &  x  )

inline

operator<<() [181/198]

template<class S , class K >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, const set< K > &  x  )

inline

operator>>() [164/181]

template<class S , class K >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, set< K > &  x  )

inline

operator>>() [165/181]

template<class K >

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  sbuf, set< K > &  x  )

inline

operator>>() [166/181]

template<class K >

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  sbuf, set< K > &  x  )

inline

operator+() [13/32]

rstring SPL::operator+ ( rstring const &  lhs, rstring const &  rhs  )

inline

operator+() [14/32]

rstring SPL::operator+ ( rstring const &  lhs, char  rhs  )

inline

operator+() [15/32]

rstring SPL::operator+ ( rstring const &  lhs, RString const &  rhs  )

inline

operator+() [16/32]

rstring SPL::operator+ ( RString const &  lhs, rstring const &  rhs  )

inline

operator+() [17/32]

rstring SPL::operator+ ( rstring const &  lhs, char const *  rhs  )

inline

operator+() [18/32]

rstring SPL::operator+ ( char const *  lhs, rstring const &  rhs  )

inline

operator+() [19/32]

ustring SPL::operator+	(	ustring const &	lhs,
		ustring const &	rhs
	)

operator+() [20/32]

ustring SPL::operator+ ( ustring const &  lhs, rstring const &  rhs  )

inline

operator+() [21/32]

ustring SPL::operator+ ( rstring const &  lhs, ustring const &  rhs  )

inline

operator+() [22/32]

rstring SPL::operator+ ( rstring &&  lhs, rstring const &  rhs  )

inline

operator+() [23/32]

rstring SPL::operator+ ( rstring const &  lhs, rstring &&  rhs  )

inline

operator+() [24/32]

rstring SPL::operator+ ( rstring &&  lhs, rstring &&  rhs  )

inline

operator+() [25/32]

rstring SPL::operator+ ( RString &&  lhs, rstring &&  rhs  )

inline

operator+() [26/32]

rstring SPL::operator+ ( RString &&  lhs, rstring const &  rhs  )

inline

operator+() [27/32]

rstring SPL::operator+ ( RString const &  lhs, rstring &&  rhs  )

inline

operator+() [28/32]

rstring SPL::operator+ ( rstring &&  lhs, RString &&  rhs  )

inline

operator+() [29/32]

rstring SPL::operator+ ( rstring const &  lhs, RString &&  rhs  )

inline

operator+() [30/32]

rstring SPL::operator+ ( rstring &&  lhs, RString const &  rhs  )

inline

operator+() [31/32]

rstring SPL::operator+ ( const char *  lhs, rstring &&  rhs  )

inline

operator+() [32/32]

rstring SPL::operator+ ( rstring &&  lhs, const char *  rhs  )

inline

operator<<() [182/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const ustring &	x
	)

operator>>() [167/181]

std::istream& SPL::operator>>	(	std::istream &	istr,
		ustring &	x
	)

operator<<() [183/198]

std::ostream& SPL::operator<<	(	std::ostream &	ostr,
		const rstring &	x
	)

operator>>() [168/181]

std::istream& SPL::operator>>	(	std::istream &	istr,
		rstring &	x
	)

serializeUnquoted() [2/3]

template<class Stream >

Stream& SPL::serializeUnquoted ( Stream &  stm, SPL::rstring const &  str  )

inline

Serialize an rstring in unquoted form

Parameters

stm	the output stream object
str	the string to serialize

Returns

the output stream object

serializeUnquoted() [3/3]

template<class Stream >

Stream& SPL::serializeUnquoted ( Stream &  stm, SPL::ustring const &  str  )

inline

Serialize a ustring in unquoted form

Parameters

stm	the output stream object
str	the string to serialize

Returns

the output stream object

operator<<() [184/198]

VirtualByteBuffer& SPL::operator<< ( VirtualByteBuffer &  sbuf, rstring const &  val  )

inline

operator>>() [169/181]

VirtualByteBuffer& SPL::operator>> ( VirtualByteBuffer &  sbuf, rstring &  val  )

inline

operator<<() [185/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  sbuf, rstring const &  val  )

inline

operator>>() [170/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  sbuf, rstring &  val  )

inline

operator<<() [186/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const timestamp &  x  )

inline

operator>>() [171/181]

std::istream& SPL::operator>> ( std::istream &  istr, timestamp &  x  )

inline

operator<<() [187/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const timestamp &  x  )

inline

operator<<() [188/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const timestamp &  x  )

inline

operator<<() [189/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const timestamp &  x  )

inline

operator>>() [172/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, timestamp &  x  )

inline

operator>>() [173/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, timestamp &  x  )

inline

operator>>() [174/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, timestamp &  x  )

inline

operator==() [4/4]

bool SPL::operator== ( const Tuple &  lhs, const Tuple &  rhs  )

inline

operator!=() [4/4]

bool SPL::operator!= ( const Tuple &  lhs, const Tuple &  rhs  )

inline

serializeWithPrecision() [15/15]

std::ostream& SPL::serializeWithPrecision ( std::ostream &  ostr, const Tuple &  x  )

inline

deserializeWithSuffix() [20/20]

void SPL::deserializeWithSuffix ( std::istream &  istr, Tuple &  x  )

inline

deserializeWithNanAndInfs() [19/19]

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, Tuple &  x, bool  withSuffix = false  )

inline

operator<<() [190/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const Tuple &  x  )

inline

operator>>() [175/181]

std::istream& SPL::operator>> ( std::istream &  istr, Tuple &  x  )

inline

operator<<() [191/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const Tuple &  x  )

inline

operator>>() [176/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, Tuple &  x  )

inline

operator<<() [192/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const Tuple &  x  )

inline

operator>>() [177/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, Tuple &  x  )

inline

getSerializedSize()

template<class T >

size_t SPL::getSerializedSize

(

T const &

x

)

operator<<() [193/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const xml &  x  )

inline

operator>>() [178/181]

std::istream& SPL::operator>> ( std::istream &  istr, xml &  x  )

inline

operator<<() [194/198]

template<class S >

ByteBuffer<S>& SPL::operator<< ( ByteBuffer< S > &  buf, const xml &  x  )

inline

operator<<() [195/198]

NetworkByteBuffer& SPL::operator<< ( NetworkByteBuffer &  buf, const xml &  x  )

inline

operator<<() [196/198]

NativeByteBuffer& SPL::operator<< ( NativeByteBuffer &  buf, const xml &  x  )

inline

operator>>() [179/181]

template<class S >

ByteBuffer<S>& SPL::operator>> ( ByteBuffer< S > &  buf, xml &  x  )

inline

operator>>() [180/181]

NetworkByteBuffer& SPL::operator>> ( NetworkByteBuffer &  buf, xml &  x  )

inline

operator>>() [181/181]

NativeByteBuffer& SPL::operator>> ( NativeByteBuffer &  buf, xml &  x  )

inline

operator<<() [197/198]

std::ostream& SPL::operator<< ( std::ostream &  ostr, const FormattableMessage &  msg  )

inline

operator<<() [198/198]

template<typename T >

std::ostream& SPL::operator<< ( std::ostream &  stream, const interval< T > &  i  )

inline

operator%() [13/13]

timestamp SPL::operator% ( timestamp const &  l, timestamp const &  r  )

inline

Modulo operator for timestamps.