wrote:
> Hi,
>
> I'm facing a peculiar problem of finding a way to interpret header
> information in a smart way.
>
> I have this header file that is shared by many users, which contains,
> among things, a few #define statements that associate GUIDs wih a
> friendly name. For e.g. consider the file zoo.h:
>
> ...
> #define tiger GUID1
> #define lion GUID2
> #define striped_cat tiger
> ...
>
> This file can be updated - i.e. #define statements are
> added/removed/modified.
>
> Now, I want to accept the animal type as input from the user, switch
> based on the GUID, and print animal specific information to the user.
> Is it posible for me to have a user specify the animal type as name
> (i.e. tiger, lion etc.) instead of GUID? It would make it very
> convenient to the user.
You can use a standard map to associate the two (I'll assume your GUIDs
are ints):
#include <map>
#include <string>
#include <cassert>
#include "guid.h" // Your GUIDs in here
namespace
{
std::map<std::string,int> zooMap;
}
void InitMap()
{
zooMap[ "Lion" ] = GUID1;
zooMap[ "Tiger" ] = GUID2;
// ...
}
// Use the map elsewhere in the file
void Foo( const std::string& name )
{
// Make sure map is initialized
assert( map.size() != 0 );
// Lookup name; might want to use map<>::find() for error checking
const int id = zooMap[ name ];
// ...
}
Alternately, an OO approach might use a factory a la _Modern C++
Design_'s Factory (library source at sourceforge.net/projects/loki-lib
):
#include <iostream>
#include <string>
#include <memory> // for auto_ptr
#include "loki/Singleton.h"
#include "loki/Factory.h"
using namespace std;
using namepsace Loki;
struct Animal
{
virtual ~Animal() {}
virtual void Print( ostream& ) = 0;
};
struct Lion : Animal
{
void Print( ostream& ) { /* ... */ }
};
struct Tiger : Animal
{
void Print( ostream& ) { /* ... */ }
};
// Make the factory a singleton since there should be only one.
typedef Singleton< Factory<Animal, string> > theAnimalFactory;
// Register all our particular animals
namespace
{
Animal CreateLion() { return new Lion; }
Animal CreateTiger() { return new Tiger; }
const bool lionRegistered = theAnimalFactory::Instance()
.Register( "Lion", CreateLion );
const bool tigerRegistered = theAnimalFactory::Instance()
.Register( "Tiger", CreateTiger );
}
// User takes over management of the animal
auto_ptr<Animal> PrintAnimal( const string id )
{
auto_ptr<Animal> animal( theAnimalFactory.CreateObject( id ) );
animal->Print( cout );
return animal;
}
Factory is in essence a snazzy front end for a map because it
associates an ID of some type with a creation function.
>
> I have a few ideas, but they don't seem to be very elegant:
>
> 1. Have the user specify name-to-GUID mappings in a separate file.
This idea makes it sound like the list can change at run-time or start
time, independent of the program (e.g., the user can add new animals).
If that's so, you cannot use a static list in a .h file to begin with.
You'll want to use some sort of config file (e.g., .ini file on
Windows). Then you build your map or register with factory as the
program is starting up (or as the user makes changes). See the code
above; the map/factory can be updated at any point during program
operation.
> 2. Parse zoo.h and do create a string-to-GUID internally. However this
> is quite cumbersome as #define statements occur all over the place in
> different formats.
It sounds you are suggesting that your C++ program would parse the .h
file to create a map between IDs and strings. This is a bad idea,
especially if the list is changeable by the user. Prefer a file format
that is simpler, as suggested above.
>
> Any pointers in this regard will be greatly appreciated!
>
> Thanks,
> Palani
Cheers! --M
Similar Threads
