fix whitespace problems

git-svn-id: svn://svn.code.sf.net/p/cryptopp/code/trunk/c5@31 57ff6487-cd31-0410-9ec3-f628ee90f5f0

1 files changed, 250 insertions, 250 deletions

diff --git a/filters.h b/filters.h
index 08216c4..1b8965b 100644
--- a/filters.h
+++ b/filters.h
@@ -1,5 +1,5 @@
-#ifndef	CRYPTOPP_FILTERS_H
-#define	CRYPTOPP_FILTERS_H
+#ifndef CRYPTOPP_FILTERS_H
+#define CRYPTOPP_FILTERS_H
 
 #include "simple.h"
 #include "secblock.h"
@@ -10,7 +10,7 @@
 
 NAMESPACE_BEGIN(CryptoPP)
 
-///	provides an	implementation of BufferedTransformation's attachment interface
+/// provides an implementation of BufferedTransformation's attachment interface
 class Filter : public BufferedTransformation, public NotCopyable
 {
 public:
@@ -19,48 +19,48 @@ public:
 	bool Attachable() {return true;}
 	BufferedTransformation *AttachedTransformation();
 	const BufferedTransformation *AttachedTransformation() const;
-	void Detach(BufferedTransformation *newAttachment =	NULL);
+	void Detach(BufferedTransformation *newAttachment = NULL);
 
-	unsigned int TransferTo2(BufferedTransformation	&target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL,	bool blocking=true);
-	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long	&begin,	unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
+	unsigned int TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true);
+	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
 
 	void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1);
-	bool Flush(bool	hardFlush, int propagation=-1, bool	blocking=true);
+	bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);
 	bool MessageSeriesEnd(int propagation=-1, bool blocking=true);
 
 protected:
-	virtual	void NotifyAttachmentChange() {}
-	virtual	BufferedTransformation * NewDefaultAttachment()	const;
-	void Insert(Filter *nextFilter);	// insert filter after this	one
+	virtual void NotifyAttachmentChange() {}
+	virtual BufferedTransformation * NewDefaultAttachment() const;
+	void Insert(Filter *nextFilter);	// insert filter after this one
 
-	virtual	bool ShouldPropagateMessageEnd() const {return true;}
-	virtual	bool ShouldPropagateMessageSeriesEnd() const {return true;}
+	virtual bool ShouldPropagateMessageEnd() const {return true;}
+	virtual bool ShouldPropagateMessageSeriesEnd() const {return true;}
 
-	void PropagateInitialize(const NameValuePairs &parameters, int propagation,	const std::string &channel=NULL_CHANNEL);
+	void PropagateInitialize(const NameValuePairs &parameters, int propagation, const std::string &channel=NULL_CHANNEL);
 
-	unsigned int Output(int	outputSite,	const byte *inString, unsigned int length, int messageEnd, bool	blocking, const	std::string	&channel=NULL_CHANNEL);
-	bool OutputMessageEnd(int outputSite, int propagation, bool	blocking, const	std::string	&channel=NULL_CHANNEL);
+	unsigned int Output(int outputSite, const byte *inString, unsigned int length, int messageEnd, bool blocking, const std::string &channel=NULL_CHANNEL);
+	bool OutputMessageEnd(int outputSite, int propagation, bool blocking, const std::string &channel=NULL_CHANNEL);
 	bool OutputFlush(int outputSite, bool hardFlush, int propagation, bool blocking, const std::string &channel=NULL_CHANNEL);
-	bool OutputMessageSeriesEnd(int	outputSite,	int	propagation, bool blocking,	const std::string &channel=NULL_CHANNEL);
+	bool OutputMessageSeriesEnd(int outputSite, int propagation, bool blocking, const std::string &channel=NULL_CHANNEL);
 
 private:
 	member_ptr<BufferedTransformation> m_attachment;
 	
 protected:
 	unsigned int m_inputPosition;
-	int	m_continueAt;
+	int m_continueAt;
 };
 
 struct FilterPutSpaceHelper
 {
-	// desiredSize is how much to ask target, bufferSize is	how	much to	allocate in	m_tempSpace
-	byte *HelpCreatePutSpace(BufferedTransformation	&target, const std::string &channel, unsigned int minSize, unsigned	int	desiredSize, unsigned int &bufferSize)
+	// desiredSize is how much to ask target, bufferSize is how much to allocate in m_tempSpace
+	byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, unsigned int minSize, unsigned int desiredSize, unsigned int &bufferSize)
 	{
-		assert(desiredSize >= minSize && bufferSize	>= minSize);
+		assert(desiredSize >= minSize && bufferSize >= minSize);
 		if (m_tempSpace.size() < minSize)
 		{
 			byte *result = target.ChannelCreatePutSpace(channel, desiredSize);
-			if (desiredSize	>= minSize)
+			if (desiredSize >= minSize)
 			{
 				bufferSize = desiredSize;
 				return result;
@@ -71,30 +71,30 @@ struct FilterPutSpaceHelper
 		bufferSize = m_tempSpace.size();
 		return m_tempSpace.begin();
 	}
-	byte *HelpCreatePutSpace(BufferedTransformation	&target, const std::string &channel, unsigned int minSize)
-		{return	HelpCreatePutSpace(target, channel,	minSize, minSize, minSize);}
-	byte *HelpCreatePutSpace(BufferedTransformation	&target, const std::string &channel, unsigned int minSize, unsigned	int	bufferSize)
-		{return	HelpCreatePutSpace(target, channel,	minSize, minSize, bufferSize);}
+	byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, unsigned int minSize)
+		{return HelpCreatePutSpace(target, channel, minSize, minSize, minSize);}
+	byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, unsigned int minSize, unsigned int bufferSize)
+		{return HelpCreatePutSpace(target, channel, minSize, minSize, bufferSize);}
 	SecByteBlock m_tempSpace;
 };
 
