posted by devcodex

@Charles Good job on the solo mission man, this was a great ep!

posted by devcodex

posted by devcodex

As you mentioned you're not dropping support for VC10, that's the toolset you want to use to target XP. For the product I'm working on the current plan is to switch to a maintenance support around the time Windows 8 arrives (much as XP is already in maintenance support only). New product versions will target newer versions of Windows. I mean seriously at some point there has to be a transition and lets be honest, there really aren't a whole lot of new features in VC11 that can't already be found in libraries such as Boost. It makes sense transition now and the above plan is a fairly painless one.

 @Raanen:You mention using LoadLibrary and make it sound like it's just going to take a few lines. How do you know that's all that's involved? If that really is the case then take a look again at what Jim said, specifically:

Note that sometimes, even if we don't officially support it, DLLs may load on an older OS or you may be able to statically link the CRT and avoid the new APIs or even implement your own version of the new API.

If using LoadLibrary or something along those lines is as simple as you say it is the above appears to me to be an invitation for you to make it happen. I'm interested to see if the above is possible and will be testing it myself, I will post back with any findings. Before you throw in the towel, especially for something you consider to be easy, lets try and see if there are working alternatives, albeit unofficially supported.

posted by devcodex

http://channel9.msdn.com/Forums/TechOff/A-question-on-XP-support-in-VC11

Charles, if the discussion gets moved there can you help us out and try and get someone to drop by and give a technical clarification for the decision? Thanks man, and keep up the great work on GoingNative.

posted by devcodex

Great job to the winners!

posted by devcodex

posted by devcodex

I'm inclined to agree with the decision to keep infinity=5 given how easy it is to regain previous functionality when needed. 

posted by devcodex

My other guess would be this is the first (of many) C++ events in 20(12): 112

Great episode!

posted by devcodex

I have registered for my seat for the show and I can't wait to get out there and meet all these great people who are putting it on!

@tgoodhew I'm loving Visual Studio 11 so far, I am running into an issue however that is making it difficult to port many of my existing projects over. While I understand variadic templates won't be making it into the initial release is there any chance that we can the current "infinity" for the faked variadic templates back to 10 from the current 5?

I ask because one particular dependency, googletest, makes use of tuples and currently breaks as it exceeds the limit of 5 elements (but does keep under the limit of 10).

Thanks again!

posted by devcodex

#include <cstdint>
#include <iostream>
#include <type_traits>

namespace anh {

    namespace detail {

        template<typename T>
        T swap_endian_(T value, std::integral_constant<size_t, 1>) {
            return value;
        }

        template<typename T>
        T swap_endian_(T value, std::integral_constant<size_t, 2>) {
            std::make_unsigned<T>::type& tmp = static_cast<std::make_unsigned<T>::type&>(value);
            tmp = (tmp >> 8) | (tmp << 8);

            return value;
        }
        
        template<typename T>
        T swap_endian_(T value, std::integral_constant<size_t, 4>) {
            std::make_unsigned<T>::type& tmp = static_cast<std::make_unsigned<T>::type&>(value);
            tmp = (tmp >> 24) |
                   ((tmp & 0x00FF0000) >> 8) | ((tmp & 0x0000FF00) << 8) |
                   (tmp << 24);

            return value;
        }
        
        template<typename T>
        T swap_endian_(T value, std::integral_constant<size_t, 8>) {
            std::make_unsigned<T>::type& tmp = static_cast<std::make_unsigned<T>::type&>(value);
            tmp = (tmp >> 56) |
                ((tmp & 0x00FF000000000000ULL) >> 40) |
                ((tmp & 0x0000FF0000000000ULL) >> 24) |
                ((tmp & 0x000000FF00000000ULL) >> 8)  |
                ((tmp & 0x00000000FF000000ULL) << 8)  |
                ((tmp & 0x0000000000FF0000ULL) << 24) |
                ((tmp & 0x000000000000FF00ULL) << 40) |
                (tmp  << 56);

            return value;
        }
    }

