c++ template: How to dynamically choose between classes and primitive types

Is it possible to implement the idea illustrated below using templates:

// please excuse any syntax errors.

template<typename KEY, typename VALUE>
class Container {
public: 
    VALUE calculate(vector<KEY> searchFors)
    {
        KEY searchFor = searchFors[0];
        pair<KEY,VALUE> lower = getLower(searchFor);
        pair<KEY,VALUE> upper = getUpper(searchFor);
        // calculateImpl uses + - * /
        VALUE value = calculateImpl( 
            lower.first, lower.second(searchFor), 
            upper.first, upper.second(searchFor) );   
        return value;
    }
    // an example of calculateImpl
    VALUE calculateImpl( KEY key1, VALUE value1, KEY key2, VALUE value2 )
    {
         return value1 * value2;
    }
    // an example of getLower getUpper, assuming there're more than 2 elements in _data
    pair<KEY,VALUE> getLower(KEY key)
    {
         return *(_data.begin());
    }        
    pair<KEY,VALUE> getUpper(KEY key)
    {
         return *(_data.begin()+1);
    }        

private:
    vector<pair<KEY,VALUE>> _data;
};

Note that VALUE requires an implementation of operator(). How can I make it such that it can choose between primitives or functors? For example, if searchFors.size() == 0, use VALUE as primitives, otherwise, use VALUE as functors?

In another words, VALUE may be a primitive, (type of VALUE), or a functor (type of VALUE (*)(KEY)) depending on a switch that depends on the size of the vector.

An usage of such a Container would be

vector<double> keys;
keys.push_back(2);  
keys.push_back(3);

// usage as primitive 
// Note Container<double,double> where VALUE=double
Container<double,Container<double,double>> c1;
double result1 = c1.calculate(keys);

Container<double,Container<double,Array<double>>> c2;
Array<double> result2 = c1.calculate(keys);

I want to be able to nest Containers, recursively call calculate, stops when VALUE is no longer a Container.

EDIT: Added code

template<typename KEY, typename VALUE>
class Container {
public: 
Container(vector<KEY> x, vector<VALUE> y)
    :_x(x),
    _y(y) {}

    VALUE calculate(vector<KEY> searchFors)
{
    if( searchFors.size() == 0 )
    {
        throw exception("no search keys");
    }
    KEY key = searchFors[0];

    if( key >= *(_x.end()-1) )
    {
        return *(_y.end()-1);
    }
    if( key <= *(_x.begin()) )
    {
        return *(_y.begin());
    }
    vector<KEY>::const_iterator iSearchKey;
    iSearchKey = upper_bound( _x.begin(), _x.end(), key );
    size_t pos = iSearchKey - _x.begin();
    return (_y[pos]-_y[pos-1])/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + _y[pos-1];
}
private:
vector<KEY> _x;
vector<VALUE> _y;
};


template<typename KEY, typename VALUE>
class Container<KEY, Container<KEY, VALUE> > {
public: 
Container(vector<KEY> x, vector<Container<KEY, VALUE> > y)
    :_x(x),
    _y(y) {}

VALUE calculate(vector<KEY> searchFors)
{
    if( searchFors.size() == 0 )
    {
        throw exception("no search keys");
    }
    KEY key = searchFors[0];
    vector<KEY> remainingKeys( searchFors.begin()+1, searchFors.end() );

    if( key >= *(_x.end()-1) )
    {
        return (_y.end()-1)->calculate(remainingKeys);
    }
    if( key <= *(_x.begin()) )
    {
        return _y.begin()->calculate(remainingKeys);
    }

    vector<KEY>::const_iterator iSearchKey;
    iSearchKey = upper_bound( _x.begin(), _x.end(), key );
    size_t pos = iSearchKey - _x.begin();

    VALUE upperY = _y[pos].calculate(remainingKeys);
    VALUE lowerY = _y[pos-1].calculate(remainingKeys);

    return (upperY-lowerY)/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + lowerY;
}
private:
vector<KEY> _x;
vector<Container<KEY, VALUE> > _y;
};

