/*  Copyright (C) 2015  Povilas Kanapickas <povilas@radix.lt>

    This file is part of cppreference-doc

    This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
    Unported License. To view a copy of this license, visit
    http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
    Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

    Permission is granted to copy, distribute and/or modify this document
    under the terms of the GNU Free Documentation License, Version 1.3 or
    any later version published by the Free Software Foundation; with no
    Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
*/

#ifndef CPPREFERENCE_LIST_H
#define CPPREFERENCE_LIST_H

#if CPPREFERENCE_STDVER>= 2011
#include <initializer_list>
#endif

#include <cstddef> // for size_t, ptrdiff_t
#include <iterator> // for std::reverse_iterator
#include <memory> // for std::allocator

namespace std {

template<class T, class Allocator = std::allocator<T>>
class list {
public:
    typedef T value_type;
    typedef Allocator allocator_type;
    typedef size_t size_type; // actual type unspecified
    typedef ptrdiff_t difference_type; // actual type not specified
#if CPPREFERENCE_SIMPLIFY_TYPEDEFS
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
#elif CPPREFERENCE_STDVER <2011
    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;
    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer const_pointer;
#else
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef typename std::allocator_traits<Allocator>::pointer pointer;
    typedef typename std::allocator_traits<Allocator>::const_pointer const_pointer;
#endif
    typedef T* iterator; // actual type is unspecified
    typedef const T* const_iterator; // actual type is unspecified
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    // constructor
#if CPPREFERENCE_STDVER <2014
    explicit list(const Allocator& alloc = Allocator());
#else
    list();
    explicit list(const Allocator& alloc);
#endif

#if CPPREFERENCE_STDVER <2011
    explicit list(size_type count,
                  const T& value = T(),
                  const Allocator& alloc = Allocator());
#else
    list(size_type count,
         const T& value,
         const Allocator& alloc = Allocator());

#if CPPREFERENCE_STDVER <2014
    explicit list(size_type n);
#else
    explicit list(size_type n, const Allocator& alloc = Allocator());
#endif

    template<class InputIt>
    list(InputIt first, InputIt last,
         const Allocator& alloc = Allocator());

    list(const list& other);
#if CPPREFERENCE_STDVER>= 2011
    list(const list& other, const Allocator& alloc);
#endif

    list(list&& other);
#if CPPREFERENCE_STDVER>= 2011
    list(list&& other, const Allocator& alloc);

    list(std::initializer_list<T> init,
         const Allocator& alloc = Allocator());
#endif

    ~list();

    list& operator=(const list& other);
#if CPPREFERENCE_STDVER>= 2011
    list& operator=(list&& other);
    list& operator=(initializer_list<T> ilist);
#endif

    void assign(size_type count, const value_type& value);
    template <class InputIt>
    void assign(InputIt first, InputIt last);
#if CPPREFERENCE_STDVER>= 2011
    void assign(std::initializer_list<T> ilist);
#endif

    allocator_type get_allocator() const;

    // element access
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;

    // iterators
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;

    reverse_iterator       rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator       rend();
    const_reverse_iterator rend() const;

#if CPPREFERENCE_STDVER>= 2011
    const_iterator         cbegin() const;
    const_iterator         cend() const;
    const_reverse_iterator crbegin() const;
    const_reverse_iterator crend() const;
#endif

    bool empty() const;
    size_type size() const;
    size_type max_size() const;

    // modifiers
    void clear();

#if CPPREFERENCE_STDVER <2011
    iterator insert(iterator pos, const T& value);
    void insert(iterator pos, size_type count, const T& value);
    template<class InputIt>
    void insert(iterator pos, InputIt first, InputIt last);
#else
    iterator insert(const_iterator pos, const T& value);
    iterator insert(const_iterator pos, T&& value);
    iterator insert(const_iterator pos, size_type count, const T& value);
    template<class InputIt>
    iterator insert(const_iterator pos, InputIt first, InputIt last);
    iterator insert(const_iterator pos, std::initializer_list<T> ilist);
#endif

#if CPPREFERENCE_STDVER>= 2011
    template<class... Args>
    iterator emplace(const_iterator pos, Args&& ... args);
#endif

#if CPPREFERENCE_STDVER <2011
    iterator erase(iterator pos);
    iterator erase(iterator first, iterator last);
#else
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);
#endif

    void push_back(const T& value);
#if CPPREFERENCE_STDVER>= 2011
    void push_back(T&& value);
#endif

#if CPPREFERENCE_STDVER>= 2011
    template<class... Args>
    void emplace_back(Args&& ... args);
#endif

    void pop_back();

    void push_front(const T& value);
#if CPPREFERENCE_STDVER>= 2011
    void push_front(T&& value);
#endif

#if CPPREFERENCE_STDVER>= 2011
    template<class... Args>
    void emplace_front(Args&& ... args);
#endif

    void pop_front();

#if CPPREFERENCE_STDVER <2011
    void resize(size_type count, T value = T());
#else
    void resize(size_type count);
    void resize(size_type count, const value_type& value);
#endif

    void swap(list& other);

    // operations
    void merge(list& other);

#if CPPREFERENCE_STDVER>= 2011
    void merge(list&& other);
#endif

    template <class Compare>
    void merge(list& other, Compare comp);

#if CPPREFERENCE_STDVER>= 2011
    template <class Compare>
    void merge(list&& other, Compare comp);
#endif

    void splice(const_iterator pos, list& other);
    void splice(const_iterator pos, list& other, const_iterator it);
    void splice(const_iterator pos, list& other,
                const_iterator first, const_iterator last);
#if CPPREFERENCE_STDVER>= 2011
    void splice(const_iterator pos, list&& other);
    void splice(const_iterator pos, list&& other, const_iterator it);
    void splice(const_iterator pos, list&& other,
                const_iterator first, const_iterator last);
#endif

    void remove(const T& value);

    template<class UnaryPredicate>
    void remove_if(UnaryPredicate p);

    void reverse();

    void unique();

    template<class BinaryPredicate>
    void unique(BinaryPredicate p);

    void sort();

    template<class Compare>
    void sort(Compare comp);
};

template<class T, class Alloc>
bool operator==(const list<T, Alloc>& lhs,
                const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator!=(const list<T, Alloc>& lhs,
                const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator<(const list<T, Alloc>& lhs,
               const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator<=(const list<T, Alloc>& lhs,
                const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>(const list<T, Alloc>& lhs,
               const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>=(const list<T, Alloc>& lhs,
                const list<T, Alloc>& rhs);

} // namespace std

#endif // CPPREFERENCE_LIST_H