    /*! Swaps the endianness of integral values and returns the results.
    *
    * \param value An integral value for which to swap the endianness.
    * \return A copy of the input parameter with its endianness swapped.
    */
    template<typename T>
    T swap_endian(T value) {
        static_assert(std::is_integral<int>::value, "swap_endian<T> requires T to be an integral type.");
        return detail::swap_endian_<T>(value, std::integral_constant<size_t, sizeof(T)>());
    }

}  // namespace anh

using namespace std;

int main() {
    uint32_t test_uint_hostbyte = 0x00000002;
    uint32_t test_uint_netbyte = 0x02000000;

    uint32_t tmp_uint = anh::swap_endian(test_uint_hostbyte);

    if (tmp_uint == test_uint_netbyte) {
        cout << "Can swap 32-bit unsigned types\n";
    } else {
        cout << "Swapping 32-bit unsigned types failed\n";
    }

    int32_t test_int_hostbyte = 0xfffffff5;  // -11 on two's complement machines
    int32_t test_int_netbyte = 0xf5ffffff;

    if (tmp_uint == test_uint_netbyte) {
        cout << "Can swap 32-bit signed types\n";
    } else {
        cout << "Swapping 32-bit signed types failed\n";
    }

    return 0;
}

posted by devcodex

Thank you for the excellent feedback. In this particular case the Winsock htonl and similar functions to my knowledge don't work directly on 64-bit types, which is a need for several of the proprietary data packet formats that the project I'm currently working on deals with.

I am humbled again by just how much there is already provided with the STL and how much I still have to learn Thanks again!

posted by devcodex

This was another great episode and I'm looking forward to the new series! I've learned a great deal from the whole series and it's had a significant impact on the code I write. Thanks for all the effort you put into this!

I was just working on a bit of code necessary for converting endianness when dealing with integer types in network code. Having recently watched this episode and remembering your solution presented in episode 3 for containers I put together this solution, I'm sure it's not perfect but thanks to these shows I feel it's a much more robust and flexible solution than what I would have come up with in the past.

#include <cstdint>
#include <algorithm>
#include <iostream>
#include <limits>

namespace anh {

    namespace detail {
        /// @TODO Remove quotes from around constexpr when visual studio begins
        /// supporting that c++0x feature.
        /*constexpr*/ bool inline is_big_endian() {
            uint16_t x = 1;
            return !(*reinterpret_cast<char*>(&x));
        }

        struct bit8_tag{};
        struct bit16_tag{};
        struct bit32_tag{};
        struct bit64_tag{};

        template<typename T> struct integer_traits;
        
        template<>
        struct integer_traits<int8_t> {
            typedef bit8_tag category;
        };
        
        template<>
        struct integer_traits<uint8_t> {
            typedef bit8_tag category;
        };
        
        template<>
        struct integer_traits<int16_t> {
            typedef bit16_tag category;
        };
        
        template<>
        struct integer_traits<uint16_t> {
            typedef bit16_tag category;
        };
        
        template<>
        struct integer_traits<int32_t> {
            typedef bit32_tag category;
        };
        
        template<>
        struct integer_traits<uint32_t> {
            typedef bit32_tag category;
        };
        
        template<>
        struct integer_traits<int64_t> {
            typedef bit64_tag category;
        };
        
        template<>
        struct integer_traits<uint64_t> {
            typedef bit64_tag category;
        };
        
        template<typename T>
        T swap_endian_(T value, bit8_tag) {
            return value;
        }

        template<typename T>
        T swap_endian_(T value, bit16_tag) {
            return (value >> 8) | (value << 8);
        }
        
        template<typename T>
        T swap_endian_(T value, bit32_tag) {
            return (value >> 24) |
                ((value & 0x00FF0000) >> 8) | ((value & 0x0000FF00) << 8) |
                (value << 24);
        }
        
