Account for old versions of Pygments

[lyx.git] / src / support / limited_stack.h

diff --git a/src/support/limited_stack.h b/src/support/limited_stack.h
index 8b709758a796d8b23bd2353184fc5cc473617578..b17eeae19dbca92efecaedff761a8f40d73d8744 100644 (file)
--- a/src/support/limited_stack.h
+++ b/src/support/limited_stack.h
@@ -1,19 +1,24 @@
 // -*- C++ -*-
 /**
  * \file limited_stack.h
- * Copyright 2002 the LyX Team
- * Read the file COPYING
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- * \author John Levon <moz@compsoc.man.ac.uk>
+ * \author John Levon
+ *
+ * Full author contact details are available in file CREDITS.
  */
 
 #ifndef LIMITED_STACK_H
 #define LIMITED_STACK_H
 
-#include <list>
+#include <deque>
+
+
+namespace lyx {
 
 /**
- * limited_stack - a stack of limited size
+ * limited_stack - A stack of limited size.
  *
  * Like a normal stack, but elements falling out
  * of the bottom are destructed.
@@ -21,55 +26,75 @@
 template <typename T>
 class limited_stack {
 public:
-       typedef std::list<T> container_type;
+       typedef std::deque<T> container_type;
        typedef typename container_type::value_type value_type;
        typedef typename container_type::size_type size_type;
- 
+       typedef typename container_type::const_iterator const_iterator;
+
        /// limit is the maximum size of the stack
-       limited_stack(size_type limit = 10) {
+       limited_stack(size_type limit = 100) {
                limit_ = limit;
        }
 
-       /// return the top element
-       value_type top() {
+       /// Return the top element.
+       value_type & top() {
                return c_.front();
        }
 
-       /// pop and throw away the top element
+       /// Pop and throw away the top element.
        void pop() {
                c_.pop_front();
        }
- 
-       /// return true if the stack is empty
+
+       /// Return true if the stack is empty.
        bool empty() const {
-               return c_.size() == 0;
+               return c_.empty();
        }
 
-       /// clear all elements, deleting them
+       /// Clear all elements, deleting them.
        void clear() {
-               while (!c_.empty()) {
-                       c_.pop_back();
-               }
+               c_.clear();
        }
- 
-       /// push an item on to the stack, deleting the
+
+       /// Push an item on to the stack, deleting the
        /// bottom item on overflow.
        void push(value_type const & v) {
                c_.push_front(v);
                if (c_.size() > limit_) {
-                       c_.pop_back(); 
+                       c_.pop_back();
                }
        }
- 
+
+       /// Direct read access to intermediate elements.
+       T const & operator[](size_type pos) const {
+               return c_[pos];
+       }
+
+       /// Read access to used size.
+       size_type size() const {
+               return c_.size();
+       }
+
+       const_iterator begin() const {
+               return c_.begin();
+       }
+
+       const_iterator end() const {
+               return c_.end();
+       }
+
 private:
-       /// internal contents
+       /// Internal contents.
        container_type c_;
-       /// the maximum number elements stored
+       /// The maximum number elements stored.
        size_type limit_;
 };
 
-// make pointer type an error.
+// Make pointer type an error.
 template <typename T>
 class limited_stack<T*>;
- 
+
+
+} // namespace lyx
+
 #endif // LIMITED_STACK_H