/*  Copyright (C) 2019  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_VARIANT_H
#define CPPREFERENCE_VARIANT_H

#if CPPREFERENCE_STDVER >= 2017

#include <exception> // exception
#include <functional> // hash
#include <utility> // in_place_type_t, ...
#include <type_traits>
#include <detail/cppreference_unspecified>

namespace std {

inline constexpr std::size_t variant_npos = static_cast<size_t>(-1);

struct monostate {};

class bad_variant_access : public exception {
public:
    bad_variant_access();
    ~bad_variant_access() override;
    const char * what() const override;
};

template<class... Types>
class variant; // forward declaration

template<size_t I, class T>
struct variant_alternative; // undefined

template<size_t I, class... Types>
struct variant_alternative<I, variant<Types...>> {
    using type = CPPREFERENCE_SIMPLIFIED_TYPE;
};

template<size_t I, class... Types>
struct variant_alternative<I, const variant<Types...>> {
    using type = CPPREFERENCE_SIMPLIFIED_TYPE;
};

template<size_t I, class... Types>
struct variant_alternative<I, volatile variant<Types...>> {
    using type = CPPREFERENCE_SIMPLIFIED_TYPE;
};

template<size_t I, class... Types>
struct variant_alternative<I, const volatile variant<Types...>> {
    using type = CPPREFERENCE_SIMPLIFIED_TYPE;
};

template <size_t I, class T>
using variant_alternative_t = typename variant_alternative<I, T>::type;


template<class... Types>
class variant {
public:
    constexpr variant();

    constexpr variant(const variant& other);

    constexpr variant(variant&& other);

    template<class T>
    constexpr variant(T&& t);

    template<class T, class... Args>
    constexpr explicit variant(in_place_type_t<T>, Args&&... args);

    template<class T, class U, class... Args>

    constexpr explicit variant(in_place_type_t<T>,
                               initializer_list<U> il, Args&&... args);

    template<size_t I, class... Args>
    constexpr explicit variant(in_place_index_t<I>, Args&&... args);

    template<size_t I, class U, class... Args>
    constexpr explicit variant(in_place_index_t<I>,
                               initializer_list<U> il, Args&&... args);

    ~variant();

    constexpr variant& operator=(const variant& rhs);

    constexpr variant& operator=(variant&& rhs);

    template<class T>
    variant& operator=(T&& t);

    constexpr size_t index() const;

    constexpr bool valueless_by_exception() const;

    template <class T, class... Args>
    T& emplace(Args&&... args);

    template <class T, class U, class... Args>
    T& emplace(initializer_list<U> il, Args&&... args);

    template <size_t I, class... Args>
    variant_alternative_t<I, variant>& emplace(Args&&... args);

    template <size_t I, class U, class... Args>
    variant_alternative_t<I, variant>&
        emplace(initializer_list<U> il, Args&&... args);

    void swap(variant& rhs);
};

template<class... Types>
constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);

template<class... Types>
constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);

template<class... Types>
constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);

template<class... Types>
constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);

template<class... Types>
constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);

template<class... Types>
constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);

template <class... Types>
void swap(variant<Types...>& lhs, variant<Types...>& rhs);

template<class Visitor, class... Variants>
constexpr CPPREFERENCE_SIMPLIFIED_TYPE visit(Visitor&& vis, Variants&&... vars);

template <class R, class Visitor, class... Variants>
constexpr R visit(Visitor&&, Variants&&...);

template <class T, class... Types>
constexpr bool holds_alternative(const variant<Types...>& v);

template<size_t I, class... Types>
constexpr variant_alternative_t<I, variant<Types...>>&
    get(variant<Types...>& v);

template<size_t I, class... Types>
constexpr variant_alternative_t<I, variant<Types...>>&&
    get(variant<Types...>&& v);

template<size_t I, class... Types>
constexpr const variant_alternative_t<I, variant<Types...>>&
    get(const variant<Types...>& v);

template<size_t I, class... Types>
constexpr const variant_alternative_t<I, variant<Types...>>&
    get(const variant<Types...>&& v);

template<class T, class... Types>
constexpr T& get(variant<Types...>& v);

template<class T, class... Types>
constexpr T&& get(variant<Types...>&& v);

template<class T, class... Types>
constexpr const T& get(const variant<Types...>& v);

template<class T, class... Types>
constexpr const T&& get(const variant<Types...>&& v);

template <size_t I, class... Types>

constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
     get_if(variant<Types...>* pv);

template <size_t I, class... Types>
constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
    get_if(const variant<Types...>* pv);

template <class T, class... Types>
constexpr add_pointer_t<T> get_if(variant<Types...>* pv);
template <class T, class... Types>
constexpr add_pointer_t<const T> get_if(const variant<Types...>* pv);

template<class T>
struct variant_size; // undefined

template<class... Types>
struct variant_size<variant<Types...>> :
        integral_constant<size_t, sizeof...(Types)> {
};

template<class... Types>
struct variant_size<const variant<Types...>> :
        integral_constant<size_t, sizeof...(Types)> {
};

template<class... Types>
struct variant_size<volatile variant<Types...>> :
        integral_constant<size_t, sizeof...(Types)> {
};

template<class... Types>
struct variant_size<const volatile variant<Types...>> :
        integral_constant<size_t, sizeof...(Types)> {
};


template <class... Types>
struct hash<variant<Types...>> {};

} // namespace std

#endif // CPPREFERENCE_STDVER >= 2017
#endif // CPPREFERENCE_VARIANT_H