Implement AP2 Promises

Source/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 61 matching lines @@
         reverse_iterator rend() { return reverse_iterator(begin()); }
         const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
         const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
         T& first() { ASSERT(m_start != m_end); return m_buffer.buffer()[m_start]; }
         const T& first() const { ASSERT(m_start != m_end); return m_buffer.buffer()[m_start]; }
         PassType takeFirst();
 
         T& last() { ASSERT(m_start != m_end); return *(--end()); }
         const T& last() const { ASSERT(m_start != m_end); return *(--end()); }
+        PassType takeLast();
 
         template<typename U> void append(const U&);
         template<typename U> void prepend(const U&);
         void removeFirst();
+        void removeLast();
         void remove(iterator&);
         void remove(const_iterator&);
 
         void clear();
 
         template<typename Predicate>
         iterator findIf(Predicate&);
 
     private:
         friend class DequeIteratorBase<T, inlineCapacity>;
@@ skipping 223 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity>
     inline typename Deque<T, inlineCapacity>::PassType Deque<T, inlineCapacity>::takeFirst()
     {
         T oldFirst = Pass::transfer(first());
         removeFirst();
         return Pass::transfer(oldFirst);
     }
 
+    template<typename T, size_t inlineCapacity>
+    inline typename Deque<T, inlineCapacity>::PassType Deque<T, inlineCapacity>::takeLast()
+    {
+        T oldLast = Pass::transfer(last());
+        removeLast();
+        return Pass::transfer(oldLast);
+    }
+
     template<typename T, size_t inlineCapacity> template<typename U>
     inline void Deque<T, inlineCapacity>::append(const U& value)
     {
         expandCapacityIfNeeded();
         new (NotNull, &m_buffer.buffer()[m_end]) T(value);
         if (m_end == m_buffer.capacity() - 1)
             m_end = 0;
         else
             ++m_end;
     }
@@ skipping 14 matching lines @@
     {
         ASSERT(!isEmpty());
         TypeOperations::destruct(&m_buffer.buffer()[m_start], &m_buffer.buffer()[m_start + 1]);
         if (m_start == m_buffer.capacity() - 1)
             m_start = 0;
         else
             ++m_start;
     }
 
     template<typename T, size_t inlineCapacity>
+    inline void Deque<T, inlineCapacity>::removeLast()
+    {
+        ASSERT(!isEmpty());
+        if (!m_end)
+            m_end = m_buffer.capacity() - 1;
+        else
+            --m_end;
+        TypeOperations::destruct(&m_buffer.buffer()[m_end], &m_buffer.buffer()[m_end + 1]);
+    }
+
+    template<typename T, size_t inlineCapacity>
     inline void Deque<T, inlineCapacity>::remove(iterator& it)
     {
         remove(it.m_index);
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Deque<T, inlineCapacity>::remove(const_iterator& it)
     {
         remove(it.m_index);
     }
@@ skipping 92 matching lines @@
         if (!m_index)
             return &m_deque->m_buffer.buffer()[m_deque->m_buffer.capacity() - 1];
         return &m_deque->m_buffer.buffer()[m_index - 1];
     }
 
 } // namespace WTF
 
 using WTF::Deque;
 
 #endif // WTF_Deque_h