~ubuntu-branches/debian/jessie/armory/jessie

// 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