Корректен ли каст из string в wstring?

template< typename char_type >
string_t<char_type> make_string( const string_t<reverse_char_t<char_type>>& str )
{
    string_t<char_type> ret;
    for( auto it : str )
    {
        ret.push_back( it );
    }
    return ret;
}
 
template< typename char_type >
string_t<char_type> make_string( const string_t<char_type>& str )
{
    return str;
}

std::wstring StrToWstr(const std::string &aString)
{
    // чтобы не делать каждый раз new создадим некоторый буфер заранее
    const int maxSize = 1024 * 1024; // 1Мб символов
    static wchar_t buff[maxSize]; 
 
    int nSize = ::MultiByteToWideChar(CP_UTF8, 0, aString.c_str(), static_cast<int>(aString.length() + 1), NULL, NULL);
 
    wchar_t *tBuff = buff;
    if (nSize > maxSize )
    {
        // пытаемся выделить память только если не хватило
        tBuff = new wchar_t[nSize];
    }
    if (nSize <= 0 && tBuff == NULL)
        return L"";
        
    ::MultiByteToWideChar(CP_UTF8, 0, aString.c_str(), static_cast<int>(aString.length() + 1), buff, nSize);
        
    std::wstring result(tBuff);
 
    if (tBuff != buff )
        delete[] tBuff;
 
    return result;
}

std::string ws2s(const std::wstring& wstr, const std::locale& loc)
{
    if (wstr.empty())
        return std::string();
 
    typedef std::wstring::traits_type::state_type state_type;
    typedef std::codecvt<wchar_t, char, state_type> convert;
    
    const convert& cvt = std::use_facet<convert>(loc);
    std::string str(cvt.max_length()*wstr.size(), '\0');
    state_type state = state_type();
 
    const wchar_t* from_beg = &wstr[0];
    const wchar_t* from_end = from_beg + wstr.size();
    const wchar_t* from_nxt;
    char* to_beg = &str[0];
    char* to_end = to_beg + str.size();
    char* to_nxt;
    
    std::string::size_type sz = 0;
    std::codecvt_base::result r;
    do
    {
        r = cvt.out(state, from_beg, from_end, from_nxt,
                           to_beg,   to_end,   to_nxt);
        switch (r)
        {
        case std::codecvt_base::error:
            throw std::runtime_error("error converting wstring to string");
 
        case std::codecvt_base::partial:
            sz += to_nxt - to_beg;
            str.resize(2*str.size());
            to_beg = &str[sz];
            to_end = &str[0] + str.size();
            break;
 
        case std::codecvt_base::noconv:
            str.resize(sz + (from_end-from_beg)*sizeof(wchar_t));
            std::memcpy(&str[sz], from_beg,(from_end-from_beg)*sizeof(wchar_t));
            r = std::codecvt_base::ok;
            break;
 
        case std::codecvt_base::ok:
            sz += to_nxt - to_beg;
            str.resize(sz);
            break;
        }
    } while (r != std::codecvt_base::ok);
 
    return str;
}

std::wstring s2ws(const std::string& str, const std::locale& loc)
{
    if (str.empty())
        return std::wstring();
 
    typedef std::string::traits_type::state_type state_type;
    typedef std::codecvt<wchar_t, char, state_type> convert;
    const convert& cvt = std::use_facet<convert>(loc);
    std::wstring wstr(str.size(), '\0');
    state_type state = state_type();
    const char* from_beg = &str[0];
    const char* from_end = from_beg + str.size();
    const char* from_nxt;
    wchar_t* to_beg = &wstr[0];
    wchar_t* to_end = to_beg + wstr.size();
    wchar_t* to_nxt;
    std::wstring::size_type sz = 0;
    std::codecvt_base::result r;
    do
    {
        r = cvt.in(state, from_beg, from_end, from_nxt,
                          to_beg,   to_end,   to_nxt);
        switch (r)
        {
        case std::codecvt_base::error:
            throw std::runtime_error("error converting string to wstring");
        case std::codecvt_base::partial:
            sz += to_nxt - to_beg;
            wstr.resize(2*wstr.size());
            to_beg = &wstr[sz];
            to_end = &wstr[0] + wstr.size();
            break;
        case std::codecvt_base::noconv:
            wstr.resize(sz + (from_end-from_beg));
            std::memcpy(&wstr[sz], from_beg, (std::size_t)(from_end-from_beg));
            r = std::codecvt_base::ok;
            break;
        case std::codecvt_base::ok:
            sz += to_nxt - to_beg;
            wstr.resize(sz);
            break;
        }
    } while (r != std::codecvt_base::ok);
 
   return wstr;
}

template<class Facet>
struct deletable_facet : Facet
{
    template<class... Args>
    deletable_facet( Args&&... args ) 
                : Facet( std::forward<Args>(args)... ) {}
    ~deletable_facet() {}
};
...
std::wstring s2ws( std::string str )
{
    std::wstring ret = 
        std::wstring_convert<
            deletable_facet<std::codecvt<wchar_t, char, std::mbstate_t>>
                            >{}.from_bytes( str );
    return ret;
}

std::string ws2s( std::wstring str )
{
    std::string ret = 
        std::wstring_convert<std::codecvt_utf8<wchar_t>>{}.to_bytes( str );
    return ret;
}

std::string s = "Eniki beniki eli vareniki";
std::wstring ws(s.begin(), s.end());
std::string s2(ws.begin(), ws.end());

#include <string>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
struct my_char_traits : std::char_traits<char>
{
    //-----------------------------------------------------------------------------------
    static bool eq( const char_type a, const char_type b )
    {
        return std::tolower( a ) == std::tolower( b );
    }
    //-----------------------------------------------------------------------------------
    static bool lt( const char_type a, const char_type b )
    {
        return std::tolower( a ) <  std::tolower( b );
    }
    //-----------------------------------------------------------------------------------
    static int compare( const char_type* str1, const char* str2, size_t count )
    {
        for ( size_t it{}; it < count; ++it )
            if (lt( std::tolower( str1[it] ), std::tolower( str2[it] ) ) )
                return -1;
            else if ( lt( std::tolower( str2[it] ), std::tolower( str1[it] ) ) )
                return 1;
      return 0;
    }
    //-----------------------------------------------------------------------------------
    static const char_type* find( const char_type* str, size_t count, const char_type ch )
    {
        for( size_t it{}; it < count; ++it )
        {
            if( eq( std::tolower( str[it] ), std::tolower( ch ) ) )
            {
                return str + it;
            }
        }
        return nullptr;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
using my_string = std::basic_string<char, my_char_traits>;
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    my_string str1 = "Hello";
    my_string str2 = "hELLO";
    std::cout << std::boolalpha << ( str1 == str2 ) << std::endl;
}