vector<int>* convert(SomeClass obj)
{
	//Return vector
	vector<int>* retVector = new vector<int>();
	
	//Get the values
	int* values = ...elided...
	
	//Put into vector
	retVector->assign( values, values + length );
	
	//Clean up
	delete values;
	
	return retVector;
}

vector<vector<int> >* convert(SomeClass obj, vector<int> spec)
{
	//Length of array
	int length = GetArrayLength( obj );
	
	//Return vector
	vector<vector<int> >* retVector = new vector<vector<int> >();
	
	//Get all inner arrays
	for ( int i = 0; i < length; i++ ) 
	{
		//Create an inner vector
		vector<int>* innerVector;
		
		//Now get the element of the outer SomeOtherClass Array
		SomeOtherClass otherObj = ...elided...
		
		//Set data
		innerVector = convert( env, otherObj );
		
		//Add it to the outer vector
		retVector->push_back( *innerVector );
		
		//Clean up
		delete innerVector;
	}
	
	return retVector;
}

template <typename T>
vector<vector<T> >* convert(SomeClass obj, vector<T> spec)
{
	//Length of array
	int length = GetArrayLength( obj );
	
	//Return array
	vector<vector<T> >* T = new vector<vector<T> >();
	
	//Set all inner arrays
	for ( int i = 0; i < length; i++ ) 
	{
		//Create an inner vector
		vector<T>* innerVector;
		
		//use this to narrow down to eventually the specialized function
		T subSpec; 
		
		//Now get the element
		SomeOtherClass otherObj = ...elided... 
		
		//Convert inner data
		innerVector = convert( env, otherObj, subSpec );
		
		//Add it to the outer vector
		T->push_back( *innerVector );
		
		//Clean up refs
		delete innerVector;
	}
	
	return T;
}

int main()
{
	vector<vector<string> >* ret = convert( env, o2, vector<string>() );
	
	//Print out results
	for ( vector<vector<string> >::const_iterator it = ret->begin(); it != ret->end(); ++it )
	{
		vector<string> vec = *it;
		for ( vector<string>::const_iterator vecIt = vec.begin(); vecIt != vec.end(); ++ivecIt )
		{
			printf( ( ( *vecIt ) + "\n" ).c_str() );
		}
	}
}

template <typename T>
void drill_down(const vector<T> &vec_p)
{
    for(typename vector<T>::const_iterator i = vec_p.begin(), end = vec_p.end(); i != end; ++i)
        drill_down(*i);
}

template <typename T>
void drill_down(const T &elem_p)
{
    // Base case
}

vector<vector<vector<string> > > vec;

//This sends it to element function
drill_down( &vec );

//All of these can't find matching function
//drill_down<vector<vector<vector<string> > > >( &vec );
//drill_down<vector<vector<string> > >( &vec );