__as_generic.h

Go to the documentation of this file.

 
#pragma once
 
#if !defined(__XTD_CORE_INTERNAL__)
#error "Do not include this file: Internal use only"
#endif
 
#define __XTD_STD_INTERNAL__
#include "__xtd_std_version.h"
#undef __XTD_STD_INTERNAL__
 
namespace xtd {
  template<typename new_type_t>
  new_type_t as(std::any value) {
    try {
      return std::any_cast<new_type_t>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what());
    }
  }
  
  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(xtd::byte 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);
  }
  
#if defined(__xtd__cpp_lib_char8_t)
  template<typename new_type_t>
  new_type_t as(char8 value) {
    return static_cast<new_type_t>(value);
  }
#endif
  
  template<typename new_type_t>
  new_type_t as(char16 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char32 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(wchar value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(decimal 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 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(int32 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(int64 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(slong value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(sbyte value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint16 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint32 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(uint64 value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(xtd::ulong value) {
    return static_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const xtd::string& value) {
    try {
      return dynamic_cast<const new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what());
    }
    throw std::bad_cast();
  }
  
  template<typename new_type_t>
  new_type_t as(xtd::string& value) {
    try {
      return dynamic_cast<new_type_t&>(value);
    } catch (const std::exception& e) {
      throw invalid_cast_exception(e.what());
    }
    throw std::bad_cast();
  }
  
  template<typename new_type_t>
  new_type_t as(const xtd::string& value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(xtd::byte value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(int16 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(int32 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(int64 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(slong value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(sbyte value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(uint16 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(uint32 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(uint64 value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  template<typename new_type_t>
  new_type_t as(xtd::ulong value, xtd::byte from_base) {
    throw invalid_cast_exception {};
  }
  
  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());
    }
    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());
    }
    throw std::bad_cast();
  }
  
#if defined(__xtd__cpp_lib_char8_t)
  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());
    }
    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());
    }
    throw std::bad_cast();
  }
#endif
  
  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());
    }
    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());
    }
    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());
    }
    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());
    }
    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());
    }
    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());
    }
    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);
  }
  
#if defined(__xtd__cpp_lib_char8_t)
  template<typename new_type_t>
  new_type_t as(const char8* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char8* value) {
    return reinterpret_cast<new_type_t>(value);
  }
#endif
  
  template<typename new_type_t>
  new_type_t as(const char16* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char16* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const char32* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(char32* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(const wchar* value) {
    return reinterpret_cast<new_type_t>(value);
  }
  
  template<typename new_type_t>
  new_type_t as(wchar* value) {
    return reinterpret_cast<new_type_t>(value);
  }
}