ansaurus

Question

C++ - How can I extract a valid string within a string?

Answer 1

+2 A:

Create bool arrays which replicate the tables you've put into comments. Except instead of an "X" or blank put "true" or "false" (so "true" means the combination of modes is valid and "false" means invalid).

Use this table to lookup whether the combination is valid:

 bool IsSecondaryValidWithPrimary(unsigned int primaryIndex, unsigned int secondaryIndex)
 {
     static bool secondaryValidWithPrimary[numPrimaryModes][numSecondaryModes] = {...}

     if (primaryIndex < numPrimaryModes && secondaryIndex < numSecondaryModes)
     {
         return secondaryValidWithPrimary[primaryIndex][secondaryIndex]
     }
     else
     {
         //... this should never happen, throw your favorite exception
     }
 }

Naturally this requires you to convert each 2 character string to the correct array index to be tested. Loop over every possible combination and check to see if its valid. I doubt you seriously care about performance in this setup, so this should work nicely.

Do the same for the other validity check (secondary with another secondary) or any other combination of modes for which you have compatibility rules.

Doug T. 2009-06-12 12:44:42

Answer 2

A:

I would lean towards converting the game mode types into an enumeration. I might even wrap the mode in a class that can store the current game mode state and provide friendly accessors for other parts of the game to quickly query the current mode.

Internally I would create a std::map< int, std::vector< int > > to store a list of compatable modes. As soon as the command line is entered, I would convert the two character strings to the enumeration value. Then I would do a lookup in the compatable mode mapping to see if it's an allowed mode.

How you fill the map is up to you - I'm thinking you could have a class that does it - a compatability loader, or you could drive it from a configuration file if you wanted end users to be able to modify available modes.

An enumeration would be nicer to work with so that you could do a lot of checking at compile time, instead of runtime checks. You do a single runtime check when you convert from the input string to the enumerations, and return a fail message to the user if it's not valid. Then all your other code is checked at compile time.

Kieveli 2009-06-12 13:04:49

Answer 3

+1 A:

I might try putting each mode into a std::set with a white list of modes that are compatible with the given node. When you want to parse a mode string you make a copy of the primary white list. Then you step down through the string. If the next node is not in the white list then you have an invalid mode string. If the next mode is in the white list then you intersect the next node's white list with your working white list. Continue until you reach the end of the string or the white list is empty. If the white list is empty and you are not at the end of the string, it is invalid, otherwise it is good.

The misc modes probably don't belong in the white list (because they are on every white list).

You might also try instead using a black list and creating a union at each step of the way, then bailing out if the mode is in the list.

Dolphin 2009-06-12 15:10:19

Answer 4

+1 A:

Extracting the game type from the host's game name will be difficult without more rules in place. If you really want to avoid giving the end user more rules you could try the following...

ToLower() the entire game name string.
Split the game name using a space ' ' delimiter.
Analyse each word, do the following. If anything fails, go to next word.

taking [0] and determining if it has an ascii value of 97-122 (making sure it's a letter). If it's not within those values, go the next character, and so on until it does (without exceeding the array bounds obviously). This removes any user formatting like a hyphen -apem.
strcmp() the next 2 characters with each of primary game types until you reach a match. Otherwise failing and moving onto next word.
With the remaining characters, strcmp each next pair of characters with each secondary or misc gametype. If any don't match fail out to next word, or if there is only 1 character left over fail out to next word

That should extract the game type, or you can blame the user for using a bad game name.

Now for the harder part, verifying if the gametypes are compatible with each other. I suggest that you make a struct that holds a data structure of booleans representing each of the secondary game types. A std::map, or a single boolean array that could be accessed using a enum.

Now you're going to need a data object to represent each primary game type as well as each secondary game type.

Then just make an array of every gametype, both primary and secondary. Refer to code sample:

map<const char*, bool> mapSecondaryCompatibility;

struct tGameType
{
    char szName[3];
    mapSecondaryCompatibility m_compat;
}

As you see, there technically isn't a difference between your primary and secondary game types, they both have the same restriction... may not be compatible with another secondary game type.

With this I'm sure you can figure out the rest. I hope it helps, I gotta get back to work :)

Oh and I'm a big fan of DotA... keep up the good work!

Balk 2009-06-13 01:21:02

This is actually pretty close to what I ended up doing, so I'll accept this as the answer and edit my post with my code.

kitchen 2009-06-13 04:29:07

ansaurus

tags:

views:

answers:

C++ - How can I extract a valid string within a string?

related questions