-//!	measure	how	many byte and messages pass	through, also serves as	valve
-class MeterFilter :	public Bufferless<Filter>
+//! measure how many byte and messages pass through, also serves as valve
+class MeterFilter : public Bufferless<Filter>
 {
 public:
 	MeterFilter(BufferedTransformation *attachment=NULL, bool transparent=true)
 		: Bufferless<Filter>(attachment), m_transparent(transparent) {ResetMeter();}
 
 	void SetTransparent(bool transparent) {m_transparent = transparent;}
-	void ResetMeter() {m_currentMessageBytes = m_totalBytes	= m_currentSeriesMessages =	m_totalMessages	= m_totalMessageSeries = 0;}
+	void ResetMeter() {m_currentMessageBytes = m_totalBytes = m_currentSeriesMessages = m_totalMessages = m_totalMessageSeries = 0;}
 
 	unsigned long GetCurrentMessageBytes() const {return m_currentMessageBytes;}
 	unsigned long GetTotalBytes() {return m_totalBytes;}
-	unsigned int GetCurrentSeriesMessages()	{return	m_currentSeriesMessages;}
-	unsigned int GetTotalMessages()	{return	m_totalMessages;}
+	unsigned int GetCurrentSeriesMessages() {return m_currentSeriesMessages;}
+	unsigned int GetTotalMessages() {return m_totalMessages;}
 	unsigned int GetTotalMessageSeries() {return m_totalMessageSeries;}
 
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking);
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
 	bool IsolatedMessageSeriesEnd(bool blocking);
 
 private:
@@ -106,93 +106,93 @@ private:
 	unsigned int m_currentSeriesMessages, m_totalMessages, m_totalMessageSeries;
 };
 
-//!	.
-class TransparentFilter	: public MeterFilter
+//! .
+class TransparentFilter : public MeterFilter
 {
 public:
 	TransparentFilter(BufferedTransformation *attachment=NULL) : MeterFilter(attachment, true) {}
 };
 
-//!	.
-class OpaqueFilter : public	MeterFilter
+//! .
+class OpaqueFilter : public MeterFilter
 {
 public:
-	OpaqueFilter(BufferedTransformation	*attachment=NULL) :	MeterFilter(attachment,	false) {}
+	OpaqueFilter(BufferedTransformation *attachment=NULL) : MeterFilter(attachment, false) {}
 };
 
-/*!	FilterWithBufferedInput	divides	up the input stream	into
-	a first	block, a number	of middle blocks, and a	last block.
-	First and last blocks are optional,	and	middle blocks may
-	be a stream	instead	(i.e. blockSize	== 1).
+/*! FilterWithBufferedInput divides up the input stream into
+	a first block, a number of middle blocks, and a last block.
+	First and last blocks are optional, and middle blocks may
+	be a stream instead (i.e. blockSize == 1).
 */
-class FilterWithBufferedInput :	public Filter
+class FilterWithBufferedInput : public Filter
 {
 public:
 	FilterWithBufferedInput(BufferedTransformation *attachment);
-	//!	firstSize and lastSize may be 0, blockSize must	be at least	1
-	FilterWithBufferedInput(unsigned int firstSize,	unsigned int blockSize,	unsigned int lastSize, BufferedTransformation *attachment);
+	//! firstSize and lastSize may be 0, blockSize must be at least 1
+	FilterWithBufferedInput(unsigned int firstSize, unsigned int blockSize, unsigned int lastSize, BufferedTransformation *attachment);
 
 	void IsolatedInitialize(const NameValuePairs &parameters);
-	unsigned int Put2(const	byte *inString,	unsigned int length, int messageEnd, bool blocking)
+	unsigned int Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking)
 	{
-		return PutMaybeModifiable(const_cast<byte *>(inString),	length,	messageEnd,	blocking, false);
+		return PutMaybeModifiable(const_cast<byte *>(inString), length, messageEnd, blocking, false);
 	}
-	unsigned int PutModifiable2(byte *inString,	unsigned int length, int messageEnd, bool blocking)
+	unsigned int PutModifiable2(byte *inString, unsigned int length, int messageEnd, bool blocking)
 	{
-		return PutMaybeModifiable(inString,	length,	messageEnd,	blocking, true);
+		return PutMaybeModifiable(inString, length, messageEnd, blocking, true);
 	}
-	/*!	calls ForceNextPut() if	hardFlush is true */
-	bool IsolatedFlush(bool	hardFlush, bool	blocking);
+	/*! calls ForceNextPut() if hardFlush is true */
+	bool IsolatedFlush(bool hardFlush, bool blocking);
 
-	/*!	The	input buffer may contain more than blockSize bytes if lastSize != 0.
-		ForceNextPut() forces a	call to	NextPut() if this is the case.
+	/*! The input buffer may contain more than blockSize bytes if lastSize != 0.
+		ForceNextPut() forces a call to NextPut() if this is the case.
 	*/
 	void ForceNextPut();
 
 protected:
 	bool DidFirstPut() {return m_firstInputDone;}
 
-	virtual	void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned	int	&blockSize,	unsigned int &lastSize)
+	virtual void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned int &blockSize, unsigned int &lastSize)
 		{InitializeDerived(parameters);}
-	virtual	void InitializeDerived(const NameValuePairs	&parameters) {}
-	// FirstPut() is called	if (firstSize != 0 and totalLength >= firstSize)
-	// or (firstSize ==	0 and (totalLength > 0 or a	MessageEnd() is	received))
-	virtual	void FirstPut(const	byte *inString)	=0;
-	// NextPut() is	called if totalLength >= firstSize+blockSize+lastSize
-	virtual	void NextPutSingle(const byte *inString) {assert(false);}
-	// Same	as NextPut() except	length can be a	multiple of	blockSize
-	// Either NextPut()	or NextPutMultiple() must be overriden
-	virtual	void NextPutMultiple(const byte	*inString, unsigned	int	length);
-	// Same	as NextPutMultiple(), but inString can be modified
-	virtual	void NextPutModifiable(byte	*inString, unsigned	int	length)
+	virtual void InitializeDerived(const NameValuePairs &parameters) {}
+	// FirstPut() is called if (firstSize != 0 and totalLength >= firstSize)
+	// or (firstSize == 0 and (totalLength > 0 or a MessageEnd() is received))
+	virtual void FirstPut(const byte *inString) =0;
+	// NextPut() is called if totalLength >= firstSize+blockSize+lastSize
+	virtual void NextPutSingle(const byte *inString) {assert(false);}
+	// Same as NextPut() except length can be a multiple of blockSize
+	// Either NextPut() or NextPutMultiple() must be overriden
+	virtual void NextPutMultiple(const byte *inString, unsigned int length);
+	// Same as NextPutMultiple(), but inString can be modified
+	virtual void NextPutModifiable(byte *inString, unsigned int length)
 		{NextPutMultiple(inString, length);}
