Re: Resolving template parameters

If this does not help lead you to a solution, I guess it is beyond
my knowledge to solve this.

--------------------------------------------------------------
#include <vector>
#include <boost/any.hpp>

class ProcBase
{
public:
     virtual ~ProcBase() {}
     virtual boost::any operator()( boost::any val ) =0;
};

template<typename T1>
class Proc1 : public ProcBase
{
public:
     virtual ~Proc1() {}
     virtual boost::any operator()( boost::any val )
     {
         return boost::any( process(boost::any_cast<T1>( val )) );
     }
private:
     T1 process( T1 v )
     {
         return T1();
     }
};

template<typename T1>
class Proc2 : public ProcBase
{
public:
     virtual ~Proc2() {}
     virtual boost::any operator()( boost::any val )
     {
         return boost::any( process(boost::any_cast<T1>( val )) );
     }
private:
     T1 process( T1 v )
     {
         return T1();
     }
};

enum ProcType
{
     kProc1, kProc2
};

template<typename T>
ProcBase *ProcFactory( ProcType t )
{
     switch( t )
     {
     case kProc1:
         return new Proc1<T>();
     case kProc2:
         return new Proc2<T>();
     }
     return NULL;
}

class Resource
{
public:
     virtual ~Resource() {}
     virtual void applyProc( ProcType type1, ProcType type2 ) = 0;
};

template<typename T1>
class Array : public Resource
{
public:
     virtual ~Array() {}
     virtual void applyProc( ProcType t, ProcType )
     {
         ProcBase * processor = ProcFactory<T1>( t );
         for( unsigned int i=0; i < m_internal.size(); ++i )
         {
             m_internal[i] =
                 boost::any_cast<T1>((*processor)( m_internal[i] ));
         }
     }
private:
     std::vector<T1> m_internal;
};

template<typename T1, typename T2>
class Image : public Resource
{
public:
     virtual ~Image() {}
     virtual void applyProc( ProcType t1, ProcType t2 )
     {
         ProcBase * processor1 = ProcFactory<T1>(t1);
         ProcBase * processor2 = ProcFactory<T2>(t2);
         for( unsigned int i=0; i < m_first.size(); ++i )
         {
             m_first[i] =
                 boost::any_cast<T1>( (*processor1)( m_first[i] ));
         }
         for( unsigned int i=0; i < m_second.size(); ++i )
         {
             m_second[i] =
                 boost::any_cast<T2>( (*processor2)( m_second[i] ));
         }
     }
private:
     std::vector<T1> m_first;
     std::vector<T2> m_second;
};

int
main()
{
     Image<float,float> i;
     i.applyProc( kProc1, kProc2 );
}