Handling derived class creation using mappers in C++

Question

I'm reading through Martin Fowler's PoEAA right now on object-relational structural patterns. As a project to do while learning them, I thought I'd build a mini eCommerce system in C++. I'm having trouble figuring out how to return the objects from the mapper.

I have a Product base class, which has derived classes Hat and Shirt. Products have a type member to identify which derived class they are. I also have a ProductMapper class, with derived classes HatMapper and ShirtMapper, all of which implement a bunch of finder methods which let me try and retrieve certain hats and shirts.

class Product
{
    unsigned long long int id;
    std::string name;
    unsigned int type;
};


// Derived classes don't necessarily have the same members.

class Hat : public Product
{
    unsigned char fitted;
    unsigned char color;
    unsigned char style;
};

class Shirt : public Product
{
    unsigned char size;
};

In the logic part of my application where I'd instantiate these mappers and retrieve products is where I'm having trouble. I can instantiate a HatMapper and pull back Hat objects without any problem, same with a ShirtMapper and Shirt objects. The patterns work great in these cases (in particular I'm using class table inheritance, i.e. one product table with product data, one table for hats with hat-specific data, and one table for shirts with shirt-specific data).

My problem is, what do I do if I want to retrieve all products, both hats and shirts? I can instantiate a ProductMapper and fetch all of the product data, but that seems like the wrong approach since I'd have to loop through all the Products I retrieve and build up Hats and Shirts based on their type in my logic portion of the program. Additionally, I'd have to modify any code that handles the situation this way when I add new product types. Seems bad.

The Fowler book has examples of the mappers with the base mapper using the derived mappers which seems completely wrong to me (have to modify the base mapper every time I add a new product, not great). Here's a quick example of how it's done there:

class ProductMapper
{
    unsigned long long int productId;
    unsigned long long int productType;

    HatMapper * hm;
    ShirtMapper * sm;

    Product * FindById(unsigned long long int id)
    {
        // Query database for data.

        if (this->productType == PRODUCT_TYPE_HAT)
        {
            return hm->FindById(id); // Hat object.
        }

        else if (this->productType == PRODUCT_TYPE_SHIRT)
        {
            return sm->FindById(id); // Shirt object.
        }

        return NULL;
    }
};

Here's how I'd use this in the logic part of my program. Examples of this aren't provided in the book:

ProductMapper * pm = new ProductMapper();
Product * p = pm->FindById(1); // It's a Product, but a Hat or Shirt?

// Have to check type since a Product was returned.
switch (p->type)
{
    case PRODUCT_TYPE_HAT:
    {
        Hat * h = (Hat) p;
        break;
    }

    // Etc. Modify this every time a new product type is added or removed.
}

This will introduce circular dependencies. Additionally, assuming I somehow eliminate the circular dependencies, the result of the HatMapper and ShirtMapper classes are Hat objects and Shirt objects. Thus when I return from the ProductMapper, I'll be downcasting, so I'd have to again manipulate the result in my logic, which again introduces the issue of modifying code when I introduce new product types.

I'm at a loss for what to do. In a perfect world, I'd like to have a Product class and a ProductMapper class, both of which I can extend quickly, introducing new product types without having to modify existing code (at least too much).

I would like to be able to use these patterns from PoEAA, they do seem nice and useful, but I'm not sure if it's just something I can't do in C++ or I'm missing something that's preventing me from doing it. Alternative patterns and approaches are also really welcomed.

Answer 1

It feels like the Type Object pattern could help in this case, I know the link is about game programming but it is sufficient to apply the pattern to other domains.

The problem right now is that if you want to add products you have to add several classes, which can become hard to maintain as you noticed.

Edit: Maybe you could use something like that (code is C++11 to simplify the example):

class ProductProperty
{
    typedef std::map<std::string, unsigned char> PropertyMap;

    PropertyMap properties;

    public:
    ProductProperty(std::initializer_list<PropertyMap::value_type> il):
        properties(il)
    {}
    // Use of at() is intended to only deal with the defined properties
    const PropertyMap::value_type::second_type& 
        get(const PropertyMap::value_type::first_type& prop) const 
    { 
        return properties.at(prop); 
    }
    PropertyMap::value_type::second_type& 
        get(const PropertyMap::value_type::first_type& prop) 
    { 
        return properties.at(prop); 
    }

};

// Some helpers to illustrate
std::shared_ptr<ProductProperty> makeHatProperty()
{
    return std::make_shared<ProductProperty>(
        ProductProperty{
            {"fitted", ***whatever**},
            {"color", ***whatever**}, 
            {"style", ***whatever**}
        });
}

std::shared_ptr<ProductProperty> makeShirtProperty()
{
    return std::make_shared<ProductProperty>(
        ProductProperty{{"size", ***whatever**}}
        );
}

class Product
{
    unsigned long long int id;
    std::string name;
    unsigned int type;

    std::shared_ptr<ProductProperty> properties;

    public:
    Product(std::shared_ptr<ProductProperty> props):
        properties(props)
    {}

    // Whatever function you need to get/set/check properties
};