-	// LastPut() is	always called
-	// if totalLength <	firstSize then length == totalLength
-	// else	if totalLength <= firstSize+lastSize then length ==	totalLength-firstSize
-	// else	lastSize <=	length < lastSize+blockSize
-	virtual	void LastPut(const byte	*inString, unsigned	int	length)	=0;
-	virtual	void FlushDerived()	{}
+	// LastPut() is always called
+	// if totalLength < firstSize then length == totalLength
+	// else if totalLength <= firstSize+lastSize then length == totalLength-firstSize
+	// else lastSize <= length < lastSize+blockSize
+	virtual void LastPut(const byte *inString, unsigned int length) =0;
+	virtual void FlushDerived() {}
 
 private:
 	unsigned int PutMaybeModifiable(byte *begin, unsigned int length, int messageEnd, bool blocking, bool modifiable);
-	void NextPutMaybeModifiable(byte *inString,	unsigned int length, bool modifiable)
+	void NextPutMaybeModifiable(byte *inString, unsigned int length, bool modifiable)
 	{
-		if (modifiable)	NextPutModifiable(inString,	length);
+		if (modifiable) NextPutModifiable(inString, length);
 		else NextPutMultiple(inString, length);
 	}
 
-	// This	function should	no longer be used, put this	here to	cause a	compiler error
-	// if someone tries	to override	NextPut().
-	virtual	int	NextPut(const byte *inString, unsigned int length) {assert(false); return 0;}
+	// This function should no longer be used, put this here to cause a compiler error
+	// if someone tries to override NextPut().
+	virtual int NextPut(const byte *inString, unsigned int length) {assert(false); return 0;}
 
 	class BlockQueue
 	{
 	public:
-		void ResetQueue(unsigned int blockSize,	unsigned int maxBlocks);
+		void ResetQueue(unsigned int blockSize, unsigned int maxBlocks);
 		byte *GetBlock();
 		byte *GetContigousBlocks(unsigned int &numberOfBytes);
 		unsigned int GetAll(byte *outString);
-		void Put(const byte	*inString, unsigned	int	length);
+		void Put(const byte *inString, unsigned int length);
 		unsigned int CurrentSize() const {return m_size;}
 		unsigned int MaxSize() const {return m_buffer.size();}
 
@@ -207,49 +207,49 @@ private:
 	BlockQueue m_queue;
 };
 
-//!	.
-class FilterWithInputQueue : public	Filter
+//! .
+class FilterWithInputQueue : public Filter
 {
 public:
-	FilterWithInputQueue(BufferedTransformation	*attachment) : Filter(attachment) {}
-	unsigned int Put2(const	byte *inString,	unsigned int length, int messageEnd, bool blocking)
+	FilterWithInputQueue(BufferedTransformation *attachment) : Filter(attachment) {}
+	unsigned int Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking)
 	{
 		if (!blocking)
 			throw BlockingInputOnly("FilterWithInputQueue");
 		
-		m_inQueue.Put(inString,	length);
+		m_inQueue.Put(inString, length);
 		if (messageEnd)
 		{
 			IsolatedMessageEnd(blocking);
-			Output(0, NULL,	0, messageEnd, blocking);
+			Output(0, NULL, 0, messageEnd, blocking);
 		}
 		return 0;
 	}
 
 protected:
-	virtual	bool IsolatedMessageEnd(bool blocking) =0;
+	virtual bool IsolatedMessageEnd(bool blocking) =0;
 	void IsolatedInitialize(const NameValuePairs &parameters) {m_inQueue.Clear();}
 
 	ByteQueue m_inQueue;
 };
 
-//!	Filter Wrapper for StreamTransformation
+//! Filter Wrapper for StreamTransformation
 class StreamTransformationFilter : public FilterWithBufferedInput, private FilterPutSpaceHelper
 {
 public:
-	enum BlockPaddingScheme	{NO_PADDING, ZEROS_PADDING,	PKCS_PADDING, ONE_AND_ZEROS_PADDING, DEFAULT_PADDING};
-	/*!	DEFAULT_PADDING	means PKCS_PADDING if c.MandatoryBlockSize() > 1 &&	c.MinLastBlockSize() ==	0 (e.g.	ECB	or CBC mode),
-		otherwise NO_PADDING (OFB, CFB,	CTR, CBC-CTS modes)	*/
-	StreamTransformationFilter(StreamTransformation	&c,	BufferedTransformation *attachment = NULL, BlockPaddingScheme padding =	DEFAULT_PADDING);
-
-	void FirstPut(const	byte *inString);
-	void NextPutMultiple(const byte	*inString, unsigned	int	length);
-	void NextPutModifiable(byte	*inString, unsigned	int	length);
-	void LastPut(const byte	*inString, unsigned	int	length);
+	enum BlockPaddingScheme {NO_PADDING, ZEROS_PADDING, PKCS_PADDING, ONE_AND_ZEROS_PADDING, DEFAULT_PADDING};
+	/*! DEFAULT_PADDING means PKCS_PADDING if c.MandatoryBlockSize() > 1 && c.MinLastBlockSize() == 0 (e.g. ECB or CBC mode),
+		otherwise NO_PADDING (OFB, CFB, CTR, CBC-CTS modes) */
+	StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment = NULL, BlockPaddingScheme padding = DEFAULT_PADDING);
+
+	void FirstPut(const byte *inString);
+	void NextPutMultiple(const byte *inString, unsigned int length);
+	void NextPutModifiable(byte *inString, unsigned int length);
+	void LastPut(const byte *inString, unsigned int length);
 //	byte * CreatePutSpace(unsigned int &size);
 
 protected:
-	static unsigned	int	LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding);
+	static unsigned int LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding);
 
 	StreamTransformation &m_cipher;
 	BlockPaddingScheme m_padding;
@@ -257,18 +257,18 @@ protected:
 };
 
 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
