Re: Define a mapping from class types to strings?
On Nov 21, 2:30 pm, alan <almkg...@gmail.com> wrote:
Hello world, I'm wondering if it's possible to implement some sort of
class/object that can perform mapping from class types to strings?
I will know the class type at compile time, like so:
const char *s = string_mapper<thetype>();
Something like typeid(thetype).name() ?
However I do not know the string to be associated with the
type at compile time,
In which case, you probably want to use std::string, instead of
char const*. This means some sort of map, with the values read
in at runtime. Possibly an std::map< std::type_info const*,
std::string >, but you still have the problem of initialization.
The real question is where the names are coming from: the format
of the source data, and how the type associated with the name is
specified. External files can't contain std::type_info, only
text. And std::type_info::name() isn't portable (although if
you're only targeting one compiler, and that compiler does
something useful with this function, you may be able to use it).
What you'll probably have to do is define some sort of canonical
name, and map it to the user defined name (using std::map<
std::string, std::string >, for example).
and will need a way to set up the mapping, to be created
at run time, possibly like so:
void foo(char* some_string_from_runtime){
string_mapper_obj<thetype>.setstring(some_string_from_runtime);
}
If you can do that, then you can use std::type_info as your key
type in the map. Or rather std::type_info const*, as a
type_info isn't copiable. You'll have to provide a comparison
function, of course, based on type_info::before().
I'm rather wondering, however, how you establish the initial
mapping which allows you to call this function.
Possibly I might want to also mix up the string mappings too,
haha, but I suppose I can do that before they even reach the
string mapper.
Maybe something crazy like this? Would this work? (I'm purposefully
glossing over the memory management concerns)
template<class T>
const char* string_mapper_base(bool set, const char* set_to){
static const char* thestring;
if(set) internal = set_to;
return thestring;}
I think a class template would be simpler, with two different
functions, and a static class member.
template<class T>
inline const char* string_mapper(){ return string_mapper_base(false,
0);}
template<class T>
inline const char* string_mapper_set(const char* set_to){return
string_mapper_base(true, set_to);}
---
What I'm trying to do is set up a class of objects so that they have a
possibly-user-defined name. All objects will then be able to access
that name and report to the user that their name is so-and-so.
Worse, I would like to keep this open in the future so that
new classes of objects (inherited from a base type) will
automatically have this ability too (so static member data
doesn't work too well, because I'd then have to retype that
code - I think?).
The static member is in a separate template class, so a new
instance will be created for each instantiation of the template.
The capability is independent of the target class, and will even
work for built-in types.
Something like:
template< typename T >
class StringMapper
{
public:
explicit StringMapper( std::string const& name )
{
ourName = name ;
}
operator std::string() const
{
return ourName ;
}
operator char const*() const
{
return ourName.c_str() ;
}
private:
static std::string ourName ;
} ;
template< typename T >
std::string StringMapper< T >::ourName = std::string() ;
The basic problem remains: how to you find the mapping to start
with.
(I still prefer the solution with std::map, since this allows
you to find the typename of an object, as well as a that of a
statically known type.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34