queue.h

Go to the documentation of this file.

// queue.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_QUEUE_H
#define CRYPTOPP_QUEUE_H
 
#include "cryptlib.h"
#include "simple.h"
 
NAMESPACE_BEGIN(CryptoPP)
 
class ByteQueueNode;
 
class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation>
{
public:
        virtual ~ByteQueue();
 
        ByteQueue(size_t nodeSize=0);
 
        ByteQueue(const ByteQueue &copy);
 
        // BufferedTransformation
        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;
 
        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 index) const;
 
        void swap(ByteQueue &rhs);
 
        class Walker : public InputRejecting<BufferedTransformation>
        {
        public:
                Walker(const ByteQueue &queue)
                        : m_queue(queue), m_node(NULLPTR), m_position(0), m_offset(0), m_lazyString(NULLPTR), 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;
 
protected:
        void CleanupUsedNodes();
        void CopyFrom(const ByteQueue &copy);
        void Destroy();
 
private:
        ByteQueueNode *m_head, *m_tail;
        byte *m_lazyString;
        size_t m_lazyLength;
        size_t m_nodeSize;
        bool m_lazyStringModifiable;
        bool m_autoNodeSize;
};
 
class CRYPTOPP_DLL LazyPutter
{
public:
        virtual ~LazyPutter() {
                try {m_bq.FinalizeLazyPut();}
                catch(const Exception&) {CRYPTOPP_ASSERT(0);}
        }
 
        LazyPutter(ByteQueue &bq, const byte *inString, size_t size)
                : m_bq(bq) {bq.LazyPut(inString, size);}
 
protected:
        LazyPutter(ByteQueue &bq) : m_bq(bq) {}
 
private:
        ByteQueue &m_bq;
};
 
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