SPL Namespace Reference

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

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

Classes
class	Metric
	Class that represents a metric object, used for port, operator, and pe metrics. More...
class	SPLRuntimeException
	Class that represents SPL runtime exceptions. More...
class	SPLRuntimeTypeMismatchException
	Class that represents SPL runtime type mismatch exceptions. More...
class	SPLRuntimeDeserializationException
	Class that represents SPL runtime type deserialization exceptions. More...
class	SPLRuntimeSerializationException
	Class that represents SPL runtime type serialization exceptions. More...
class	SPLRuntimeInvalidIndexException
	Class that represents SPL runtime invalid index exceptions. More...
class	SPLRuntimeInvalidArgumentException
	Class that represents SPL runtime invalid argument exceptions. More...
class	SPLRuntimeInvalidMetricException
	Class that represents SPL runtime invalid metric exceptions. More...
class	SPLRuntimeInvalidCheckpointException
	Class that represents SPL runtime invalid checkpoint exceptions. 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	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	SPLRuntimeOperatorException
	Class that represents SPL runtime operator exceptions. More...
class	SPLRuntimeMissingDataDirectory
	Class that represents a missing data directory. More...
class	SPLRuntimeIOException
	Indicates that an exception has occurred when executing an I/O operation. 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	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	ConnectionNotification
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	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	OperatorMetrics
	Class that represents operator metrics. More...
class	OperatorThread
	Class that represents an operator thread. 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	AutoPortMutex
	Class that provides an RAII handler for critical sections in port processing. More...
class	FilterExpression
	Class that represents a filter expression clause for import specifications. More...
class	OperatorInputPort
	Class that represents an operator input port. More...
class	OperatorOutputPort
	Class that represents an operator output port. More...
class	OperatorPort
	Class that forms a common base for operator ports. More...
class	Punctuation
	Class that represents a punctuation. 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	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	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...
class	DataStoreException
	Class that represents runtime exceptions thrown by Checkpointing APIs. 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	PEMetrics
	Class that represents PE metrics. More...
class	ProcessingElement
	Class that represents a processing element. More...
class	ByteBuffer
	Class that serves as the base for the NativeByteBuffer and NetworkByteBuffer classes. 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	List
	Class that defines reflective interfaces for lists. More...
class	Map
	Class that defines reflective interfaces for maps. More...
class	Set
	Class that defines reflective interfaces for sets. 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	Collection
	Class that serves as an interface for the List, Map, and Set classes. More...
class	Enum
	Class that serves as a reflective interface for the enumeration types. 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	ConstListIterator
	Class that serves as a constant iterator for reflective list iteration. More...
class	map
	Class that represents a map type (extends from std::tr1::unordered_map). More...
class	MapIterator
	Class that serves as an iterator for reflective map iteration. More...
class	ConstMapIterator
	Class that serves as a constant iterator for reflective map iteration. More...
class	set
	Class that represents a set type (extends from std::tr1::unordered_set). More...
class	SetIterator
	Class that serves as an iterator for reflective set iteration. More...
class	ConstSetIterator
	Class that serves as a constant iterator for reflective set iteration. More...
class	rstring
class	timestamp
	Class that represents a timestamp type. 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	ConstTupleAttribute
	Class that serves as a reflective interface for const tuple attributes. More...
class	TupleIterator
	Class that serves as an iterator for reflective tuple iteration. More...
class	ConstTupleIterator
	Class that serves as an iterator for reflective const tuple iteration. More...
class	ustring
	Class that represents a ustring primitive type. More...
class	ConstValueHandle
	Class for reflective manipulation of const values of spl types. More...
class	ValueHandle
	Class for reflective manipulation of values of SPL types. More...
class	xml
	Class that represents an xml type. More...
class	CV
	Class that implements a wrapper for a pthread conditional variable. More...
class	FormattableMessage
class	FormattableMessage0
class	FormattableMessage1
class	FormattableMessage2
class	FormattableMessage3
class	FormattableMessage4
class	FormattableMessage5
class	FormattableMessage6
class	FormattableMessage7
class	FormattableMessage8
class	FormattableMessage9
class	FormattableMessage10
class	Mutex
	Class that provides a wrapper for a pthread mutex. More...
class	AutoMutex
	Class that provides an RAII handler for critical sections. More...
