queue.h
Go to the documentation of this file.
// queue.h - written and placed in the public domain by Wei Dai
//! \file
//! \headerfile queue.h
//! \brief Classes for an unlimited queue to store bytes
#ifndef CRYPTOPP_QUEUE_H
#define CRYPTOPP_QUEUE_H
#include "cryptlib.h"
#include "simple.h"
NAMESPACE_BEGIN(CryptoPP)
class ByteQueueNode;
//! \class ByteQueue
//! \brief Data structure used to store byte strings
//! \details The queue is implemented as a linked list of byte arrays
class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation>
{
public:
//! \brief Construct a ByteQueue
//! \param nodeSize the initial node size
//! \details Internally, ByteQueue uses a ByteQueueNode to store bytes, and \p nodeSize determines the
//! size of the ByteQueueNode. A value of 0 indicates the ByteQueueNode should be automatically sized,
//! which means a value of 256 is used.
ByteQueue(size_t nodeSize=0);
//! \brief Copy construct a ByteQueue
//! \param copy the other ByteQueue
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;
bool operator!=(const ByteQueue &rhs) const {return !operator==(rhs);}
byte operator[](lword i) const;
void swap(ByteQueue &rhs);
//! \class Walker
//! \brief A ByteQueue iterator
class Walker : public InputRejecting<BufferedTransformation>
{
public:
//! \brief Construct a ByteQueue Walker
//! \param queue a ByteQueue
Walker(const ByteQueue &queue)
: m_queue(queue), m_node(NULL), m_position(0), m_offset(0), m_lazyString(NULL), m_lazyLength(0)
{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(const Exception&) {assert(0);}}
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
LazyPutter
use this to make sure LazyPut is finalized in event of exception
Definition: queue.h:129
ByteQueue::MaxRetrievable
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Definition: queue.h:35
ByteQueue
Data structure used to store byte strings.
Definition: queue.h:20
ByteQueue::Walker::Walker
Walker(const ByteQueue &queue)
Construct a ByteQueue Walker.
Definition: queue.h:84
BufferedTransformation
Interface for buffered transformations.
Definition: cryptlib.h:1352
ByteQueueNode
Definition: queue.cpp:15
DEFAULT_CHANNEL
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
Definition: cryptlib.cpp:63
simple.h
Classes providing basic library services.
InputRejecting
Base class for input rejecting filters.
Definition: simple.h:121
Exception
Base class for all exceptions thrown by the library.
Definition: cryptlib.h:139
operator==
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
LazyPutterModifiable
like LazyPutter, but does a LazyPutModifiable instead
Definition: queue.h:143
ByteQueue::Walker::MaxRetrievable
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Definition: queue.h:90
Bufferless
Base class for bufferless filters.
Definition: simple.h:83
ByteQueue::Walker
A ByteQueue iterator.
Definition: queue.h:79
ByteQueue::AnyRetrievable
bool AnyRetrievable() const
Determines whether bytes are ready for retrieval.
Definition: queue.h:37
CryptoPP
Crypto++ library namespace.
operator!=
bool operator!=(const OID &lhs, const OID &rhs)
Compare two OIDs for inequality.
NameValuePairs
Interface for retrieving values given their names.
Definition: cryptlib.h:277
cryptlib.h
Abstract base classes that provide a uniform interface to this library.