        template<typename T>
        T swap_endian_(T value, bit64_tag) {
            return (value  >> 56) |
            #ifdef _WIN32
                ((value & 0x00FF000000000000) >> 40) |
                ((value & 0x0000FF0000000000) >> 24) |
                ((value & 0x000000FF00000000) >> 8)  |
                ((value & 0x00000000FF000000) << 8)  |
                ((value & 0x0000000000FF0000) << 24) |
                ((value & 0x000000000000FF00) << 40) |
            #else
                ((value & 0x00FF000000000000LLU) >> 40) |
                ((value & 0x0000FF0000000000LLU) >> 24) |
                ((value & 0x000000FF00000000LLU) >> 8)  |
                ((value & 0x00000000FF000000LLU) << 8)  |
                ((value & 0x0000000000FF0000LLU) << 24) |
                ((value & 0x000000000000FF00LLU) << 40) |
            #endif
            (value  << 56);
        }
    }

    /*! Swaps the endianness of the passed in value and returns the results.
    *
    * For standard integer types (any of the intX_t/uintX_t types)
    * specializations exist to ensure the fastest performance. All other types
    * are treated as char* and reversed.
    */
    template<typename T> 
    T swap_endian(T value) {
        if (std::numeric_limits<T>::is_integer) {
            return detail::swap_endian_<T>(value, detail::integer_traits<T>::category());
        }

        unsigned char* tmp = reinterpret_cast<unsigned char*>(&value);
        std::reverse(tmp, tmp + sizeof(T));
        return value;
    }

    /*! Converts a value from host-byte order to little endian.
    *
    * Only works with integer types.
    *
    * \param value The value to convert to little endian
    * \return The value converted to endian order.
    */
    template<typename T>
    T host_to_little(T value) {
        static_assert(std::numeric_limits<T>::is_integer);
        return detail::is_big_endian() ? swap_endian(value) : value;
    }
    
    /*! Converts a value from host-byte order to big endian.
    *
    * Only works with integer types.
    *
    * \param value The value to convert to big endian
    * \return The value converted to endian order.
    */
    template<typename T>
    T host_to_big(T value) {
        static_assert(std::numeric_limits<T>::is_integer);
        return detail::is_big_endian() ? value : swap_endian(value);
    }
    
    /*! Converts a value from big endian to host-byte order.
    *
    * Only works with integer types.
    *
    * \param value The value to convert to host-byte order.
    * \return The value converted to host-byte order.
    */
    template<typename T>
    T big_to_host(T value) {
        static_assert(std::numeric_limits<T>::is_integer);
        return detail::is_big_endian() ? value : swap_endian(value);
    }
    
    /*! Converts a value from little endian to host-byte order.
    *
    * Only works with integer types.
    *
    * \param value The value to convert to host-byte order.
    * \return The value converted to host-byte order.
    */
    template<typename T>
    T little_to_host(T value) {
        static_assert(std::numeric_limits<T>::is_integer);
        return detail::is_big_endian() ? swap_endian(value) : value;
    }
        
}  // namespace anh


using namespace std;

int main() {   
    uint32_t test_int_hostbyte = 0x00000002;
    uint32_t test_int_netbyte = 0x02000000;

    uint32_t tmp_int = anh::swap_endian(test_int_hostbyte);

    if (tmp_int == test_int_netbyte) {
        cout << "Hurray, swapping works!\n";
    } else {
        cout << "Sorry, try again!\n";
    }

    return 0;
}

posted by devcodex

Thank you for the feedback! Here's the updated working solution (in roughly half the amount of code as my first attempt and less than a third of that of the original legacy code):

std::u16string chat_data = message->getStringUnicode16();
std::wstring tmp(chat_data.begin(), chat_data.end());

const std::wregex p(L"(\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (.*)");
std::wsmatch m;

if (! std::regex_match(tmp, m, p)) {
    LOG(ERROR) << "Invalid spatial chat message format";
    return;
}

Looking at this solution compared to the original while loop that did the same thing it's much easier now to determine the intention of the code just by reading it. I am continually amazed at just how powerful and elegant the stl is and at the impact the new standard has on the language, what an awesome experience it must be to have a career working so closely with it!

posted by devcodex

First I just want to say I've been following these videos since they started and I love them, you have a natural knack for disseminating quality information