-typedef	StreamTransformationFilter StreamCipherFilter;
+typedef StreamTransformationFilter StreamCipherFilter;
 #endif
 
-//!	Filter Wrapper for HashTransformation
+//! Filter Wrapper for HashTransformation
 class HashFilter : public Bufferless<Filter>, private FilterPutSpaceHelper
 {
 public:
-	HashFilter(HashTransformation &hm, BufferedTransformation *attachment =	NULL, bool putMessage=false)
-		: Bufferless<Filter>(attachment), m_hashModule(hm),	m_putMessage(putMessage) {}
+	HashFilter(HashTransformation &hm, BufferedTransformation *attachment = NULL, bool putMessage=false)
+		: Bufferless<Filter>(attachment), m_hashModule(hm), m_putMessage(putMessage) {}
 
 	void IsolatedInitialize(const NameValuePairs &parameters);
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking);
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
 
 	byte * CreatePutSpace(unsigned int &size) {return m_hashModule.CreateUpdateSpace(size);}
 
@@ -278,7 +278,7 @@ private:
 	byte *m_space;
 };
 
-//!	Filter Wrapper for HashTransformation
+//! Filter Wrapper for HashTransformation
 class HashVerificationFilter : public FilterWithBufferedInput
 {
 public:
@@ -286,23 +286,23 @@ public:
 	{
 	public:
 		HashVerificationFailed()
-			: Exception(DATA_INTEGRITY_CHECK_FAILED, "HashVerifier:	message	hash not valid") {}
+			: Exception(DATA_INTEGRITY_CHECK_FAILED, "HashVerifier: message hash not valid") {}
 	};
 
-	enum Flags {HASH_AT_BEGIN=1, PUT_MESSAGE=2,	PUT_HASH=4,	PUT_RESULT=8, THROW_EXCEPTION=16, DEFAULT_FLAGS	= HASH_AT_BEGIN	| PUT_RESULT};
-	HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment =	NULL, word32 flags = DEFAULT_FLAGS);
+	enum Flags {HASH_AT_BEGIN=1, PUT_MESSAGE=2, PUT_HASH=4, PUT_RESULT=8, THROW_EXCEPTION=16, DEFAULT_FLAGS = HASH_AT_BEGIN | PUT_RESULT};
+	HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment = NULL, word32 flags = DEFAULT_FLAGS);
 
 	bool GetLastResult() const {return m_verified;}
 
 protected:
-	void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned	int	&blockSize,	unsigned int &lastSize);
-	void FirstPut(const	byte *inString);
-	void NextPutMultiple(const byte	*inString, unsigned	int	length);
-	void LastPut(const byte	*inString, unsigned	int	length);
+	void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned int &blockSize, unsigned int &lastSize);
+	void FirstPut(const byte *inString);
+	void NextPutMultiple(const byte *inString, unsigned int length);
+	void LastPut(const byte *inString, unsigned int length);
 
 private:
-	static inline unsigned int FirstSize(word32	flags, HashTransformation &hm) {return flags & HASH_AT_BEGIN ? hm.DigestSize() : 0;}
-	static inline unsigned int LastSize(word32 flags, HashTransformation &hm) {return flags	& HASH_AT_BEGIN	? 0	: hm.DigestSize();}
+	static inline unsigned int FirstSize(word32 flags, HashTransformation &hm) {return flags & HASH_AT_BEGIN ? hm.DigestSize() : 0;}
+	static inline unsigned int LastSize(word32 flags, HashTransformation &hm) {return flags & HASH_AT_BEGIN ? 0 : hm.DigestSize();}
 
 	HashTransformation &m_hashModule;
 	word32 m_flags;
@@ -310,47 +310,47 @@ private:
 	bool m_verified;
 };
 
-typedef	HashVerificationFilter HashVerifier;	// for backwards compatibility
+typedef HashVerificationFilter HashVerifier;	// for backwards compatibility
 
-//!	Filter Wrapper for PK_Signer
-class SignerFilter : public	Unflushable<Filter>
+//! Filter Wrapper for PK_Signer
+class SignerFilter : public Unflushable<Filter>
 {
 public:
 	SignerFilter(RandomNumberGenerator &rng, const PK_Signer &signer, BufferedTransformation *attachment = NULL, bool putMessage=false)
 		: Unflushable<Filter>(attachment), m_rng(rng), m_signer(signer), m_messageAccumulator(signer.NewSignatureAccumulator()), m_putMessage(putMessage) {}
 
 	void IsolatedInitialize(const NameValuePairs &parameters);
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking);
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
 
 private:
 	RandomNumberGenerator &m_rng;
-	const PK_Signer	&m_signer;
+	const PK_Signer &m_signer;
 	member_ptr<HashTransformation> m_messageAccumulator;
 	bool m_putMessage;
 	SecByteBlock m_buf;
 };
 
-//!	Filter Wrapper for PK_Verifier
-class SignatureVerificationFilter :	public FilterWithBufferedInput
+//! Filter Wrapper for PK_Verifier
+class SignatureVerificationFilter : public FilterWithBufferedInput
 {
 public:
-	class SignatureVerificationFailed :	public Exception
+	class SignatureVerificationFailed : public Exception
 	{
 	public:
 		SignatureVerificationFailed()
-			: Exception(DATA_INTEGRITY_CHECK_FAILED, "VerifierFilter: digital signature	not	valid")	{}
+			: Exception(DATA_INTEGRITY_CHECK_FAILED, "VerifierFilter: digital signature not valid") {}
 	};
 
-	enum Flags {SIGNATURE_AT_BEGIN=1, PUT_MESSAGE=2, PUT_SIGNATURE=4, PUT_RESULT=8,	THROW_EXCEPTION=16,	DEFAULT_FLAGS =	SIGNATURE_AT_BEGIN | PUT_RESULT};
-	SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation	*attachment	= NULL,	word32 flags = DEFAULT_FLAGS);
+	enum Flags {SIGNATURE_AT_BEGIN=1, PUT_MESSAGE=2, PUT_SIGNATURE=4, PUT_RESULT=8, THROW_EXCEPTION=16, DEFAULT_FLAGS = SIGNATURE_AT_BEGIN | PUT_RESULT};
+	SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment = NULL, word32 flags = DEFAULT_FLAGS);
 
 	bool GetLastResult() const {return m_verified;}
 
 protected:
-	void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned	int	&blockSize,	unsigned int &lastSize);
-	void FirstPut(const	byte *inString);
-	void NextPutMultiple(const byte	*inString, unsigned	int	length);
-	void LastPut(const byte	*inString, unsigned	int	length);
+	void InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned int &blockSize, unsigned int &lastSize);
+	void FirstPut(const byte *inString);
+	void NextPutMultiple(const byte *inString, unsigned int length);
+	void LastPut(const byte *inString, unsigned int length);
 
 private:
 	const PK_Verifier &m_verifier;
@@ -360,108 +360,108 @@ private:
 	bool m_verified;
 };
 
-typedef	SignatureVerificationFilter	VerifierFilter;	// for backwards compatibility
+typedef SignatureVerificationFilter VerifierFilter; // for backwards compatibility
 
-//!	Redirect input to another BufferedTransformation without owning	it
+//! Redirect input to another BufferedTransformation without owning it
 class Redirector : public CustomSignalPropagation<Sink>
 {
 public:
 	Redirector() : m_target(NULL), m_passSignal(true) {}
-	Redirector(BufferedTransformation &target, bool	passSignal=true) : m_target(&target), m_passSignal(passSignal) {}
+	Redirector(BufferedTransformation &target, bool passSignal=true) : m_target(&target), m_passSignal(passSignal) {}
 
-	void Redirect(BufferedTransformation &target) {m_target	= &target;}
+	void Redirect(BufferedTransformation &target) {m_target = &target;}
 	void StopRedirection() {m_target = NULL;}
 	bool GetPassSignal() const {return m_passSignal;}
-	void SetPassSignal(bool	passSignal)	{m_passSignal =	passSignal;}
+	void SetPassSignal(bool passSignal) {m_passSignal = passSignal;}
 
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking)
-		{return	m_target ? m_target->Put2(begin, length, m_passSignal ?	messageEnd : 0,	blocking) :	0;}
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_target ? m_target->Put2(begin, length, m_passSignal ? messageEnd : 0, blocking) : 0;}
 	void Initialize(const NameValuePairs &parameters, int propagation)
 		{ChannelInitialize(NULL_CHANNEL, parameters, propagation);}
-	bool Flush(bool	hardFlush, int propagation=-1, bool	blocking=true)
-		{return	m_target &&	m_passSignal ? m_target->Flush(hardFlush, propagation, blocking) : false;}
+	bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
+		{return m_target && m_passSignal ? m_target->Flush(hardFlush, propagation, blocking) : false;}
 	bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
-		{return	m_target &&	m_passSignal ? m_target->MessageSeriesEnd(propagation, blocking) : false;}
-
-	void ChannelInitialize(const std::string &channel, const NameValuePairs	&parameters=g_nullNameValuePairs, int propagation=-1);
-	unsigned int ChannelPut2(const std::string &channel, const byte	*begin,	unsigned int length, int messageEnd, bool blocking)
-		{return	m_target ? m_target->ChannelPut2(channel, begin, length, m_passSignal ?	messageEnd : 0,	blocking) :	0;}
-	unsigned int ChannelPutModifiable2(const std::string &channel, byte	*begin,	unsigned int length, int messageEnd, bool blocking)
-		{return	m_target ? m_target->ChannelPutModifiable2(channel,	begin, length, m_passSignal	? messageEnd : 0, blocking)	: 0;}
-	bool ChannelFlush(const	std::string	&channel, bool completeFlush, int propagation=-1, bool blocking=true)
-		{return	m_target &&	m_passSignal ? m_target->ChannelFlush(channel, completeFlush, propagation, blocking) : false;}
+		{return m_target && m_passSignal ? m_target->MessageSeriesEnd(propagation, blocking) : false;}
+
+	void ChannelInitialize(const std::string &channel, const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1);
+	unsigned int ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_target ? m_target->ChannelPut2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking) : 0;}
+	unsigned int ChannelPutModifiable2(const std::string &channel, byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_target ? m_target->ChannelPutModifiable2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking) : 0;}
+	bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true)
+		{return m_target && m_passSignal ? m_target->ChannelFlush(channel, completeFlush, propagation, blocking) : false;}
 	bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true)
-		{return	m_target &&	m_passSignal ? m_target->ChannelMessageSeriesEnd(channel, propagation, blocking) : false;}
+		{return m_target && m_passSignal ? m_target->ChannelMessageSeriesEnd(channel, propagation, blocking) : false;}
 
 private:
 	BufferedTransformation *m_target;
 	bool m_passSignal;
 };
 
-// Used	By ProxyFilter
-class OutputProxy :	public CustomSignalPropagation<Sink>
+// Used By ProxyFilter
+class OutputProxy : public CustomSignalPropagation<Sink>
 {
 public:
-	OutputProxy(BufferedTransformation &owner, bool	passSignal)	: m_owner(owner), m_passSignal(passSignal) {}
+	OutputProxy(BufferedTransformation &owner, bool passSignal) : m_owner(owner), m_passSignal(passSignal) {}
 
 	bool GetPassSignal() const {return m_passSignal;}
-	void SetPassSignal(bool	passSignal)	{m_passSignal =	passSignal;}
+	void SetPassSignal(bool passSignal) {m_passSignal = passSignal;}
 
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking)
-		{return	m_owner.AttachedTransformation()->Put2(begin, length, m_passSignal ? messageEnd	: 0, blocking);}
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_owner.AttachedTransformation()->Put2(begin, length, m_passSignal ? messageEnd : 0, blocking);}
 	unsigned int PutModifiable2(byte *begin, unsigned int length, int messageEnd, bool blocking)
-		{return	m_owner.AttachedTransformation()->PutModifiable2(begin,	length,	m_passSignal ? messageEnd :	0, blocking);}
+		{return m_owner.AttachedTransformation()->PutModifiable2(begin, length, m_passSignal ? messageEnd : 0, blocking);}
 	void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1)
