V-Gears/QGearsMain/src/core/Utilites.cpp

#include "core/Utilites.h"

#include <OgreStringConverter.h>



const Ogre::String
CreateAutoName(const Ogre::String prefix)
{
    static int enumerator = 0;
    return prefix + Ogre::StringConverter::toString( enumerator++ );
}



struct KeyName
{
    Ogre::String name;
    OIS::KeyCode key;
};

KeyName key_names[] =
{
    { "Enter", OIS::KC_RETURN },
    { "Escape", OIS::KC_ESCAPE },
    { "Space", OIS::KC_SPACE },
    { "LShift", OIS::KC_LSHIFT },
    { "RShift", OIS::KC_RSHIFT },
    { "LCtrl", OIS::KC_LCONTROL },
    { "RCtrl", OIS::KC_RCONTROL },
    { "LAlt", OIS::KC_LMENU },
    { "RAlt", OIS::KC_RMENU },

    { "0", OIS::KC_0 },
    { "1", OIS::KC_1 },
    { "2", OIS::KC_2 },
    { "3", OIS::KC_3 },
    { "4", OIS::KC_4 },
    { "5", OIS::KC_5 },
    { "6", OIS::KC_6 },
    { "7", OIS::KC_7 },
    { "8", OIS::KC_8 },
    { "9", OIS::KC_9 },

    { "A", OIS::KC_A },
    { "B", OIS::KC_B },
    { "C", OIS::KC_C },
    { "D", OIS::KC_D },
    { "E", OIS::KC_E },
    { "F", OIS::KC_F },
    { "G", OIS::KC_G },
    { "H", OIS::KC_H },
    { "I", OIS::KC_I },
    { "J", OIS::KC_J },
    { "K", OIS::KC_K },
    { "L", OIS::KC_L },
    { "M", OIS::KC_M },
    { "N", OIS::KC_N },
    { "O", OIS::KC_O },
    { "P", OIS::KC_P },
    { "Q", OIS::KC_Q },
    { "R", OIS::KC_R },
    { "S", OIS::KC_S },
    { "T", OIS::KC_T },
    { "U", OIS::KC_U },
    { "V", OIS::KC_V },
    { "W", OIS::KC_W },
    { "X", OIS::KC_X },
    { "Y", OIS::KC_Y },
    { "Z", OIS::KC_Z },

    { "Left", OIS::KC_LEFT },
    { "Up", OIS::KC_UP },
    { "Down", OIS::KC_DOWN },
    { "Right", OIS::KC_RIGHT },

    { "Num0", OIS::KC_NUMPAD0 },
    { "Num1", OIS::KC_NUMPAD1 },
    { "Num2", OIS::KC_NUMPAD2 },
    { "Num3", OIS::KC_NUMPAD3 },
    { "Num4", OIS::KC_NUMPAD4 },
    { "Num5", OIS::KC_NUMPAD5 },
    { "Num6", OIS::KC_NUMPAD6 },
    { "Num7", OIS::KC_NUMPAD7 },
    { "Num8", OIS::KC_NUMPAD8 },
    { "Num9", OIS::KC_NUMPAD9 },
    { "NumLock", OIS::KC_NUMLOCK },
    { "NumDiv", OIS::KC_DIVIDE },
    { "NumMult", OIS::KC_MULTIPLY },
    { "NumSub", OIS::KC_SUBTRACT },
    { "NumAdd", OIS::KC_ADD },
    { "NumEnter", OIS::KC_NUMPADENTER },
    { "NumDec", OIS::KC_DECIMAL },

    { "F1", OIS::KC_F1 },
    { "F2", OIS::KC_F2 },
    { "F3", OIS::KC_F3 },
    { "F4", OIS::KC_F4 },
    { "F5", OIS::KC_F5 },
    { "F6", OIS::KC_F6 },
    { "F7", OIS::KC_F7 },
    { "F8", OIS::KC_F8 },
    { "F9", OIS::KC_F9 },
    { "F10", OIS::KC_F10 },
    { "F11", OIS::KC_F11 },
    { "F12", OIS::KC_F12 },

    { "UNASSIGNED", OIS::KC_UNASSIGNED },
};



Ogre::String
KeyToString( OIS::KeyCode key )
{
    // find string by key
    for( KeyName* kn = key_names; kn->name != "UNASSIGNED"; ++kn )
    {
        if( kn->key == key )
        {
            return kn->name;
        }
    }

    return "UNASSIGNED";
}



