summaryrefslogtreecommitdiffstats
path: root/CryptoPP/queue.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--CryptoPP/queue.h143
1 files changed, 143 insertions, 0 deletions
diff --git a/CryptoPP/queue.h b/CryptoPP/queue.h
new file mode 100644
index 000000000..75f7807fd
--- /dev/null
+++ b/CryptoPP/queue.h
@@ -0,0 +1,143 @@
+// specification file for an unlimited queue for storing bytes
+
+#ifndef CRYPTOPP_QUEUE_H
+#define CRYPTOPP_QUEUE_H
+
+#include "simple.h"
+//#include <algorithm>
+
+NAMESPACE_BEGIN(CryptoPP)
+
+/** The queue is implemented as a linked list of byte arrays, but you don't need to
+ know about that. So just ignore this next line. :) */
+class ByteQueueNode;
+
+//! Byte Queue
+class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation>
+{
+public:
+ ByteQueue(size_t nodeSize=0);
+ ByteQueue(const ByteQueue &copy);
+ ~ByteQueue();
+
+ lword MaxRetrievable() const
+ {return CurrentSize();}
+ bool AnyRetrievable() const
+ {return !IsEmpty();}
+
+ void IsolatedInitialize(const NameValuePairs &parameters);
+ byte * CreatePutSpace(size_t &size);
+ size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking);
+
+ size_t Get(byte &outByte);
+ size_t Get(byte *outString, size_t getMax);
+
+ size_t Peek(byte &outByte) const;
+ size_t Peek(byte *outString, size_t peekMax) const;
+
+ size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
+ size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
+
+ // these member functions are not inherited
+ void SetNodeSize(size_t nodeSize);
+
+ lword CurrentSize() const;
+ bool IsEmpty() const;
+
+ void Clear();
+
+ void Unget(byte inByte);
+ void Unget(const byte *inString, size_t length);
+
+ const byte * Spy(size_t &contiguousSize) const;
+
+ void LazyPut(const byte *inString, size_t size);
+ void LazyPutModifiable(byte *inString, size_t size);
+ void UndoLazyPut(size_t size);
+ void FinalizeLazyPut();
+
+ ByteQueue & operator=(const ByteQueue &rhs);
+ bool operator==(const ByteQueue &rhs) const;
+ byte operator[](lword i) const;
+ void swap(ByteQueue &rhs);
+
+ class Walker : public InputRejecting<BufferedTransformation>
+ {
+ public:
+ Walker(const ByteQueue &queue)
+ : m_queue(queue) {Initialize();}
+
+ lword GetCurrentPosition() {return m_position;}
+
+ lword MaxRetrievable() const
+ {return m_queue.CurrentSize() - m_position;}
+
+ void IsolatedInitialize(const NameValuePairs &parameters);
+
+ size_t Get(byte &outByte);
+ size_t Get(byte *outString, size_t getMax);
+
+ size_t Peek(byte &outByte) const;
+ size_t Peek(byte *outString, size_t peekMax) const;
+
+ size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
+ size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
+
+ private:
+ const ByteQueue &m_queue;
+ const ByteQueueNode *m_node;
+ lword m_position;
+ size_t m_offset;
+ const byte *m_lazyString;
+ size_t m_lazyLength;
+ };
+
+ friend class Walker;
+
+private:
+ void CleanupUsedNodes();
+ void CopyFrom(const ByteQueue &copy);
+ void Destroy();
+
+ bool m_autoNodeSize;
+ size_t m_nodeSize;
+ ByteQueueNode *m_head, *m_tail;
+ byte *m_lazyString;
+ size_t m_lazyLength;
+ bool m_lazyStringModifiable;
+};
+
+//! use this to make sure LazyPut is finalized in event of exception
+class CRYPTOPP_DLL LazyPutter
+{
+public:
+ LazyPutter(ByteQueue &bq, const byte *inString, size_t size)
+ : m_bq(bq) {bq.LazyPut(inString, size);}
+ ~LazyPutter()
+ {try {m_bq.FinalizeLazyPut();} catch(...) {}}
+protected:
+ LazyPutter(ByteQueue &bq) : m_bq(bq) {}
+private:
+ ByteQueue &m_bq;
+};
+
+//! like LazyPutter, but does a LazyPutModifiable instead
+class LazyPutterModifiable : public LazyPutter
+{
+public:
+ LazyPutterModifiable(ByteQueue &bq, byte *inString, size_t size)
+ : LazyPutter(bq) {bq.LazyPutModifiable(inString, size);}
+};
+
+NAMESPACE_END
+
+#ifndef __BORLANDC__
+NAMESPACE_BEGIN(std)
+template<> inline void swap(CryptoPP::ByteQueue &a, CryptoPP::ByteQueue &b)
+{
+ a.swap(b);
+}
+NAMESPACE_END
+#endif
+
+#endif