-		{if	(m_passSignal) m_owner.AttachedTransformation()->Initialize(parameters,	propagation);}
-	bool Flush(bool	hardFlush, int propagation=-1, bool	blocking=true)
-		{return	m_passSignal ? m_owner.AttachedTransformation()->Flush(hardFlush, propagation, blocking) : false;}
+		{if (m_passSignal) m_owner.AttachedTransformation()->Initialize(parameters, propagation);}
+	bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
+		{return m_passSignal ? m_owner.AttachedTransformation()->Flush(hardFlush, propagation, blocking) : false;}
 	bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
-		{return	m_passSignal ? m_owner.AttachedTransformation()->MessageSeriesEnd(propagation, blocking) : false;}
-
-	unsigned int ChannelPut2(const std::string &channel, const byte	*begin,	unsigned int length, int messageEnd, bool blocking)
-		{return	m_owner.AttachedTransformation()->ChannelPut2(channel, begin, length, m_passSignal ? messageEnd	: 0, blocking);}
-	unsigned int ChannelPutModifiable2(const std::string &channel, byte	*begin,	unsigned int length, int messageEnd, bool blocking)
-		{return	m_owner.AttachedTransformation()->ChannelPutModifiable2(channel, begin,	length,	m_passSignal ? messageEnd :	0, blocking);}
-	void ChannelInitialize(const std::string &channel, const NameValuePairs	&parameters, int propagation=-1)
-		{if	(m_passSignal) m_owner.AttachedTransformation()->ChannelInitialize(channel,	parameters,	propagation);}
-	bool ChannelFlush(const	std::string	&channel, bool completeFlush, int propagation=-1, bool blocking=true)
-		{return	m_passSignal ? m_owner.AttachedTransformation()->ChannelFlush(channel, completeFlush, propagation, blocking) : false;}
+		{return m_passSignal ? m_owner.AttachedTransformation()->MessageSeriesEnd(propagation, blocking) : false;}
+
+	unsigned int ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_owner.AttachedTransformation()->ChannelPut2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking);}
+	unsigned int ChannelPutModifiable2(const std::string &channel, byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{return m_owner.AttachedTransformation()->ChannelPutModifiable2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking);}
+	void ChannelInitialize(const std::string &channel, const NameValuePairs &parameters, int propagation=-1)
+		{if (m_passSignal) m_owner.AttachedTransformation()->ChannelInitialize(channel, parameters, propagation);}
+	bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true)
+		{return m_passSignal ? m_owner.AttachedTransformation()->ChannelFlush(channel, completeFlush, propagation, blocking) : false;}
 	bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true)
-		{return	m_passSignal ? m_owner.AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation, blocking) : false;}
+		{return m_passSignal ? m_owner.AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation, blocking) : false;}
 
 private:
 	BufferedTransformation &m_owner;
 	bool m_passSignal;
 };
 
-//!	Base class for Filter classes that are proxies for a chain of other	filters.
-class ProxyFilter :	public FilterWithBufferedInput
+//! Base class for Filter classes that are proxies for a chain of other filters.
+class ProxyFilter : public FilterWithBufferedInput
 {
 public:
-	ProxyFilter(BufferedTransformation *filter,	unsigned int firstSize,	unsigned int lastSize, BufferedTransformation *attachment);
+	ProxyFilter(BufferedTransformation *filter, unsigned int firstSize, unsigned int lastSize, BufferedTransformation *attachment);
 
-	bool IsolatedFlush(bool	hardFlush, bool	blocking);
+	bool IsolatedFlush(bool hardFlush, bool blocking);
 
 	void SetFilter(Filter *filter);
-	void NextPutMultiple(const byte	*s,	unsigned int len);
+	void NextPutMultiple(const byte *s, unsigned int len);
 
 protected:
 	member_ptr<BufferedTransformation> m_filter;
 };
 
-//!	simple proxy filter	that doesn't modify	the	underlying filter's	input or output
-class SimpleProxyFilter	: public ProxyFilter
+//! simple proxy filter that doesn't modify the underlying filter's input or output
+class SimpleProxyFilter : public ProxyFilter
 {
 public:
 	SimpleProxyFilter(BufferedTransformation *filter, BufferedTransformation *attachment)
-		: ProxyFilter(filter, 0, 0,	attachment)	{}
+		: ProxyFilter(filter, 0, 0, attachment) {}
 
-	void FirstPut(const	byte *)	{}
-	void LastPut(const byte	*, unsigned	int) {m_filter->MessageEnd();}
+	void FirstPut(const byte *) {}
+	void LastPut(const byte *, unsigned int) {m_filter->MessageEnd();}
 };
 
-//!	proxy for the filter created by	PK_Encryptor::CreateEncryptionFilter
-/*!	This class is here just	to provide symmetry	with VerifierFilter. */
+//! proxy for the filter created by PK_Encryptor::CreateEncryptionFilter
+/*! This class is here just to provide symmetry with VerifierFilter. */
 class PK_EncryptorFilter : public SimpleProxyFilter
 {
 public:
@@ -469,31 +469,31 @@ public:
 		: SimpleProxyFilter(encryptor.CreateEncryptionFilter(rng), attachment) {}
 };
 
-//!	proxy for the filter created by	PK_Decryptor::CreateDecryptionFilter
-/*!	This class is here just	to provide symmetry	with SignerFilter. */
+//! proxy for the filter created by PK_Decryptor::CreateDecryptionFilter
+/*! This class is here just to provide symmetry with SignerFilter. */
 class PK_DecryptorFilter : public SimpleProxyFilter
 {
 public:
 	PK_DecryptorFilter(const PK_Decryptor &decryptor, BufferedTransformation *attachment = NULL)
-		: SimpleProxyFilter(decryptor.CreateDecryptionFilter(),	attachment)	{}
+		: SimpleProxyFilter(decryptor.CreateDecryptionFilter(), attachment) {}
 };
 
