POD CO-VARIANT return type virtual overload

Code:

---

template<typename P, typename B>
class POD_PARAMETER_INTERFACE_BASE_MIXIN : public B
{
//TYPEDEFS
private:
        typedef POD_PARAMETER_INTERFACE_BASE_MIXIN<P, B> THIS_TYPE;
        typedef B BASE;

//CONSTRUCTOR/DESTRUCTOR
public:
        POD_PARAMETER_INTERFACE_BASE_MIXIN(const typename B::TYPE_TRAITS::ITEM_CREATION_DATA_TYPE& creation_data):
        BASE(creation_data)
        {
        }
        virtual ~POD_PARAMETER_INTERFACE_BASE_MIXIN()
        {
        }

//ACCESSORS
public:
        virtual P POD_PARAMETER(unsigned int pid) const = 0;
        virtual void SetPODParameter(P value, unsigned int pid) = 0;
};

template<typename B>
class TIME_T_PARAMETER_INTERFACE_MIXIN : public POD_PARAMETER_INTERFACE_BASE_MIXIN<time_t, B>
{
        //TYPEDEFS
private:
        typedef TIME_T_PARAMETER_INTERFACE_MIXIN<B> THIS_TYPE;
        typedef POD_PARAMETER_INTERFACE_BASE_MIXIN<time_t, B> BASE;

        //CONSTRUCTOR/DESTRUCTOR
public:
        TIME_T_PARAMETER_INTERFACE_MIXIN(const typename B::TYPE_TRAITS::ITEM_CREATION_DATA_TYPE& creation_data):
        BASE(creation_data)
        {
        }
        virtual ~TIME_T_PARAMETER_INTERFACE_MIXIN()
        {
        }

//INTERFACE
public:
        boost::shared_ptr<ITIME_T_PARAMETER> TIME_T_PARAMETER_INTERFACE(const OBSERVER_HANDLE& client)
        {
                typename boost::shared_ptr<ITIME_T_PARAMETER> itemp(new typename ITIME_T_PARAMETER(SptrToThis<THIS_TYPE>()));
                RegisterObserver(client);
                return itemp;
        }
};

template<typename B>
class UINT_PARAMETER_INTERFACE_MIXIN : public POD_PARAMETER_INTERFACE_BASE_MIXIN<unsigned int, B>
{
        //TYPEDEFS
private:
        typedef UINT_PARAMETER_INTERFACE_MIXIN<B> THIS_TYPE;
        typedef POD_PARAMETER_INTERFACE_BASE_MIXIN<unsigned int, B> BASE;

        //CONSTRUCTOR/DESTRUCTOR
public:
        UINT_PARAMETER_INTERFACE_MIXIN(const typename B::TYPE_TRAITS::ITEM_CREATION_DATA_TYPE& creation_data):
        BASE(creation_data)
        {
        }
        virtual ~UINT_PARAMETER_INTERFACE_MIXIN()
        {
        }

          //INTERFACE
public:
        boost::shared_ptr<IUINT_PARAMETER> UINT_PARAMETER_INTERFACE(const OBSERVER_HANDLE& client)
        {
                typename boost::shared_ptr<IUINT_PARAMETER> itemp(new typename IUINT_PARAMETER(SptrToThis<THIS_TYPE>()));
                RegisterObserver(client);
                return itemp;
        }
};

template<typename B>
class DOUBLE_PARAMETER_INTERFACE_MIXIN : public POD_PARAMETER_INTERFACE_BASE_MIXIN<double, B>
{
//TYPEDEFS
private:
        typedef DOUBLE_PARAMETER_INTERFACE_MIXIN<B> THIS_TYPE;
        typedef POD_PARAMETER_INTERFACE_BASE_MIXIN<double, B> BASE;

//CONSTRUCTOR/DESTRUCTOR
public:
        DOUBLE_PARAMETER_INTERFACE_MIXIN(const typename B::TYPE_TRAITS::ITEM_CREATION_DATA_TYPE& creation_data):
        BASE(creation_data)
        {
        }
        virtual ~DOUBLE_PARAMETER_INTERFACE_MIXIN()
        {
        }

//INTERFACE
public:
        boost::shared_ptr<IDOUBLE_PARAMETER> DOUBLE_PARAMETER_INTERFACE(const OBSERVER_HANDLE& client)
        {
                typename boost::shared_ptr<IDOUBLE_PARAMETER> itemp(new typename IDOUBLE_PARAMETER(SptrToThis<THIS_TYPE>()));
                RegisterObserver(client);
                return itemp;
        }
};

---

as you can see I am creating POD parameter mixin. Problem is you can not mixin more than one base of different pod type. You can not instantiate two versions of the POD_PARAMETER function because they only differ by return type.

Obvious solution is to just name the get/set function based on pod type.

I was wondering if anyone has a clever solution to this type of problem