void main()
{
using namespace boost::assign;

vector<double> y;
vector<double> z;

y += 1,2,3,4;
z += 1,4,9,16;
Container<double,double> yz1(y,z);

z.clear();
z += 1,8,27,64;
Container<double,double> yz2(y,z);

vector<double> x;   
x += 1,4;
vector<Container<double,double> > ys;
ys += yz1,yz2;

Container<double,Container<double,double> > xy(x,ys);

    vector<double> keys;
keys += 2.5,3.5;
double value = xy.calculate(keys);

    // prints 29
cout << value << endl;

}

EDIT: an more efficient version by storing iterators instead of the data

template<typename KEY, typename VALUE>
class Container;

template<typename KEY, typename VALUE>
class Container_helper{
public:
typedef typename std::vector<KEY>::const_iterator key_iterator_type;
typedef VALUE value_type;
typedef typename vector<VALUE>::const_iterator value_iterator_type;

static value_type getValue(const value_iterator_type& iValue, 
    const key_iterator_type&, const key_iterator_type&){
          return *iValue;
     }
};

template<typename KEY, typename VALUE>
class Container_helper<KEY, Container<KEY, VALUE> >{
public:
typedef typename std::vector<KEY>::const_iterator key_iterator_type;
     typedef typename Container_helper<KEY, VALUE>::value_type value_type;
typedef typename std::vector<Container<KEY, VALUE> >::const_iterator value_iterator_type;

static value_type getValue(const value_iterator_type& iValue, 
    const key_iterator_type& xBegin, const key_iterator_type& xEnd)
{
           return (*iValue)(xBegin,xEnd);
     }
};

template<typename KEY, typename VALUE>
class Container {

typedef typename std::vector<KEY>::const_iterator key_iterator_type;
typedef typename std::vector<VALUE>::const_iterator value_iterator_type;
typedef typename Container_helper<KEY, VALUE>::value_type value_type;

public:   
Container(const key_iterator_type& xBegin, 
          const key_iterator_type& xEnd,        
          const value_iterator_type&开发者_如何学Goamp; yBegin, 
          const value_iterator_type& yEnd)
    :_xBegin(xBegin),_xEnd(xEnd),_yBegin(yBegin),_yEnd(yEnd) {}
Container(const Container& source)
    :_xBegin(source._xBegin),_xEnd(source._xEnd),
     _yBegin(source._yBegin),_yEnd(source._yEnd) {}
     Container& operator=(const Container& source)
{
    _xBegin = source._xBegin;
    _xEnd = source._xEnd;
    _yBegin = source._yBegin;
    _yEnd = source._yEnd; 
    return *this;
}


public:
     value_type 
operator()( const key_iterator_type& searchBegin, const key_iterator_type& searchEnd ) const
{
    if( searchBegin == searchEnd )
    {
        throw exception("no search keys");
    }
    KEY key = *searchBegin;
    key_iterator_type searchNext = searchBegin + 1;

              if( key >= *(_xEnd-1) )
              {
                  return Container_helper<KEY,VALUE>::getValue(_yEnd-1, searchNext, searchEnd);
              }
              if( key <= *_xBegin )
              {
                  return Container_helper<KEY,VALUE>::getValue(_yBegin, searchNext, searchEnd);
              }

              key_iterator_type iSearchKey = upper_bound( _xBegin, _xEnd, key );
              size_t pos = iSearchKey - _xBegin;

    KEY lowerX = *(_xBegin+pos-1);
    KEY upperX = *(_xBegin+pos);

              value_type upperY = Container_helper<KEY,VALUE>::
        getValue(_yBegin+pos, searchNext, searchEnd);
              value_type lowerY = Container_helper<KEY,VALUE>::
        getValue(_yBegin+pos-1, searchNext, searchEnd);

              return (upperY-lowerY)/(upperX-lowerX) * (key-lowerX) + lowerY;
         }

  private:
     key_iterator_type _xBegin; 
     key_iterator_type _xEnd;       
     value_iterator_type _yBegin; 
     value_iterator_type _yEnd; 
  };

If I understood you right, I think that might be useful to you

template<typename KEY, typename VALUE>
class Container {
public: 
    VALUE calculate(vector<KEY> searchFors);
    .
    .
    .
private:
    vector<pair<KEY,VALUE> > _data;

};

template<typename KEY, typename VALUE>
VALUE Container<KEY, VALUE>::calculate(vector<KEY> searchFors)
{
     // operate on non-container (simple) values.
}