class	RWMutex
	Class that provides a wrapper for a pthread rwlock. More...
class	SpinLock
	Class that provides a wrapper for a pthread mutex. More...
class	AutoSpinLock
	Class that provides an RAII handler for critical sections. More...
class	Thread
	Class that implements a wrapper for a pthread thread. More...
class	CountWindowPolicy
	Class that represents a count based window policy. More...
class	DeltaWindowPolicy
	Class that represents a delta based window policy. More...
class	PartitionAgePartitionEvictionPolicy
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	PunctWindowPolicy
	Class that represents a punctuation based window policy. More...
class	SlidingWindow
	Class that represents a sliding window. More...
class	TimeWindowPolicy
	Class that represents a time based window policy. More...
class	TumblingWindow
	Class that represents a tumbling window. More...
class	TumblingWindowSummarizer
	Class that defines an interface for tumbling window summarizers. More...
class	TupleCountPartitionEvictionPolicy
	Partitions should be evicted when there are too many tuples. More...
class	Window
	Class that serves as a common base for tumbling and sliding windows. More...
class	AutoWindowDataAcquirer
	Class that provides an RAII handler for window data access. More...
class	WindowEvent
	Class that defines an interface for window events. More...
class	WindowPolicy
	Class that represents the eviction policies or the trigger policies of a window. More...

Typedefs
typedef std::tr1::shared_ptr < FilterExpression >	FilterExpressionPtr
typedef std::tr1::shared_ptr < SubscriptionExpression >	SubscriptionExpressionPtr
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
typedef float	float32
typedef double	float64
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
typedef std::string	RString
	Class that represents an rstring primitive type, based on std::string.
typedef std::tr1::shared_ptr < ControlPlaneConnection >	ControlPlaneConnectionPtr
typedef std::tr1::shared_ptr < ControlPlaneConnector >	ControlPlaneConnectorPtr

Functions
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, 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, 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::tr1::unordered_map< K, V > &value)
template<class K , class V >
SPL::ByteBuffer< Checkpoint > &	operator>> (SPL::ByteBuffer< Checkpoint > &ckpt, std::tr1::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, 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::tr1::unordered_map< K, V > &map)
template<class S , class K , class V >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::tr1::unordered_map< K, V > &map)
template<class S , class T >
ByteBuffer< S > &	operator<< (ByteBuffer< S > &sbuf, const std::tr1::unordered_set< T > &set)
template<class S , class T >
ByteBuffer< S > &	operator>> (ByteBuffer< S > &sbuf, std::tr1::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, 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::tr1::unordered_map< K, V > &map)
template<class K , class V >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::tr1::unordered_map< K, V > &map)
template<class T >
NativeByteBuffer &	operator<< (NativeByteBuffer &sbuf, const std::tr1::unordered_set< T > &set)
template<class T >
NativeByteBuffer &	operator>> (NativeByteBuffer &sbuf, std::tr1::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, 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::tr1::unordered_map< K, V > &map)
template<class K , class V >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::tr1::unordered_map< K, V > &map)
template<class T >
NetworkByteBuffer &	operator<< (NetworkByteBuffer &sbuf, const std::tr1::unordered_set< T > &set)
template<class T >
NetworkByteBuffer &	operator>> (NetworkByteBuffer &sbuf, std::tr1::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)
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)
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)
std::ostream &	operator<< (std::ostream &ostr, const uint8 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 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)
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)
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

typedef std::tr1::shared_ptr<ControlPlaneConnection> SPL::ControlPlaneConnectionPtr

Defines a shared pointer to a ControlPlaneConnection instance.

typedef std::tr1::shared_ptr<ControlPlaneConnector> SPL::ControlPlaneConnectorPtr

Defines a shared pointer to a ControlPlaneConnection instance.

typedef std::tr1::shared_ptr<FilterExpression> SPL::FilterExpressionPtr

typedef std::tr1::shared_ptr<SubscriptionExpression> SPL::SubscriptionExpressionPtr

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

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

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

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

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

typedef float SPL::float32

typedef double SPL::float64

typedef _<...> SPL::boolean

typedef _<...> SPL::int8

typedef _<...> SPL::uint8

typedef int16_t SPL::int16

typedef int32_t SPL::int32

typedef int64_t SPL::int64

typedef uint16_t SPL::uint16

