8 #include <botan/secqueue.h>    19       SecureQueueNode() : buffer(DEFAULT_BUFFERSIZE)
    20          { next = 0; start = end = 0; }
    22       ~SecureQueueNode() { next = 0; start = end = 0; }
    24       size_t write(
const byte input[], 
size_t length)
    26          size_t copied = std::min<size_t>(length, buffer.size() - end);
    27          copy_mem(&buffer[end], input, copied);
    32       size_t read(
byte output[], 
size_t length)
    34          size_t copied = 
std::min(length, end - start);
    35          copy_mem(output, &buffer[start], copied);
    40       size_t peek(
byte output[], 
size_t length, 
size_t offset = 0)
    42          const size_t left = end - start;
    43          if(offset >= left) 
return 0;
    44          size_t copied = 
std::min(length, left - offset);
    45          copy_mem(output, &buffer[start + offset], copied);
    49       size_t size()
 const { 
return (end - start); }
    51       friend class SecureQueue;
    52       SecureQueueNode* next;
    53       SecureVector<byte> buffer;
    63    head = tail = 
new SecureQueueNode;
    74    head = tail = 
new SecureQueueNode;
    75    SecureQueueNode* temp = input.head;
    78       write(&temp->buffer[temp->start], temp->end - temp->start);
    86 void SecureQueue::destroy()
    88    SecureQueueNode* temp = head;
    91       SecureQueueNode* holder = temp->next;
   104    head = tail = 
new SecureQueueNode;
   105    SecureQueueNode* temp = input.head;
   108       write(&temp->buffer[temp->start], temp->end - temp->start);
   120       head = tail = 
new SecureQueueNode;
   123       const size_t n = tail->write(input, length);
   128          tail->next = 
new SecureQueueNode;
   140    while(length && head)
   142       const size_t n = head->read(output, length);
   146       if(head->size() == 0)
   148          SecureQueueNode* holder = head->next;
   161    SecureQueueNode* current = head;
   163    while(offset && current)
   165       if(offset >= current->size())
   167          offset -= current->size();
   168          current = current->next;
   175    while(length && current)
   177       const size_t n = current->peek(output, length, offset);
   182       current = current->next;
   192    SecureQueueNode* current = head;
   197       count += current->size();
   198       current = current->next;
   208    return (
size() == 0);
 
size_t read(byte[], size_t)
void set_next(Filter *f[], size_t n)
SecureQueue & operator=(const SecureQueue &other)
void copy_mem(T *out, const T *in, size_t n)
void write(const byte[], size_t)
size_t peek(byte[], size_t, size_t=0) const