-//!	Append input to	a string object
-template <class	T>
+//! Append input to a string object
+template <class T>
 class StringSinkTemplate : public Bufferless<Sink>
 {
 public:
-	// VC60	workaround:	no T::char_type
-	typedef	typename T::traits_type::char_type char_type;
+	// VC60 workaround: no T::char_type
+	typedef typename T::traits_type::char_type char_type;
 
 	StringSinkTemplate(T &output)
-		: m_output(&output)	{assert(sizeof(output[0])==1);}
+		: m_output(&output) {assert(sizeof(output[0])==1);}
 
 	void IsolatedInitialize(const NameValuePairs &parameters)
-		{if	(!parameters.GetValue("OutputStringPointer", m_output))	throw InvalidArgument("StringSink: OutputStringPointer not specified");}
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking)
+		{if (!parameters.GetValue("OutputStringPointer", m_output)) throw InvalidArgument("StringSink: OutputStringPointer not specified");}
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
 	{
-		m_output->append((const	char_type *)begin, (const char_type	*)begin+length);
+		m_output->append((const char_type *)begin, (const char_type *)begin+length);
 		return 0;
 	}
 
@@ -501,22 +501,22 @@ private:
 	T *m_output;
 };
 
-//!	Append input to	an std::string
-typedef	StringSinkTemplate<std::string>	StringSink;
+//! Append input to an std::string
+typedef StringSinkTemplate<std::string> StringSink;
 
-//!	Copy input to a	memory buffer
-class ArraySink	: public Bufferless<Sink>
+//! Copy input to a memory buffer
+class ArraySink : public Bufferless<Sink>
 {
 public:
-	ArraySink(const	NameValuePairs &parameters = g_nullNameValuePairs) {IsolatedInitialize(parameters);}
-	ArraySink(byte *buf, unsigned int size)	: m_buf(buf), m_size(size),	m_total(0) {}
+	ArraySink(const NameValuePairs &parameters = g_nullNameValuePairs) {IsolatedInitialize(parameters);}
+	ArraySink(byte *buf, unsigned int size) : m_buf(buf), m_size(size), m_total(0) {}
 
-	unsigned int AvailableSize() {return m_size	- STDMIN(m_total, (unsigned	long)m_size);}
+	unsigned int AvailableSize() {return m_size - STDMIN(m_total, (unsigned long)m_size);}
 	unsigned long TotalPutLength() {return m_total;}
 
 	void IsolatedInitialize(const NameValuePairs &parameters);
 	byte * CreatePutSpace(unsigned int &size);
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking);
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
 
 protected:
 	byte *m_buf;
@@ -524,30 +524,30 @@ protected:
 	unsigned long m_total;
 };
 
-//!	Xor	input to a memory buffer
-class ArrayXorSink : public	ArraySink
+//! Xor input to a memory buffer
+class ArrayXorSink : public ArraySink
 {
 public:
-	ArrayXorSink(byte *buf,	unsigned int size)
+	ArrayXorSink(byte *buf, unsigned int size)
 		: ArraySink(buf, size) {}
 
-	unsigned int Put2(const	byte *begin, unsigned int length, int messageEnd, bool blocking);
+	unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking);
 	byte * CreatePutSpace(unsigned int &size) {return BufferedTransformation::CreatePutSpace(size);}
 };
 
-//!	.
-class StringStore :	public Store
+//! .
+class StringStore : public Store
 {
 public:
 	StringStore(const char *string = NULL)
 		{StoreInitialize(MakeParameters("InputBuffer", ConstByteArrayParameter(string)));}
-	StringStore(const byte *string,	unsigned int length)
+	StringStore(const byte *string, unsigned int length)
 		{StoreInitialize(MakeParameters("InputBuffer", ConstByteArrayParameter(string, length)));}
-	template <class	T> StringStore(const T &string)
+	template <class T> StringStore(const T &string)
 		{StoreInitialize(MakeParameters("InputBuffer", ConstByteArrayParameter(string)));}
 
-	unsigned int TransferTo2(BufferedTransformation	&target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL,	bool blocking=true);
-	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long	&begin,	unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
+	unsigned int TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true);
+	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
 
 private:
 	void StoreInitialize(const NameValuePairs &parameters);
@@ -556,64 +556,64 @@ private:
 	unsigned int m_length, m_count;
 };
 
-//!	.
-class RandomNumberStore	: public Store
+//! .
+class RandomNumberStore : public Store
 {
 public:
-	RandomNumberStore(RandomNumberGenerator	&rng, unsigned long	length)
-		: m_rng(rng), m_length(length),	m_count(0) {}
+	RandomNumberStore(RandomNumberGenerator &rng, unsigned long length)
+		: m_rng(rng), m_length(length), m_count(0) {}
 
-	bool AnyRetrievable() const	{return	MaxRetrievable() !=	0;}
+	bool AnyRetrievable() const {return MaxRetrievable() != 0;}
 	unsigned long MaxRetrievable() const {return m_length-m_count;}
 
-	unsigned int TransferTo2(BufferedTransformation	&target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL,	bool blocking=true);
-	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long	&begin,	unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const
+	unsigned int TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true);
+	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const
 	{
-		throw NotImplemented("RandomNumberStore: CopyRangeTo2()	is not supported by	this store");
+		throw NotImplemented("RandomNumberStore: CopyRangeTo2() is not supported by this store");
 	}
 
 private:
-	void StoreInitialize(const NameValuePairs &parameters) {m_count	= 0;}
+	void StoreInitialize(const NameValuePairs &parameters) {m_count = 0;}
 
 	RandomNumberGenerator &m_rng;
-	const unsigned long	m_length;
+	const unsigned long m_length;
 	unsigned long m_count;
 };
 
-//!	.
-class NullStore	: public Store
+//! .
+class NullStore : public Store
 {
 public:
-	NullStore(unsigned long	size = ULONG_MAX) :	m_size(size) {}
+	NullStore(unsigned long size = ULONG_MAX) : m_size(size) {}
 	void StoreInitialize(const NameValuePairs &parameters) {}
 	unsigned long MaxRetrievable() const {return m_size;}
-	unsigned int TransferTo2(BufferedTransformation	&target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL,	bool blocking=true);
-	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long	&begin,	unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
+	unsigned int TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true);
+	unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const;
 
 private:
 	unsigned long m_size;
 };
 
