Avoid the abstract templates

Why wouldn't a template work for this part as well? For instance, you can have a template function generage(int sourceID), and you don't need inheritance at all.

So you're saying?
template
class CacheLRU
{
DataGenerator iMakeMissingData;
DataHolder iHoldTheCachedData
}
So the cache knows at compile-time to grab the right generator object since he does know what type of data he will hold already... I think, if I follow you correctly. That makes it simpler I suppose. Maybe more involved in the writing of the dataGenerator class though, since wildly different types kinda get blobbed into the same place.

I wouldn't use a dataGenerator class, since a function is probably all that's needed. In any case, writing the dataGenerator class is not hard, because it only needs to know how to generate a T, and nothing else. What you seem to be missing is that you can use template specialization to define the different generators independently of each other, even though they all have the name "dataGenerator".

The situation is similar if you use functions:
template <typename T> T generate(int sourceID);

template <> Mesh generate<Mesh>(int sourceID) {
...
}

template <> Character generate<Character>(int sourceID) {
...
}


Ok, I think I understand that bit.

I'm aware of template specialization, I'm just worried that header file will get to be ginormous if I have more than a trivial amount of specializations. I guess I'll burn that bridge when I get to it, because this method is still worlds simpler than what I was trying to do.

Thanks.

How about:


// Builder type must define:
// Builder::args type which wraps all possible input arguments.
// T const& Builder.create(int id, args source_arguments);
template<typename T, typename Builder>
class cached_builder
{
public:
T const& find_or_create(int sourceID, typename Builder::args const& source_arguments)
{
T const* existing_data = iHoldTheCachedData.find(sourceID);
if (existing_data)
return *existing_data;
T const& new_data = iHoldTheCachedData.insert(builder.create(sourceID, source_arguments));
return new_data;
}
private:
DataHolder<T> iHoldTheCachedData;
Builder builder;
}