template<typename KEY, typename VALUE>
class Container<KEY, Container<KEY, VALUE> > {
public: 
    VALUE calculate(vector<KEY> searchFors);
    .
    .
    .
private:
    vector<pair<KEY, Container<KEY, VALUE> > > _data;
};

template<typename KEY, typename VALUE>
VALUE Container<KEY, Container<KEY, VALUE> >::calculate(vector<KEY> searchFors)
{
     // operate on container values
}

Those functions should nicely encapsulate what is base type and what is container. The only problem is that it will only work for a container class - if you have more than one type of container you might use some type of traits.

EDIT:

After seeing your exact example I see that is possible with separating functionality into helper class, but it trashes namespace with additional class. If you don't mind, then code is here:

#include <iostream>
#include <vector>

#include <boost/assign.hpp> 

using namespace std;

template<typename KEY, typename VALUE>
class Container;

template<typename KEY, typename VALUE>
class Container_helper{
public:
    typedef VALUE value_type;

    static value_type calculate(VALUE& val, vector<KEY> /*remainingKeys*/){
        return val;
    }
};

template<typename KEY, typename VALUE>
class Container_helper<KEY, Container<KEY, VALUE> >{
public:
    typedef typename Container_helper<KEY, VALUE>::value_type value_type;

    static value_type calculate(Container<KEY, VALUE>& val, vector<KEY> remainingKeys){
        return val.calculate(remainingKeys);
    }
};

template<typename KEY, typename VALUE>
class Container {

public: 

Container(vector<KEY> x, vector<VALUE> y)
    :_x(x),
    _y(y) {}

public:

    typename Container_helper<KEY, VALUE>::value_type calculate(vector<KEY> searchFors){
          if( searchFors.size() == 0 )
        {
            throw exception(/*"no search keys"*/);
        }
        KEY key = searchFors[0];
        vector<KEY> remainingKeys( searchFors.begin()+1, searchFors.end() );

        if( key >= *(_x.end()-1) )
        {
            return Container_helper<KEY, VALUE>::calculate(*(_y.end()-1), remainingKeys);
        }
        if( key <= *(_x.begin()) )
        {
            return Container_helper<KEY, VALUE>::calculate((*_y.begin()), remainingKeys);
        }

        typename vector<KEY>::const_iterator iSearchKey;
        iSearchKey = upper_bound( _x.begin(), _x.end(), key );
        size_t pos = iSearchKey - _x.begin();

        typename Container_helper<KEY, VALUE>::value_type upperY = Container_helper<KEY, VALUE>::calculate(_y[pos], remainingKeys);
        typename Container_helper<KEY, VALUE>::value_type lowerY = Container_helper<KEY, VALUE>::calculate(_y[pos-1], remainingKeys);

        return (upperY-lowerY)/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + lowerY;
    }

private:
vector<KEY> _x;
vector<VALUE> _y;
};


int main(int argc, char* argv[])
{
using namespace boost::assign;

vector<double> y;
vector<double> z;

y += 1,2,3,4;
z += 1,4,9,16;
Container<double,double> yz1(y,z);

z.clear();
z += 1,8,27,64;
Container<double,double> yz2(y,z);

vector<double> x;   
x += 1,4;
vector<Container<double,double> > ys;
ys += yz1,yz2;

Container<double,Container<double,double> > xy(x,ys);

    vector<double> keys;
keys += 2.5,3.5;
double value = xy.calculate(keys);

    // prints 29
cout << value << endl;

}

I think you can either, define an method in your Container class which get a VALUE and KEY and return a VALUE. Then you can speciliazed this function to either return a value or call the functor. Or (which I would probably do) is write a Wrapper Class which wrap a Primitive to a Functor so when you need a primitive , just create a Container using the Wrapper. That would look like this (this probably doesn't compile)

 template<typename KEY, typename VALUE>
 class PrimitiveToFunctor {
   public:
    PrimitiveToFunctor(VALUE v) {
       value = v;
    }
    VALUE function_to_wrap(KEY key) {
       return value;
    } 
  private:
  VALUE value;
 }

Container<double, Container<double, PrimitiveToFunction<double>>> c1;