Creating a generic conversion function

Question

I have a ResourceManager which takes in classes of type Resource. Resource is a parent class of other classes such as ShaderProgram, Texture, Mesh and even Camera who are completely unrelated to one another.

Suffice it to say, the ResourceManager works. But there is one thing that is very tedious and annoying, and that's when I retrieve the objects from the ResourceManager. Here is the problem:

In order to get an object from ResourceManager you call either of these functions:

static Resource* get(int id);
static Resource* get(const std::string &name);

The first function checks one std::unordered_map by an integer id; whereas the second function checks another std::unordered_map by the name that is manually given by the client. I have two versions of these functions for flexibility sakes because there are times where we don't care what the object contained within ResourceManager is (like Mesh) and there are times where we do care about what it is (like Camera or ShaderProgram) because we may want to retrieve the said objects by name rather than id.

Either way, both functions return a pointer to a Resource. When you call the function, it's as easy as something like:

rm::get("skyboxShader");

Where rm is just a typedef of ResourceManager since the class is static (all members/functions are static). The problem though is that the rm::get(..) function returns a Resource*, and not the child class that was added to the ResourceManager to begin with. So, in order to solve this problem I have to do a manual type conversion so that I can get ShaderProgram* instead of Resource*. I do it like this:

auto s = static_cast<ShaderProgram*>(rm::get(name));

So, everytime I want to access a Resource I have to insert the type I want to actually get into the static_cast. This is problematic insofar that everytime someone needs to access a Resource they have to type convert it. So, naturally I created a function, and being that ShaderProgram is the subject here, thus:

ShaderProgram* Renderer::program(const std::string &name)
{
    auto s = static_cast<ShaderProgram*>(rm::get(name));

    return s;
}

This function is static, and ResourceManager is a static class so the two go well hand-in-hand. This is a nice helper function and it works effectively and my program renders the result just fine. The problem is what I have to do when I'm dealing with other Resources; that means for every Resource that exists, there has to be a type-conversion function to accommodate it. Now THAT is annoying. Isn't there a way I can write a generic type-conversion function something like this?

auto Renderer::getResource(classTypeYouWant T, const std::string &name)
{
    auto s = static_cast<T*>(rm::get(name));

    return s;
}

Here, the auto keyword causes the function to derive which type it's supposed to be dealing with and return the result accordingly. My first guess is that I might have to use templates; but the problem with templates is that I can't limit which types get inserted into the function, and I really REALLY don't want floating-point id numbers, char ids, let alone custom-defined ids. It's either string (might change to const char* tbh) or ints or else.

How can I create a generic conversion function like the one described above?

Answer 1

OK, I did not like the idea of a typeless storage, but maybe you find that basic program as a start point. There are a lot of things which must be beautified, but some work must remain :-)

Again: It is a design failure to solve something in that way!

In addition to your example code this solution provides a minimum of safety while checking for the stored type while recall the element. But this solution needs rtti an this is not available on all platforms.

#include <map>
#include <iostream>
#include <typeinfo>

class ResourcePointerStorage
{
    private:
        std::map< const std::string, std::pair<void*, const std::type_info*>> storage;

    public:
        bool Get(const std::string& id, std::pair<void*, const std::type_info*>& ptr )
        {
            auto it= storage.find( id );
            if ( it==storage.end() ) return false;
            ptr= it->second;
            return true;
        }

        bool Put( const std::string& id, void* ptr, const std::type_info* ti)
        {
            storage[id]=make_pair(ptr, ti);
        }
};

template < typename T>
bool Get(ResourcePointerStorage& rm, const std::string& id, T** ptr) 
{
    std::pair<void*, const std::type_info*> p;

    if ( rm.Get( id,p ))
    {
        if ( *p.second != typeid(T)) { return false; }
        *ptr= static_cast<T*>(p.first);
        return true;
    }
    else
    {
        return 0;
    }
}

template < typename T>
void Put( ResourcePointerStorage& rm, const std::string& id, T *ptr)
{
    rm.Put( id, ptr, &typeid(T) ); 
}

class Car
{
    private:
        int i;

    public:
        Car(int _i):i(_i){}
        void Print() { std::cout << "A car " << i << std::endl; }
};

class Animal
{
    private:
        double d;

    public:
        Animal( double _d):d(_d) {}
        void Show() { std::cout << "An animal " << d << std::endl; }
};

int main()
{
    ResourcePointerStorage store;

    Put( store, "A1", new Animal(1.1) );
    Put( store, "A2", new Animal(2.2) );
    Put( store, "C1", new Car(3) );

    Animal *an;
    Car *car;

    if ( Get(store, "A1", &an)) { an->Show(); } else { std::cout << "Error" << std::endl; }
    if ( Get(store, "A2", &an)) { an->Show(); } else { std::cout << "Error" << std::endl; }
    if ( Get(store, "C1", &car)) { car->Print(); } else { std::cout << "Error" << std::endl; }

    // not stored object
    if ( Get(store, "XX", &an)) { } else { std::cout << "Expected false condition" << std::endl; }

    // false type
    if ( Get(store, "A1", &car)) { } else { std::cout << "Expected false condition" << std::endl; }
};

Answer 2

I've found the solution to my question. I created a macro:

#define convert(type, func) dynamic_cast<type>(func)

Extremely generic and code-neutral which allows types to be dynamic_casted from the return type of the function. It also allows for doing checks:

if (!convert(ShaderProgram*, rm::get("skyboxShader")))
    cerr << "Conversion unsuccessful!" << endl;
else cout << "Conversion successful!" << endl;

I hope my solution will help people who search for questions similar of this kind. Thanks all!

Answer 3

Have you looked at using dynamic_cast? If the conversion fails with dynamic_cast the the pointer will be set to nullptr. So you could either write overloads for each type or you could write a template function where you pass the the type you want to convert to as well as the string or id and if the conversion succeeds or fails return true or false.

template<typename T>
bool Renderer::getResource(T*& type, const std::string &name)
{
    type = dynamic_cast<decltype(std::remove_reference<decltype(T)>::type)>(rm::get(name));
    if (type == nullptr)
        return false;
    return true;
}