POD CO-VARIANT return type virtual overload

[souldog]

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