typedef uint32_t SPL::uint32

typedef uint64_t SPL::uint64

typedef std::string SPL::RString

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
                    

---

Function Documentation

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.

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

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

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

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

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

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

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

inline

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

inline

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class K , class V >

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

inline

Add/serialize an std::tr1::unordered_map to the Checkpoint

Parameters:

ckpt	the ByteBuffer<Checkpoint> instance
value	an std::tr1::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

template<class K , class V >

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

inline

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

Parameters:

ckpt	the ByteBuffer<Checkpoint> instance
value	return the std::tr1::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

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S >

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

inline

template<class S , class T >

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

inline

template<class S , class T >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class T >

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

inline

template<class S , class T >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class K , class V >

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class S , class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class S , class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

template<class T , int32_t size>

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

inline

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

inline

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

inline

template<class S >

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

inline

template<class S >

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

inline

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

inline

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

inline

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

inline

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

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

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

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

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , class V , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class S , class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class S , class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class K , int32_t msize>

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

inline

template<class S >

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

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

inline

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

inline

template<int32_t size>

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

inline

template<int32_t size>

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

inline

template<int32_t size>

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

inline

template<int32_t size>

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

inline

template<class S , int32_t size>

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

inline

template<int32_t size>

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

inline

template<int32_t size>

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

inline

template<class S , int32_t size>

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

inline

template<int32_t size>

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

inline

template<int32_t size>

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

inline

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

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class Buffer , class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class S , class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class S , class T >

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

inline

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

inline

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

inline

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

inline

template<class BufferType >

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

inline

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

inline

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

inline

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

inline

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

inline

template<class BufferType >

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

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

inline

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

inline

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

inline

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

inline

template<class BufferType >

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

inline

template<class BufferType >

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

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

inline

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

inline

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

inline

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

inline

template<class BufferType >

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

inline

template<class BufferType >

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

template<>

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class S >

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

inline

template<class S >

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

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

inline

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

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class S , class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class S , class T >

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

inline

template<class T >

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

inline

template<class T >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class S , class K , class V >

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

inline

template<class S , class K , class V >

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

inline

template<class K , class V >

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

inline

template<class K , class V >

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

inline

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

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

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

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

template<class K , class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class T >

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

inline

template<class T , int32_t N>

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

inline

template<class K , class T >

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

inline

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

template<class K , class T >

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

inline

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

template<class K >

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

inline

template<class K >

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

inline

template<class K >

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

inline

template<class K >

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

inline

template<class K >

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

inline

template<class K >

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

inline

template<class S , class K >

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

inline

template<class S , class K >

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

inline

template<class K >

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

inline

template<class K >

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

inline

rstring SPL::operator+ ( rstring const &  lhs, rstring const &  rhs  )

inline

rstring SPL::operator+ ( rstring const &  lhs, char  rhs  )

inline

rstring SPL::operator+ ( rstring const &  lhs, RString const &  rhs  )

inline

rstring SPL::operator+ ( RString const &  lhs, rstring const &  rhs  )

inline

rstring SPL::operator+ ( rstring const &  lhs, char const *  rhs  )

inline

rstring SPL::operator+ ( char const *  lhs, rstring const &  rhs  )

inline

ustring SPL::operator+	(	ustring const &	lhs,
		ustring const &	rhs
	)

ustring SPL::operator+ ( ustring const &  lhs, rstring const &  rhs  )

inline

ustring SPL::operator+ ( rstring const &  lhs, ustring const &  rhs  )

inline

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

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

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

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

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

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

VirtualByteBuffer& SPL::operator<< ( VirtualByteBuffer &  sbuf, rstring const &  val  )

inline

VirtualByteBuffer& SPL::operator>> ( VirtualByteBuffer &  sbuf, rstring &  val  )

inline

template<class S >

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

inline

template<class S >

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

void SPL::deserializeWithNanAndInfs ( std::istream &  istr, Tuple &  x, bool  withSuffix = false  )

inline

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

inline

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

inline

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

inline

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

inline

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

inline

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

inline

template<class T >

size_t SPL::getSerializedSize

(

T const &

x

)

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

template<class S >

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

inline

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

inline

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

inline

std::ostream& SPL::operator<< ( std::ostream &  ostr, const FormattableMessage &  msg  )

inline