Crypto++ 8.4 Free C++ class library of cryptographic schemes

queue.h
Go to the documentation of this file.
1 // queue.h - originally written and placed in the public domain by Wei Dai
2
3 /// \file
4 /// \brief Classes for an unlimited queue to store bytes
5
6 #ifndef CRYPTOPP_QUEUE_H
7 #define CRYPTOPP_QUEUE_H
8
9 #include "cryptlib.h"
10 #include "simple.h"
11
12 NAMESPACE_BEGIN(CryptoPP)
13
14 class ByteQueueNode;
15
16 /// \brief Data structure used to store byte strings
17 /// \details The queue is implemented as a linked list of byte arrays
18 class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation>
19 {
20 public:
21 /// \brief Construct a ByteQueue
22 /// \param nodeSize the initial node size
23 /// \details Internally, ByteQueue uses a ByteQueueNode to store bytes, and \p nodeSize determines the
24 /// size of the ByteQueueNode. A value of 0 indicates the ByteQueueNode should be automatically sized,
25 /// which means a value of 256 is used.
26 ByteQueue(size_t nodeSize=0);
27
28 /// \brief Copy construct a ByteQueue
29 /// \param copy the other ByteQueue
30 ByteQueue(const ByteQueue &copy);
31 ~ByteQueue();
32
33 lword MaxRetrievable() const
34 {return CurrentSize();}
35 bool AnyRetrievable() const
36 {return !IsEmpty();}
37
38 void IsolatedInitialize(const NameValuePairs &parameters);
39 byte * CreatePutSpace(size_t &size);
40 size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking);
41
42 size_t Get(byte &outByte);
43 size_t Get(byte *outString, size_t getMax);
44
45 size_t Peek(byte &outByte) const;
46 size_t Peek(byte *outString, size_t peekMax) const;
47
48 size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
49 size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
50
51 // these member functions are not inherited
52 void SetNodeSize(size_t nodeSize);
53
54 lword CurrentSize() const;
55 bool IsEmpty() const;
56
57 void Clear();
58
59 void Unget(byte inByte);
60 void Unget(const byte *inString, size_t length);
61
62 const byte * Spy(size_t &contiguousSize) const;
63
64 void LazyPut(const byte *inString, size_t size);
65 void LazyPutModifiable(byte *inString, size_t size);
66 void UndoLazyPut(size_t size);
67 void FinalizeLazyPut();
68
69 ByteQueue & operator=(const ByteQueue &rhs);
70 bool operator==(const ByteQueue &rhs) const;
71 bool operator!=(const ByteQueue &rhs) const {return !operator==(rhs);}
72 byte operator[](lword i) const;
73 void swap(ByteQueue &rhs);
74
75 /// \brief A ByteQueue iterator
76 class Walker : public InputRejecting<BufferedTransformation>
77 {
78 public:
79 /// \brief Construct a ByteQueue Walker
80 /// \param queue a ByteQueue
81 Walker(const ByteQueue &queue)
82 : m_queue(queue), m_node(NULLPTR), m_position(0), m_offset(0), m_lazyString(NULLPTR), m_lazyLength(0)
83 {Initialize();}
84
85 lword GetCurrentPosition() {return m_position;}
86
87 lword MaxRetrievable() const
88 {return m_queue.CurrentSize() - m_position;}
89
90 void IsolatedInitialize(const NameValuePairs &parameters);
91
92 size_t Get(byte &outByte);
93 size_t Get(byte *outString, size_t getMax);
94
95 size_t Peek(byte &outByte) const;
96 size_t Peek(byte *outString, size_t peekMax) const;
97
98 size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
99 size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
100
101 private:
102 const ByteQueue &m_queue;
103 const ByteQueueNode *m_node;
104 lword m_position;
105 size_t m_offset;
106 const byte *m_lazyString;
107 size_t m_lazyLength;
108 };
109
110 friend class Walker;
111
112 private:
113 void CleanupUsedNodes();
114 void CopyFrom(const ByteQueue &copy);
115 void Destroy();
116
117 bool m_autoNodeSize;
118 size_t m_nodeSize;
119 ByteQueueNode *m_head, *m_tail;
120 byte *m_lazyString;
121 size_t m_lazyLength;
122 bool m_lazyStringModifiable;
123 };
124
125 /// use this to make sure LazyPut is finalized in event of exception
126 class CRYPTOPP_DLL LazyPutter
127 {
128 public:
129 LazyPutter(ByteQueue &bq, const byte *inString, size_t size)
130 : m_bq(bq) {bq.LazyPut(inString, size);}
131 ~LazyPutter()
132 {try {m_bq.FinalizeLazyPut();} catch(const Exception&) {CRYPTOPP_ASSERT(0);}}
133 protected:
134 LazyPutter(ByteQueue &bq) : m_bq(bq) {}
135 private:
136 ByteQueue &m_bq;
137 };
138
139 /// like LazyPutter, but does a LazyPutModifiable instead
140 class LazyPutterModifiable : public LazyPutter
141 {
142 public:
143 LazyPutterModifiable(ByteQueue &bq, byte *inString, size_t size)
144 : LazyPutter(bq) {bq.LazyPutModifiable(inString, size);}
145 };
146
147 NAMESPACE_END
148
149 #ifndef __BORLANDC__
150 NAMESPACE_BEGIN(std)
151 template<> inline void swap(CryptoPP::ByteQueue &a, CryptoPP::ByteQueue &b)
152 {
153 a.swap(b);
154 }
155 NAMESPACE_END
156 #endif
157
158 #endif
LazyPutter
use this to make sure LazyPut is finalized in event of exception
Definition: queue.h:126
ByteQueue::MaxRetrievable
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Definition: queue.h:33
swap
void swap(::SecBlock< T, A > &a, ::SecBlock< T, A > &b)
Swap two SecBlocks.
Definition: secblock.h:1177
ByteQueue
Data structure used to store byte strings.
Definition: queue.h:18
ByteQueue::Walker::Walker
Walker(const ByteQueue &queue)
Construct a ByteQueue Walker.
Definition: queue.h:81
BufferedTransformation
Interface for buffered transformations.
Definition: cryptlib.h:1634
CRYPTOPP_ASSERT
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:68
DEFAULT_CHANNEL
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
Definition: cryptlib.h:511
simple.h
Classes providing basic library services.
InputRejecting
Base class for input rejecting filters.
Definition: simple.h:194
Exception
Base class for all exceptions thrown by the library.
Definition: cryptlib.h:158
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:140
ByteQueue::Walker::MaxRetrievable
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Definition: queue.h:87
Bufferless
Base class for bufferless filters.
Definition: simple.h:119
lword
word64 lword
Large word type.
Definition: config_int.h:158
ByteQueue::Walker
A ByteQueue iterator.
Definition: queue.h:76
ByteQueue::AnyRetrievable
bool AnyRetrievable() const
Determines whether bytes are ready for retrieval.
Definition: queue.h:35
CryptoPP
Crypto++ library namespace.
operator!=
bool operator!=(const OID &lhs, const OID &rhs)
Compare two OIDs for inequality.
LWORD_MAX
const lword LWORD_MAX
Large word type max value.
Definition: config_int.h:164
NameValuePairs
Interface for retrieving values given their names.
Definition: cryptlib.h:321
cryptlib.h
Abstract base classes that provide a uniform interface to this library.