objqueue.h

伯克利做的SFTP安全文件传输协议

// objqueue.h
// queue of self-sufficient objects (e.g. ints)
// required operations:
//   copy ctor
//   =
//   dtor (of course)
// copyright SafeTP Development Group, Inc., 2000  Terms of use are as specified in license.txt

#ifndef __OBJQUEUE_H
#define __OBJQUEUE_H

#include "xassert.h"      // xassert
#include "typ.h"          // bool
#include <stdio.h>        // NULL

template <class T>
class Queue {
  class Node {
  public:
    T data;
    Node *next;
  public:
    Node(T const &d, Node *n) : data(d), next(n) {}
    ~Node() {}
  };

private:     // data
  Node *head;      // where we dequeue
  Node *tail;      // where we enqueue

private:     // funcs
  void init() { head=NULL; tail=NULL; }
  void dup(Queue const &obj);

public:      // funcs
  Queue() { init(); }        // initially empty
  ~Queue() { empty(); }
  Queue(Queue const &obj) { init(); dup(obj); }
  Queue& operator= (Queue const &obj) {
    if (this != &obj) { empty(); dup(obj); }
    return *this;
  }

  // basic queue operations
  void enqueue(T const &d);
  T dequeue();              // can't be empty

  // simple extensions
  bool isEmpty() const { return head == NULL; }
  T peek() const;           // non-destructive dequeue

  // moderate extensions
  int count() const;
  void empty();             // throws away all values in queue
};


template <class T>
void Queue<T>::dup(Queue const &obj)
{
  for (Node const *n = obj.head; n != NULL; n = n->next) {
    enqueue(n->data);
  }
}


template <class T>
void Queue<T>::enqueue(T const &d)
{
  Node *n = new Node(d, NULL);

  if (tail == NULL) {
    xassert(head == NULL);
    head = tail = n;
  }
  else {   // tail != NULL
    xassert(head != NULL);
    tail->next = n;
    tail = n;
  }
}


template <class T>
T Queue<T>::dequeue()
{
  xassert(!isEmpty());
  T ret = head->data;     // grab data to return
  Node *temp = head;      // grab node to delete
  head = head->next;      // skip past it..
  delete temp;

  if (head == NULL) {
    tail = NULL;     // reset
  }

  return ret;
}


template <class T>
T Queue<T>::peek() const
{
  xassert(!isEmpty());
  return head->data;
}


template <class T>
int Queue<T>::count() const
{
  int ct = 0;
  for (Node const *n = head; n != NULL; n = n->next) {
    ct++;
  }
  return ct;
}


template <class T>
void Queue<T>::empty()
{
  while (!isEmpty()) {
    dequeue();
  }
}

#endif // __OBJQUEUE_H