as.h

Go to the documentation of this file.

 
#pragma once
#include <any>
#include <memory>
#include "convert.h"
#include "convert_pointer.h"
#include "convert_string.h"
#include "invalid_cast_exception.h"
#include "types.h"
 
namespace xtd {
  // ___________________________________________________________________________________________
  //                                                                                     generic
 
  template<typename new_type_t>
  new_type_t as(std::any value) {
    try {
      return any_cast<new_type_t>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
  }
  
  template<typename new_type_t>
  new_type_t as(bool value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(byte_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char8_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char16_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char32_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(wchar_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(decimal_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(double value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(float value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(int16_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(int32_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(int64_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(llong_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(sbyte_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint16_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint32_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint64_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(ullong_t value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const xtd::ustring& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
  
  template<typename new_type_t>
  new_type_t as(xtd::ustring& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const xtd::ustring& value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(byte_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(int16_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(int32_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(int64_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(llong_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(sbyte_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(uint16_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(uint32_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(uint64_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
  template<typename new_type_t>
  new_type_t as(ullong_t value, byte_t from_base) {
    throw invalid_cast_exception(csf_);
  }
 
  template<typename new_type_t>
  new_type_t as(const std::string& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(std::string& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const std::u8string& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(std::u8string& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const std::u16string& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(std::u16string& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const std::u32string& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(std::u32string& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const std::wstring& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(std::wstring& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what(), csf_);
    }
    throw std::bad_cast();
  }
 
  template<typename new_type_t>
  new_type_t as(const char* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const char8_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char8_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const char16_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char16_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const char32_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char32_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const wchar_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(wchar_t* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  // ___________________________________________________________________________________________
  //                                                                 xtd::convert specialization
  
  template<>
  inline bool as<bool>(std::any value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(bool value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(byte_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char8_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char16_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char32_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(wchar_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(decimal_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(double value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(float value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(int16_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(int32_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(int64_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(llong_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(sbyte_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(uint16_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(uint32_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(uint64_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(ullong_t value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const xtd::ustring& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const std::string& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const std::u8string& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const std::u16string& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const std::u32string& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const std::wstring& value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const char* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const char8_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char8_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const char16_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char16_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const char32_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(char32_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(const wchar_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline bool as<bool>(wchar_t* value) {
    return xtd::convert::to_boolean(value);
  }
  
  template<>
  inline byte_t as<byte_t>(std::any value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(bool value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(byte_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char8_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char16_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char32_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(wchar_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(decimal_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(double value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(float value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(int16_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(int32_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(int64_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(llong_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(sbyte_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(uint16_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(uint32_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(uint64_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(ullong_t value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const xtd::ustring& value) {
    return xtd::convert::to_byte(value);
  }
 
  template<>
  inline byte_t as<byte_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_byte(value, from_base);
  }
 
  template<>
  inline byte_t as<byte_t>(const std::string& value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const std::u8string& value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const std::u16string& value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const std::u32string& value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const std::wstring& value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const char* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const char8_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char8_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const char16_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char16_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const char32_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(char32_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(const wchar_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline byte_t as<byte_t>(wchar_t* value) {
    return xtd::convert::to_byte(value);
  }
  
  template<>
  inline char as<char>(std::any value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(bool value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(byte_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char8_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char16_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char32_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(wchar_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(decimal_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(double value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(float value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(int16_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(int32_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(int64_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(llong_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(sbyte_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(uint16_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(uint32_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(uint64_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(ullong_t value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const xtd::ustring& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const std::string& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const std::u8string& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const std::u16string& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const std::u32string& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const std::wstring& value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const char* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const char8_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char8_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const char16_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char16_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const char32_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(char32_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(const wchar_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char as<char>(wchar_t* value) {
    return xtd::convert::to_char(value);
  }
  
  template<>
  inline char8_t as<char8_t>(std::any value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(bool value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(byte_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char8_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char16_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char32_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(wchar_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(decimal_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(double value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(float value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(int16_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(int32_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(int64_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(llong_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(sbyte_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(uint16_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(uint32_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(uint64_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(ullong_t value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const xtd::ustring& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const std::string& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const std::u8string& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const std::u16string& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const std::u32string& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const std::wstring& value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const char* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const char8_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char8_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const char16_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char16_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const char32_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(char32_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(const wchar_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char8_t as<char8_t>(wchar_t* value) {
    return xtd::convert::to_char8(value);
  }
  
  template<>
  inline char16_t as<char16_t>(std::any value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(bool value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(byte_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char8_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char16_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char32_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(wchar_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(decimal_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(double value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(float value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(int16_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(int32_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(int64_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(llong_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(sbyte_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(uint16_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(uint32_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(uint64_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(ullong_t value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const xtd::ustring& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const std::string& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const std::u8string& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const std::u16string& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const std::u32string& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const std::wstring& value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const char* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const char8_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char8_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const char16_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char16_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const char32_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(char32_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(const wchar_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char16_t as<char16_t>(wchar_t* value) {
    return xtd::convert::to_char16(value);
  }
  
  template<>
  inline char32_t as<char32_t>(std::any value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(bool value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(byte_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char8_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char16_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char32_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(wchar_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(decimal_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(double value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(float value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(int16_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(int32_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(int64_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(llong_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(sbyte_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(uint16_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(uint32_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(uint64_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(ullong_t value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const xtd::ustring& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const std::string& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const std::u8string& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const std::u16string& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const std::u32string& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const std::wstring& value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const char* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const char8_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char8_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const char16_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char16_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const char32_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(char32_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(const wchar_t* value) {
    return xtd::convert::to_char32(value);
  }
  
  template<>
  inline char32_t as<char32_t>(wchar_t* value) {
    return xtd::convert::to_char32(value);
  }
 
  template<>
  inline wchar_t as<wchar_t>(std::any value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(bool value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(byte_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char8_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char16_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char32_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(wchar_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(decimal_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(double value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(float value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(int16_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(int32_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(int64_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(llong_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(sbyte_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(uint16_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(uint32_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(uint64_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(ullong_t value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const xtd::ustring& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const std::string& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const std::u8string& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const std::u16string& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const std::u32string& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const std::wstring& value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const char* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const char8_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char8_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const char16_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char16_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const char32_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(char32_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(const wchar_t* value) {
    return xtd::convert::to_wchar(value);
  }
  
  template<>
  inline wchar_t as<wchar_t>(wchar_t* value) {
    return xtd::convert::to_wchar(value);
  }
 
  template<>
  inline decimal_t as<decimal_t>(std::any value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(bool value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(byte_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char8_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char16_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char32_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(wchar_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(decimal_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(double value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(float value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(int16_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(int32_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(int64_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(llong_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(sbyte_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(uint16_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(uint32_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(uint64_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(ullong_t value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const xtd::ustring& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const std::string& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const std::u8string& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const std::u16string& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const std::u32string& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const std::wstring& value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const char* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const char8_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char8_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const char16_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char16_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const char32_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(char32_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(const wchar_t* value) {
    return xtd::convert::to_decimal(value);
  }
  
  template<>
  inline decimal_t as<decimal_t>(wchar_t* value) {
    return xtd::convert::to_decimal(value);
  }
 
  template<>
  inline double as<double>(std::any value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(bool value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(byte_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char8_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char16_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char32_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(wchar_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(decimal_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(double value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(float value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(int16_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(int32_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(int64_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(llong_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(sbyte_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(uint16_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(uint32_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(uint64_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(ullong_t value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const xtd::ustring& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const std::string& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const std::u8string& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const std::u16string& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const std::u32string& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const std::wstring& value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const char* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const char8_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char8_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const char16_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char16_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const char32_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(char32_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(const wchar_t* value) {
    return xtd::convert::to_double(value);
  }
  
  template<>
  inline double as<double>(wchar_t* value) {
    return xtd::convert::to_double(value);
  }
 
  template<>
  inline float as<float>(std::any value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(bool value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(byte_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char8_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char16_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char32_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(wchar_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(decimal_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(double value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(float value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(int16_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(int32_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(int64_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(llong_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(sbyte_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(uint16_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(uint32_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(uint64_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(ullong_t value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const xtd::ustring& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const std::string& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const std::u8string& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const std::u16string& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const std::u32string& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const std::wstring& value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const char* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const char8_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char8_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const char16_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char16_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const char32_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(char32_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(const wchar_t* value) {
    return xtd::convert::to_single(value);
  }
  
  template<>
  inline float as<float>(wchar_t* value) {
    return xtd::convert::to_single(value);
  }
 
  template<>
  inline int16_t as<int16_t>(std::any value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(bool value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(byte_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char8_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char16_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char32_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(wchar_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(decimal_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(double value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(float value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(int16_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(int32_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(int64_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(llong_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(sbyte_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(uint16_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(uint32_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(uint64_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(ullong_t value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const xtd::ustring& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_int16(value, from_base);
  }
 
  template<>
  inline int16_t as<int16_t>(const std::string& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const std::u8string& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const std::u16string& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const std::u32string& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const std::wstring& value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const char* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const char8_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char8_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const char16_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char16_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const char32_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(char32_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(const wchar_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int16_t as<int16_t>(wchar_t* value) {
    return xtd::convert::to_int16(value);
  }
  
  template<>
  inline int32_t as<int32_t>(std::any value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(bool value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(byte_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char8_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char16_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char32_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(wchar_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(decimal_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(double value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(float value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(int16_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(int32_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(int64_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(llong_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(sbyte_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(uint16_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(uint32_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(uint64_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(ullong_t value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const xtd::ustring& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_int32(value, from_base);
  }
 
  template<>
  inline int32_t as<int32_t>(const std::string& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const std::u8string& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const std::u16string& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const std::u32string& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const std::wstring& value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const char* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const char8_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char8_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const char16_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char16_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const char32_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(char32_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(const wchar_t* value) {
    return xtd::convert::to_int32(value);
  }
  
  template<>
  inline int32_t as<int32_t>(wchar_t* value) {
    return xtd::convert::to_int32(value);
  }
 
  template<>
  inline int64_t as<int64_t>(std::any value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(bool value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(byte_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char8_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char16_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char32_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(wchar_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(decimal_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(double value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(float value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(int16_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(int32_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(int64_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(llong_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(sbyte_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(uint16_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(uint32_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(uint64_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(ullong_t value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const xtd::ustring& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_int64(value, from_base);
  }
 
  template<>
  inline int64_t as<int64_t>(const std::string& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const std::u8string& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const std::u16string& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const std::u32string& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const std::wstring& value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const char* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const char8_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char8_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const char16_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char16_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const char32_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(char32_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(const wchar_t* value) {
    return xtd::convert::to_int64(value);
  }
  
  template<>
  inline int64_t as<int64_t>(wchar_t* value) {
    return xtd::convert::to_int64(value);
  }
 
  template<>
  inline llong_t as<llong_t>(std::any value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(bool value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(byte_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char8_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char16_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char32_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(wchar_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(decimal_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(double value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(float value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(int16_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(int32_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(int64_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(llong_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(sbyte_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(uint16_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(uint32_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(uint64_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(ullong_t value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const xtd::ustring& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_llong(value, from_base);
  }
 
  template<>
  inline llong_t as<llong_t>(const std::string& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const std::u8string& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const std::u16string& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const std::u32string& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const std::wstring& value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const char* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const char8_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char8_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const char16_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char16_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const char32_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(char32_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(const wchar_t* value) {
    return xtd::convert::to_llong(value);
  }
  
  template<>
  inline llong_t as<llong_t>(wchar_t* value) {
    return xtd::convert::to_llong(value);
  }
 
  template<>
  inline sbyte_t as<sbyte_t>(std::any value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(bool value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(byte_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char8_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char16_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char32_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(wchar_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(decimal_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(double value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(float value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(int16_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(int32_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(int64_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(llong_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(sbyte_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(uint16_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(uint32_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(uint64_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(ullong_t value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const xtd::ustring& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_sbyte(value, from_base);
  }
 
  template<>
  inline sbyte_t as<sbyte_t>(const std::string& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const std::u8string& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const std::u16string& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const std::u32string& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const std::wstring& value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const char* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const char8_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char8_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const char16_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char16_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const char32_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(char32_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(const wchar_t* value) {
    return xtd::convert::to_sbyte(value);
  }
  
  template<>
  inline sbyte_t as<sbyte_t>(wchar_t* value) {
    return xtd::convert::to_sbyte(value);
  }
 
  template<>
  inline uint16_t as<uint16_t>(std::any value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(bool value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(byte_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char8_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char16_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char32_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(wchar_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(decimal_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(double value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(float value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(int16_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(int32_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(int64_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(llong_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(sbyte_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(uint16_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(uint32_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(uint64_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(ullong_t value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const xtd::ustring& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_uint16(value, from_base);
  }
 
  template<>
  inline uint16_t as<uint16_t>(const std::string& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const std::u8string& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const std::u16string& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const std::u32string& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const std::wstring& value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const char* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const char8_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char8_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const char16_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char16_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const char32_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(char32_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(const wchar_t* value) {
    return xtd::convert::to_uint16(value);
  }
  
  template<>
  inline uint16_t as<uint16_t>(wchar_t* value) {
    return xtd::convert::to_uint16(value);
  }
 
  template<>
  inline uint32_t as<uint32_t>(std::any value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(bool value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(byte_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char8_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char16_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char32_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(wchar_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(decimal_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(double value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(float value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(int16_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(int32_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(int64_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(llong_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(sbyte_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(uint16_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(uint32_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(uint64_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(ullong_t value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const xtd::ustring& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_uint32(value, from_base);
  }
 
  template<>
  inline uint32_t as<uint32_t>(const std::string& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const std::u8string& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const std::u16string& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const std::u32string& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const std::wstring& value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const char* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const char8_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char8_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const char16_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char16_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const char32_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(char32_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(const wchar_t* value) {
    return xtd::convert::to_uint32(value);
  }
  
  template<>
  inline uint32_t as<uint32_t>(wchar_t* value) {
    return xtd::convert::to_uint32(value);
  }
 
  template<>
  inline uint64_t as<uint64_t>(std::any value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(bool value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(byte_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char8_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char16_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char32_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(wchar_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(decimal_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(double value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(float value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(int16_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(int32_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(int64_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(llong_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(sbyte_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(uint16_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(uint32_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(uint64_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(ullong_t value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const xtd::ustring& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_uint64(value, from_base);
  }
 
  template<>
  inline uint64_t as<uint64_t>(const std::string& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const std::u8string& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const std::u16string& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const std::u32string& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const std::wstring& value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const char* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const char8_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char8_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const char16_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char16_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const char32_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(char32_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(const wchar_t* value) {
    return xtd::convert::to_uint64(value);
  }
  
  template<>
  inline uint64_t as<uint64_t>(wchar_t* value) {
    return xtd::convert::to_uint64(value);
  }
 
  template<>
  inline ullong_t as<ullong_t>(std::any value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(bool value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(byte_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char8_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char16_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char32_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(wchar_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(decimal_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(double value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(float value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(int16_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(int32_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(int64_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(llong_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(sbyte_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(uint16_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(uint32_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(uint64_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(ullong_t value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const xtd::ustring& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const xtd::ustring& value, byte_t from_base) {
    return xtd::convert::to_ullong(value, from_base);
  }
 
  template<>
  inline ullong_t as<ullong_t>(const std::string& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const std::u8string& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const std::u16string& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const std::u32string& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const std::wstring& value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const char* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const char8_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char8_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const char16_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char16_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const char32_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(char32_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(const wchar_t* value) {
    return xtd::convert::to_ullong(value);
  }
  
  template<>
  inline ullong_t as<ullong_t>(wchar_t* value) {
    return xtd::convert::to_ullong(value);
  }
 
  template<>
  inline ustring as<ustring>(std::any value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(bool value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(byte_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(byte_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(char value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(char8_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(char16_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(char32_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(wchar_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(decimal_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(double value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(float value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(int16_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(int16_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(int32_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(int32_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(int64_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(int64_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(llong_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(llong_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(sbyte_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(sbyte_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(uint16_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(uint16_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(uint32_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(uint32_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(uint64_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(uint64_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  template<>
  inline ustring as<ustring>(ullong_t value) {
    return xtd::convert::to_string(value);
  }
  
  template<>
  inline ustring as<ustring>(ullong_t value, byte_t from_base) {
    return xtd::convert::to_string(value, from_base);
  }
 
  // ___________________________________________________________________________________________
  //                                                         xtd::convert_pointer specialization
  
  template<typename new_type_t, typename current_type_t>
  const new_type_t& as(const current_type_t& value) {
    return xtd::convert_pointer::to_ref<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  new_type_t& as(current_type_t& value) {
    return xtd::convert_pointer::to_ref<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  const new_type_t* as(const current_type_t* value) {
    return xtd::convert_pointer::to_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  new_type_t* as(current_type_t* value) {
    return xtd::convert_pointer::to_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  std::unique_ptr<new_type_t> as(std::unique_ptr<current_type_t>& value) {
    return xtd::convert_pointer::to_unique_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  std::unique_ptr<new_type_t> as(std::unique_ptr<current_type_t>&& value) {
    return xtd::convert_pointer::to_unique_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  std::shared_ptr<new_type_t> as(const std::shared_ptr<current_type_t>& value) {
    return xtd::convert_pointer::to_shared_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  std::shared_ptr<new_type_t> as(std::shared_ptr<current_type_t>& value) {
    return xtd::convert_pointer::to_shared_ptr<new_type_t>(value);
  }
  
  template<typename new_type_t, typename current_type_t>
  std::shared_ptr<new_type_t> as(std::shared_ptr<current_type_t>&& value) {
    return xtd::convert_pointer::to_shared_ptr<new_type_t>(value);
  }
 
  // ___________________________________________________________________________________________
  //                                                          xtd::convert_string specialization
  
  template<>
  inline std::string as<std::string>(const std::string& value) {
    return xtd::convert_string::to_string(value);
  }
  template<>
  inline std::string as<std::string>(std::string& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const std::string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(std::string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const std::string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(std::string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const std::string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(std::string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const std::string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(std::string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const std::string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(std::string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const char* value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const char* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(const char* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(const char* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(const char* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(const char* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(char* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(char* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(char* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(char* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(char* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(char* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(const xtd::ustring& value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline std::string as<std::string>(xtd::ustring& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const xtd::ustring& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(xtd::ustring& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const xtd::ustring& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(xtd::ustring& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const xtd::ustring& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(xtd::ustring& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const xtd::ustring& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(xtd::ustring& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const xtd::ustring& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(xtd::ustring& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const std::u8string& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline std::string as<std::string>(std::u8string& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const std::u8string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(std::u8string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const std::u8string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(std::u8string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const std::u8string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(std::u8string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const std::u8string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(std::u8string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const std::u8string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(std::u8string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const char8_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(const char8_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(const char8_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(const char8_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(const char8_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(const char8_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(char8_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(char8_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(char8_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(char8_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(char8_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(char8_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(const std::u16string& value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline std::string as<std::string>(std::u16string& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const std::u16string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(std::u16string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const std::u16string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(std::u16string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const std::u16string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(std::u16string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const std::u16string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(std::u16string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const std::u16string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(std::u16string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const char16_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(const char16_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(const char16_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(const char16_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(const char16_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(const char16_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(char16_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(char16_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(char16_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(char16_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(char16_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(char16_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(const std::u32string& value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline std::string as<std::string>(std::u32string& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const std::u32string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(std::u32string& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const std::u32string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(std::u32string& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const std::u32string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(std::u32string& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const std::u32string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(std::u32string& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const std::u32string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(std::u32string& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const char32_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(const char32_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(const char32_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(const char32_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(const char32_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(const char32_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(char32_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(char32_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(char32_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(char32_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(char32_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(char32_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(const std::wstring& value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline std::string as<std::string>(std::wstring& value) {
    return xtd::convert_string::to_string(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(const std::wstring& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline xtd::ustring as<xtd::ustring>(std::wstring& value) {
    return xtd::convert_string::to_ustring(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(const std::wstring& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u8string as<std::u8string>(std::wstring& value) {
    return xtd::convert_string::to_u8string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(const std::wstring& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u16string as<std::u16string>(std::wstring& value) {
    return xtd::convert_string::to_u16string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(const std::wstring& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::u32string as<std::u32string>(std::wstring& value) {
    return xtd::convert_string::to_u32string(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(const std::wstring& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::wstring as<std::wstring>(std::wstring& value) {
    return xtd::convert_string::to_wstring(value);
  }
 
  template<>
  inline std::string as<std::string>(const wchar_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(const wchar_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(const wchar_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(const wchar_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(const wchar_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(const wchar_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
  
  template<>
  inline std::string as<std::string>(wchar_t* value) {
    return xtd::convert_string::to_string(value);
  }
  
  template<>
  inline xtd::ustring as<xtd::ustring>(wchar_t* value) {
    return xtd::convert_string::to_ustring(value);
  }
  
  template<>
  inline std::u8string as<std::u8string>(wchar_t* value) {
    return xtd::convert_string::to_u8string(value);
  }
  
  template<>
  inline std::u16string as<std::u16string>(wchar_t* value) {
    return xtd::convert_string::to_u16string(value);
  }
  
  template<>
  inline std::u32string as<std::u32string>(wchar_t* value) {
    return xtd::convert_string::to_u32string(value);
  }
  
  template<>
  inline std::wstring as<std::wstring>(wchar_t* value) {
    return xtd::convert_string::to_wstring(value);
  }
}