Re: [Boost-users] Re: (newbie) design question (is there an MPL solution?)

From: Timothy Perrigo (tperrigo_at_[hidden])
Date: 2004-08-10 13:15:44

On Aug 10, 2004, at 10:04 AM, David Abrahams wrote:

> Timothy Perrigo <tperrigo_at_[hidden]> writes:
>
>> I'm just now treading into the (rather intimidating) waters of
>> template metaprogramming, so I'm not even sure if it will fit what I'm
>> trying to accomplish.  I need to create a kind of registry to keep
>> track of instances of variables of different types (actually, several
>> of these registries, representing different system states); variables
>> of a type would be identified by an unique (integer) id.  In other
>> words, the variables within a particular registry represent the state
>> of the system at a given point in time, so although each registry
>> would have variables of the same types and ids, the values of the
>> variables in different registries may be different.  If the variables
>> were all of the same type, a simple map would work.  What I would like
>> is a way of asking this registry for a variable of a specified type
>> and id, and get back the appropriate instance (of the appropriate
>> type).  I.e., something like the following would be ideal:
>>
>> MyType mt = registry.get<MyType>(my_id);
>>
>> Is there anything in the MPL (or elsewhere in Boost) that might help
>> me accomplish what I'm looking to do?  If not, does anyone have any
>> design suggestions to accomplish this in another way?  Any help would
>> be appreciated!
>
> Need more info.
>
> Does each id map to just one type, or might there be different types
> using the same ID in different registries of type R?
>
> Is the id a runtime value, or is it known at compile-time?
>
> -- 
> Dave Abrahams
> Boost Consulting
> http://www.boost-consulting.com
>
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users
>

Thanks for the reply...I'll try to give as much background information 
as I can without clouding the issue.  We're working on a constraint 
processing system.  Particular problems will be modeled with variables 
with values within certain domains and subject to certain constraints.  
These constraints, when propagated, will narrow the domains of the 
variables, but some form of searching will be required to bind all the 
variables to values and find a feasible solution.  The idea behind the 
registry I mentioned is for it to serve as a snapshot of the current 
state of the system (at a specific point in a search, for example).  
The "same" variables will exist in different registries, but may have 
different domains since their sets of possible values may have been 
reduced due to decisions made during the search.  So to answer your 
first question, a particular id will always correspond to a variable of 
a given type, though its value at that point in time (i.e, in that 
registry) may differ from the same variable in a different registry.  
Right now, the id is a runtime value; whenever a new constrained 
variable is created, it is given a new id.

Does this help at all?  Any suggestions, pointers, critiques, etc would 
be greatly appreciated!

PS -- Gennadiy Rozental's earlier reply does get me past my earlier 
stumbling block, though we're still investigating whether this approach 
will allow us to do everything we'd like, so I'd definitely be 
interested in hearing any other ideas.

Thanks!
Tim