sol::tie_t< Tn > Struct Template Reference

#include <sol.hpp>

Inheritance diagram for sol::tie_t< Tn >:

Public Member Functions
template<typename T >
tie_t &	operator= (T &&value)

Private Types
typedef std::tuple< std::add_lvalue_reference_t< Tn >... >	base_t

Private Member Functions
template<typename T >
void	set (std::false_type, T &&target)
template<typename T >
void	set (std::true_type, T &&target)
template<std::size_t... I, typename T >
void	set_extra (std::true_type, std::index_sequence< I... >, T &&target)
template<std::size_t... I, typename T >
void	set_extra (std::false_type, std::index_sequence< I... >, T &&target)

Member Typedef Documentation

base_t

template<typename... Tn>

typedef std::tuple<std::add_lvalue_reference_t<Tn>...> sol::tie_t< Tn >::base_t

private

Member Function Documentation

operator=()

template<typename... Tn>

template<typename T >

tie_t& sol::tie_t< Tn >::operator= ( T &&  value )

inline

                                    {
            typedef is_tieable<meta::unqualified_t<T>> tieable;
            set(tieable(), std::forward<T>(value));
            return *this;
        }

set() [1/2]

template<typename... Tn>

template<typename T >

void sol::tie_t< Tn >::set ( std::false_type  , T &&  target  )

inlineprivate

                                            {
            std::get<0>(*this) = std::forward<T>(target);
        }

set() [2/2]

template<typename... Tn>

template<typename T >

void sol::tie_t< Tn >::set ( std::true_type  , T &&  target  )

inlineprivate

                                           {
            typedef tie_size<meta::unqualified_t<T>> value_size;
            typedef tie_size<std::tuple<Tn...>> tie_size;
            typedef std::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
            typedef std::make_index_sequence<indices_size::value> indices;
            set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
        }

set_extra() [1/2]

template<typename... Tn>

template<std::size_t... I, typename T >

void sol::tie_t< Tn >::set_extra ( std::true_type  , std::index_sequence< I... >  , T &&  target  )

inlineprivate

                                                                          {
            using std::get;
            (void)detail::swallow{0,
                (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0};
        }

set_extra() [2/2]

template<typename... Tn>

template<std::size_t... I, typename T >

void sol::tie_t< Tn >::set_extra ( std::false_type  , std::index_sequence< I... >  , T &&  target  )

inlineprivate

                                                                           {
            using std::get;
            (void)detail::swallow{0,
                (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0};
        }

---

The documentation for this struct was generated from the following file:

• external/sol.hpp