/__w/eve/eve/include/eve/traits/as_translation.hpp

Translates an as type wrapper to a type wrapper of its translated type.

Translates an as type wrapper to a type wrapper of its translated type.

Template Parameters

V	The wrapper type to translate

Returns

Type tag for the translated type

enum class E: int { };
eve::as<E> tag;
static_assert(std::same_as<decltype(eve::translate(tag)), eve::as<int>>);

//==================================================================================================
/*
  EVE - Expressive Vector Engine
  Copyright : EVE Project Contributors
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once
 
#include <eve/concept/translation.hpp>
#include <eve/detail/wide_forward.hpp>
#include <eve/memory/pointer.hpp>
#include <eve/traits/value_type.hpp>
#include <eve/traits/pointer.hpp>
 
#include <bit>
#include <new>
 
namespace eve
{
  //================================================================================================
  //================================================================================================
  template <typename V>
  constexpr translate_t<V> translate(V const& val)
  {
    if constexpr (has_plain_translation<element_type_t<V>>) return std::bit_cast<translate_t<V>>(val);
    else                                                    return val;
  }
 
  //================================================================================================
  //================================================================================================
  template <typename T, size_t N>
  constexpr std::array<translate_t<T>, N> translate(std::array<T, N> val)
  {
    if constexpr (has_plain_translation<element_type_t<T>>) return std::bit_cast<std::array<translate_t<T>, N>>(val);
    else                                                    return val;
  }
 
  //================================================================================================
  //================================================================================================
  template <typename V>
  constexpr translate_t<V>& translate(V& val)
  {
    return reinterpret_cast<translate_t<V>&>(val);
  }
 
  //================================================================================================
  //================================================================================================
  template <typename V>
  constexpr auto translate(as<V>)
  {
    return as<translate_t<V>>{};
  }
 
  //================================================================================================
  //================================================================================================
  template <detail::scalar_pointer Ptr>
  constexpr auto translate_ptr(Ptr ptr)
  {
    if constexpr (has_plain_translation<value_type_t<Ptr>>)
    {
      using trans_t = detail::copy_qualifiers_t<translated_value_type_t<Ptr>, Ptr>;
 
      if constexpr (std::is_pointer_v<Ptr>)
      {
        return std::launder(reinterpret_cast<trans_t*>(ptr));
      }
      else
      {
        return std::bit_cast<typename Ptr::template rebind<trans_t>>(ptr);
      }
    }
    else
    {
      return ptr;
    }
  }
 
  //================================================================================================
  //================================================================================================
  template <typename Dst, translatable_into<Dst> Src>
  constexpr Dst translate_into(Src const& val, as<Dst>)
  {
    return std::bit_cast<Dst>(val);
  }
}