It just so happened that as I was watching this video I was also working on an old and nefarious piece of code: A network message that is essentially a string in char16_t* format that contains 5 integers, formatted as strings and separated by spaces, followed by a text message (this is actually a network message for SpatialChat in the MMORPG project I'm working on). The 5 integers at the beginning are id's for things such as the mood of the speaker, the form of delivery (shouting, whispering, etc).

The original implementation of this involved converting a char16_t* string to a int8_t* (or from utf16 to utf8) before trying to work its way through processing and then converting back to char16_t*. This works great for English text but we recently had a few players from Russia using the Cyrillic alphabet in which the code blows up due to the loss of precision in switching between string formats. It was my task to resolve this issue and given that the bulk of the processing is in a while loop I wanted to see if this could be eliminated using STL algorithms.

Here is the original code as it existed in the source, note the lack of comments which made figuring out what the code was actually doing a big chore:

string chatData;

message->getStringUnicode16(chatData);
chatData.convert(BSTRType_ANSI);

int8* data = chatData.getRawData();
uint16 len = chatData.getLength();

char chatElement[5][32];

uint8 element        = 0;
uint8 elementIndex    = 0;
uint16 byteCount    = 0;

while(element < 5)
{
    if(*data == ' ')
    {
        chatElement[element][elementIndex] = 0;
        byteCount++;
        element++;
        data++;
        elementIndex = 0;
        continue;
    }
    
    chatElement[element][elementIndex] = *data;
    elementIndex++;
    byteCount++;
    data++;
}

// Convert the chat elements to logical types before passing them on.
uint64_t chat_target_id;
try    {
    chat_target_id    = boost::lexical_cast<uint64>(chatElement[0]);
} catch(boost::bad_lexical_cast &) {
    chat_target_id    = 0;
}

SocialChatType chat_type_id = static_cast<SocialChatType>(atoi(chatElement[1]));
MoodType mood_id = static_cast<MoodType>(atoi(chatElement[2]));
    
string chatMessage(data);

After careful examination you can see that the string is converted from utf16 to ansi format, then the string is looped over looking for the 5 integers (in string format) and finally placing the leftover data into a new string. Very complicated, brittle, and failes horribly in the case of strings that require utf16 format. Someone in the past also had decided it would be a good idea to typedef a custom BString class to string, which has been an endless source of confusion as well.

Here is my "homework" solution which makes use of several STL algorithms to achieve the desired results:

// Get the unicode data and convert it to ansii, then get the raw data.
std::u16string chat_data = message->getStringUnicode16();

std::vector<std::u16string> tmp;
std::vector<uint64_t> chat_elements;
int elements_size = 0;

// The spatial chat data is all in a ustring. This consists of 5 chat elements
// and the text of the spatial chat. The 5 chat elements are integers that are
// sent as strings so here we use an istream_iterator which splits the strings
// at spaces.
std::basic_istringstream<char16_t> iss(chat_data);
std::copy_n(std::istream_iterator<std::u16string, char16_t, std::char_traits<char16_t>>(iss), 5,
    std::back_inserter<std::vector<std::u16string>>(tmp));

// Now we use the STL transform to convert the vector of std::u16string to a vector of uint64_t.
try {
    std::transform(tmp.begin(), tmp.end(), std::back_inserter<std::vector<uint64_t>>(chat_elements),
        [&elements_size] (const std::u16string& s) -> uint64_t {
            // Convert the element to a uint64_t
            uint64_t output = boost::lexical_cast<uint64_t>(std::string(s.begin(), s.end())); 

            // After successful conversion update we need to store how long
            // the string was (plus 1 for the space delimiter that came after it).
            elements_size += s.size() + 1; 

            return output;
        });
} catch(const boost::bad_lexical_cast& e) {
    LOG(ERROR) << e.what();
    return; // We suffered an unrecoverable error, bail out now.
}

// After pulling out the chat elements store the rest of the data as the spatial text body.
std::u16string spatial_text(chat_data.begin()+elements_size, chat_data.end());

The above works like a charm! My only complaint is the lack of string literal identifiers in vc2010 when working with std::u16string and std::u32string, however, it's not a dealbreaker (ie., I can't do something like:

std::u16string mystring(u"Some text goes here");

).

Thanks again for a great series, you're definitely making an impact in the C++ community!

posted by devcodex