From d50c1c742947b45e10f0dbf85cfac79d49c91e54 Mon Sep 17 00:00:00 2001
From: Sean Hunt <scshunt@csclub.uwaterloo.ca>
Date: Fri, 29 Jul 2011 23:42:36 +0000
Subject: [PATCH] Include an "implementation" if SGI's slist. This was quickly
 hacked together to get it working with code, and is neither optimal
 (erase(Iterator, Iterator) calculates the previous iterator twice, rather
 than calculating the previous iterator of the first one, then advancing it
 until the second is found) nor complete (splice() was not implemented). Most
 of the implementation is borrowed from forward_list via using-declarations.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136542 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/ext/slist | 128 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 include/ext/slist

diff --git a/include/ext/slist b/include/ext/slist
new file mode 100644
index 000000000..a7703e478
--- /dev/null
+++ b/include/ext/slist
@@ -0,0 +1,128 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP__EXT_SLIST
+#define _LIBCPP__EXT_SLIST
+
+#include <__config>
+#include <forward_list>
+#include <iterator>
+
+#pragma GCC system_header
+
+namespace __gnu_cxx {
+
+using namespace std;
+
+template <class _Tp, class _Alloc>
+class _LIBCPP_VISIBLE slist : forward_list<_Tp, _Alloc>
+{
+public:
+    typedef forward_list<_Tp, _Alloc> __base_type;
+    using typename __base_type::value_type;
+    using typename __base_type::pointer;
+    using typename __base_type::reference;
+    using typename __base_type::const_reference;
+    using typename __base_type::size_type;
+    using typename __base_type::difference_type;
+    using typename __base_type::iterator;
+    using typename __base_type::const_iterator;
+    using __base_type::begin;
+    using __base_type::end;
+    using __base_type::max_size;
+    using __base_type::empty;
+    using __base_type::front;
+    using __base_type::push_front;
+    using __base_type::pop_front;
+    using __base_type::clear;
+    using __base_type::resize;
+    using __base_type::insert_after;
+    using __base_type::erase_after;
+    using __base_type::splice_after;
+    using __base_type::remove;
+    using __base_type::remove_if;
+    using __base_type::unique;
+    using __base_type::sort;
+    using __base_type::reverse;
+
+    _LIBCPP_INLINE_VISIBILITY
+    slist() { }
+    _LIBCPP_INLINE_VISIBILITY
+    slist(size_type __n) : __base_type(__n) { }
+    _LIBCPP_INLINE_VISIBILITY
+    slist(size_type __n, const _Tp& __t) : __base_type(__n, __t) { }
+    _LIBCPP_INLINE_VISIBILITY
+    template <typename _InputIterator>
+    slist(_InputIterator __f, _InputIterator __l) : __base_type(__f, __l) { }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void swap (slist& __s) { __base_type::swap(s); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void merge (slist& __s) { __base_type::merge(s); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    friend bool operator==(const slist& __l, const slist& __r)
+    {
+        return static_cast<const __base_type&>(__l) ==
+               static_cast<const __base_type&>(__r);
+    }
+    _LIBCPP_INLINE_VISIBILITY
+    friend bool operator<(const slist& __l, const slist& __r)
+    {
+        return static_cast<const __base_type&>(__l) ==
+               static_cast<const __base_type&>(__r);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type size() const { return _VSTD::distance(begin(), end()); }
+
+    iterator previous(iterator __pos);
+    const_iterator previous(const_iterator __pos);
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(iterator __pos, const _Tp& __x) { return insert(previous(__pos), __x); }
+    _LIBCPP_INLINE_VISIBILITY
+    template <class _InputIterator>
+    void insert(iterator __pos, _InputIterator __f, _InputIterator __l) { return insert(previous(__pos), __f, __l); }
+    _LIBCPP_INLINE_VISIBILITY
+    void insert(iterator __pos, size_type __n, const _Tp& __x) { return insert(previous(__pos), __n, __x); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator erase(iterator __pos) { return erase(previous(__pos)); } 
+    _LIBCPP_INLINE_VISIBILITY
+    iterator erase(iterator __f, iterator __l) { return erase(previous(__f), previous(__l)); }
+};
+
+template <class _Tp, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+slist<_Tp, _Alloc>::iterator slist<_Tp, _Alloc>::previous(iterator __pos)
+{
+  iterator __a = begin(), __b = end();
+  while (__a != __pos)
+  {
+    __b = __a;
+    ++__a;
+  }
+  return __b;
+}
+
+template <class _Tp, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+slist<_Tp, _Alloc>::const_iterator slist<_Tp, _Alloc>::previous(const_iterator __pos)
+{
+  iterator __a = begin(), __b = end();
+  while (__a != __pos)
+  {
+    __b = __a;
+    ++__a;
+  }
+  return __b;
+}