OIS::KeyCode
StringToKey( const Ogre::String& str )
{
    if( str == "" )
    {
        return OIS::KC_UNASSIGNED;
    }

    // find key by string
    for( KeyName* kn = key_names; kn->name != "UNASSIGNED"; ++kn )
    {
        if( kn->name == str )
        {
            return kn->key;
        }
    }

    return OIS::KC_UNASSIGNED;
}



Ogre::StringVector
StringTokenise( const Ogre::String& str, const Ogre::String& delimiters, const Ogre::String& delimiters_preserve, const Ogre::String& quote, const Ogre::String& esc )
{
    Ogre::StringVector ret;

    Ogre::String::size_type pos = 0; // the current position (char) in the string
    char ch = 0; // buffer for the current character
    char delimiter = 0;	// the buffer for the delimiter char which
                            // will be added to the tokens if the delimiter
                            // is preserved
    char current_quote = 0; // the char of the current open quote
    bool quoted = false; // indicator if there is an open quote
    Ogre::String token;  // string buffer for the token
    bool token_complete = false; // indicates if the current token is
                                 // read to be added to the result vector
    Ogre::String::size_type len = str.length();  // length of the input-string

    // for every char in the input-string
    while( len > pos )
    {
        // get the character of the string and reset the delimiter buffer
        ch = str.at( pos );
        delimiter = 0;

        // assume ch isn't a delimiter
        bool add_char = true;

        // check ...

        // ... if the delimiter is an escaped character
        bool escaped = false; // indicates if the next char is protected
        if( esc.empty() == false ) // check if esc-chars are provided
        {
            if( esc.find_first_of( ch ) != std::string::npos )
            {
                // get the escaped char
                ++pos;
                if( pos < len ) // if there are more chars left
                {
                    // get the next one
                    ch = str.at( pos );

                    // add the escaped character to the token
                    add_char = true;
                }
                else // cannot get any more characters
                {
                    // don't add the esc-char
                    add_char = false;
                }

                // ignore the remaining delimiter checks
                escaped = true;
            }
        }

        // ... if the delimiter is a quote
        if( quote.empty() == false && escaped == false )
        {
            // if quote chars are provided and the char isn't protected
            if( quote.find_first_of( ch ) != std::string::npos )
            {
                // if not quoted, set state to open quote and set
                // the quote character
                if( quoted == false )
                {
                    quoted = true;
                    current_quote = ch;

                    // don't add the quote-char to the token
                    add_char = false;
                }
                else // if quote is open already
                {
                    // check if it is the matching character to close it
                    if( current_quote == ch )
                    {
                        // close quote and reset the quote character
                        quoted = false;
                        current_quote = 0;

                        // don't add the quote-char to the token
                        add_char = false;
                    }
                }
            }
        }

        // if the delimiter isn't preserved
        if( delimiters.empty() == false && escaped == false && quoted == false )
        {
            // if a delimiter is provided and the char isn't protected by
            // quote or escape char
            if( delimiters.find_first_of( ch ) != std::string::npos )
            {
                // if ch is a delimiter and the token string isn't empty
                // the token is complete
                if( token.empty() == false )
                {
                    token_complete = true;
                }

                // don't add the delimiter to the token
                add_char = false;
            }
        }

        // if the delimiter is preserved - add it as a token
        bool add_delimiter = false;
        if( delimiters_preserve.empty() == false && escaped == false && quoted == false )
        {
            // if a delimiter which will be preserved is provided and the
            // char isn't protected by quote or escape char
            if( delimiters_preserve.find_first_of( ch ) != std::string::npos )
            {
                // if ch is a delimiter and the token string isn't empty the token is complete
                if( token.empty() == false )
                {
                    token_complete = true;
                }

                // don't add the delimiter to the token
                add_char = false;

                // add the delimiter
                delimiter = ch;
                add_delimiter = true;
            }
        }

        // add the character to the token
        if( add_char == true )
        {
            // add the current char
            token.push_back( ch );
        }

        // add the token if it is complete
        if( token_complete == true && token.empty() == false )
        {
            // add the token string
            ret.push_back( token );

            // clear the contents
            token.clear();

            // build the next token
            token_complete = false;
        }

        // add the delimiter
        if( add_delimiter == true )
        {
            // the next token is the delimiter
            Ogre::String delim_token;
            delim_token.push_back( delimiter );
            ret.push_back( delim_token );
        }

        // repeat for the next character
        ++pos;
    }

    // add the final token
    if( token.empty() == false )
    {
        ret.push_back( token );
    }

    return ret;
}