-//!	A Filter that pumps	data into its attachment as	input
+//! A Filter that pumps data into its attachment as input
 class Source : public InputRejecting<Filter>
 {
 public:
 	Source(BufferedTransformation *attachment)
 		: InputRejecting<Filter>(attachment) {}
 
-	unsigned long Pump(unsigned	long pumpMax=ULONG_MAX)
-		{Pump2(pumpMax); return	pumpMax;}
+	unsigned long Pump(unsigned long pumpMax=ULONG_MAX)
+		{Pump2(pumpMax); return pumpMax;}
 	unsigned int PumpMessages(unsigned int count=UINT_MAX)
 		{PumpMessages2(count); return count;}
 	void PumpAll()
 		{PumpAll2();}
-	virtual	unsigned int Pump2(unsigned	long &byteCount, bool blocking=true) =0;
-	virtual	unsigned int PumpMessages2(unsigned	int	&messageCount, bool	blocking=true) =0;
-	virtual	unsigned int PumpAll2(bool blocking=true);
-	virtual	bool SourceExhausted() const =0;
+	virtual unsigned int Pump2(unsigned long &byteCount, bool blocking=true) =0;
+	virtual unsigned int PumpMessages2(unsigned int &messageCount, bool blocking=true) =0;
+	virtual unsigned int PumpAll2(bool blocking=true);
+	virtual bool SourceExhausted() const =0;
 
 protected:
-	void SourceInitialize(bool pumpAll,	const NameValuePairs &parameters)
+	void SourceInitialize(bool pumpAll, const NameValuePairs &parameters)
 	{
 		IsolatedInitialize(parameters);
 		if (pumpAll)
@@ -621,59 +621,59 @@ protected:
 	}
 };
 
-//!	Turn a Store into a	Source
-template <class	T>
+//! Turn a Store into a Source
+template <class T>
 class SourceTemplate : public Source
 {
 public:
 	SourceTemplate<T>(BufferedTransformation *attachment)
 		: Source(attachment) {}
-	SourceTemplate<T>(BufferedTransformation *attachment, T	store)
+	SourceTemplate<T>(BufferedTransformation *attachment, T store)
 		: Source(attachment), m_store(store) {}
 	void IsolatedInitialize(const NameValuePairs &parameters)
 		{m_store.IsolatedInitialize(parameters);}
-	unsigned int Pump2(unsigned	long &byteCount, bool blocking=true)
-		{return	m_store.TransferTo2(*AttachedTransformation(), byteCount, NULL_CHANNEL,	blocking);}
-	unsigned int PumpMessages2(unsigned	int	&messageCount, bool	blocking=true)
-		{return	m_store.TransferMessagesTo2(*AttachedTransformation(), messageCount, NULL_CHANNEL, blocking);}
+	unsigned int Pump2(unsigned long &byteCount, bool blocking=true)
+		{return m_store.TransferTo2(*AttachedTransformation(), byteCount, NULL_CHANNEL, blocking);}
+	unsigned int PumpMessages2(unsigned int &messageCount, bool blocking=true)
+		{return m_store.TransferMessagesTo2(*AttachedTransformation(), messageCount, NULL_CHANNEL, blocking);}
 	unsigned int PumpAll2(bool blocking=true)
-		{return	m_store.TransferAllTo2(*AttachedTransformation(), NULL_CHANNEL,	blocking);}
+		{return m_store.TransferAllTo2(*AttachedTransformation(), NULL_CHANNEL, blocking);}
 	bool SourceExhausted() const
-		{return	!m_store.AnyRetrievable() && !m_store.AnyMessages();}
+		{return !m_store.AnyRetrievable() && !m_store.AnyMessages();}
 	void SetAutoSignalPropagation(int propagation)
 		{m_store.SetAutoSignalPropagation(propagation);}
-	int	GetAutoSignalPropagation() const
-		{return	m_store.GetAutoSignalPropagation();}
+	int GetAutoSignalPropagation() const
+		{return m_store.GetAutoSignalPropagation();}
 
 protected:
 	T m_store;
 };
 
-//!	.
-class StringSource : public	SourceTemplate<StringStore>
+//! .
+class StringSource : public SourceTemplate<StringStore>
 {
 public:
-	StringSource(BufferedTransformation	*attachment	= NULL)
+	StringSource(BufferedTransformation *attachment = NULL)
 		: SourceTemplate<StringStore>(attachment) {}
-	StringSource(const char	*string, bool pumpAll, BufferedTransformation *attachment =	NULL)
+	StringSource(const char *string, bool pumpAll, BufferedTransformation *attachment = NULL)
 		: SourceTemplate<StringStore>(attachment) {SourceInitialize(pumpAll, MakeParameters("InputBuffer", ConstByteArrayParameter(string)));}
-	StringSource(const byte	*string, unsigned int length, bool pumpAll,	BufferedTransformation *attachment = NULL)
+	StringSource(const byte *string, unsigned int length, bool pumpAll, BufferedTransformation *attachment = NULL)
 		: SourceTemplate<StringStore>(attachment) {SourceInitialize(pumpAll, MakeParameters("InputBuffer", ConstByteArrayParameter(string, length)));}
 
-#ifdef __MWERKS__	// CW60	workaround
-	StringSource(const std::string &string,	bool pumpAll, BufferedTransformation *attachment = NULL)
+#ifdef __MWERKS__	// CW60 workaround
+	StringSource(const std::string &string, bool pumpAll, BufferedTransformation *attachment = NULL)
 #else
-	template <class	T> StringSource(const T	&string, bool pumpAll, BufferedTransformation *attachment =	NULL)
+	template <class T> StringSource(const T &string, bool pumpAll, BufferedTransformation *attachment = NULL)
 #endif
 		: SourceTemplate<StringStore>(attachment) {SourceInitialize(pumpAll, MakeParameters("InputBuffer", ConstByteArrayParameter(string)));}
 };
 
-//!	.
+//! .
 class RandomNumberSource : public SourceTemplate<RandomNumberStore>
 {
 public:
-	RandomNumberSource(RandomNumberGenerator &rng, unsigned	int	length,	bool pumpAll, BufferedTransformation *attachment = NULL)
-		: SourceTemplate<RandomNumberStore>(attachment,	RandomNumberStore(rng, length))	{if	(pumpAll) PumpAll();}
+	RandomNumberSource(RandomNumberGenerator &rng, unsigned int length, bool pumpAll, BufferedTransformation *attachment = NULL)
+		: SourceTemplate<RandomNumberStore>(attachment, RandomNumberStore(rng, length)) {if (pumpAll) PumpAll();}
 };
 
 NAMESPACE_END