Tuple iterator test by Anthony Williams

#include "tupleit.hh"
#include <vector>
#include <algorithm>
#include <iostream>
#include <string>
#include <iterator>
#include <deque>
#include <list>
#include <assert.h>

struct MyCompareFunc
{
    template<typename Tuple>
    bool operator()(Tuple const& lhs,Tuple const& rhs) const
    {
        if(lhs.template get<0>()<rhs.template get<0>())
        {
            return true;
        }
        else return false;
    }
}
myCompareFunc;

struct WriteTriple
{
    template<typename Tuple>
    void operator()(Tuple const& tuple) const
    {
        std::cout<<"("<<tuple.template get<0>()<<","<<tuple.get_tail().template get<0>()<<","<<tuple.get_tail().get_tail().template get<0>()<<")"<<std::endl;
    }
} writeTriple;

template<typename Tuple>
void copyTuple(Tuple t)
{
    Tuple t1(t);
    t1=t;
}

void testStuff()
{
    typedef std::vector<int> VecInt;
    VecInt v1,v2;
    // initialize v1 and v2
    v1.resize(3);
    v2.resize(3);
    v1[0]=42;
    v2[0]=23;

    typedef iterators::TupleIt<boost::tuple<VecInt::iterator,VecInt::iterator> >
        TupleIteratorType;

    TupleIteratorType tupleIterator=iterators::makeTupleIterator(v1.begin(),v2.begin());

    *tupleIterator=boost::tuple<int,int>(1,3); // write to vectors
    std::cout<<"v1[0]=="<<v1[0]<<std::endl;
    std::cout<<"v2[0]=="<<v2[0]<<std::endl;
    assert(v1[0]==1);
    assert(v2[0]==3);

    TupleIteratorType::value_type valueCopy=*tupleIterator; // read values
    valueCopy=boost::tuple<int,int>(9,27); // write to copy only

    // verify original vector unchanged
    std::cout<<"v1[0]=="<<v1[0]<<std::endl;
    std::cout<<"v2[0]=="<<v2[0]<<std::endl;
    std::cout<<"valueCopy<0>=="<<valueCopy.get<0>()<<std::endl;
    std::cout<<"valueCopy<1>=="<<valueCopy.get<1>()<<std::endl;
    assert(v1[0]==1);
    assert(v2[0]==3);

    TupleIteratorType::value_type& opStarResult=*tupleIterator; // Ok.
    int& intRef=opStarResult.get<0>(); // ref to element in v1
    intRef=46;
    assert(v1[0]==46);
    std::cout<<"v1[0]=="<<v1[0]<<std::endl;
    std::cout<<"v2[0]=="<<v2[0]<<std::endl;
}

class bigstuff
{
    char array[256];
};


int main()
{
    std::vector<int> v1,v2,v3;

    for(int i=20;i;--i)
    {
        v1.push_back(i);
        v2.push_back(2*i);
        v3.push_back(3*i);
    }

    std::cout<<"Initial"<<std::endl;
    for(int i=0;i<v1.size();++i)
    {
        std::cout<<"entry["<<i<<"]=("<<v1[i]<<","<<v2[i]<<","<<v3[i]<<")"<<std::endl;
    }
    std::for_each(iterators::makeTupleIterator(v1.begin(),v2.begin(),v3.begin()),iterators::makeTupleIterator(v1.end(),v2.end(),v3.end()),writeTriple);

    std::sort(iterators::makeTupleIterator(v1.begin(),v2.begin(),v3.begin()),iterators::makeTupleIterator(v1.end(),v2.end(),v3.end()),myCompareFunc);

    std::cout<<"Sorted"<<std::endl;
    for(int i=0;i<v1.size();++i)
    {
        std::cout<<"entry["<<i<<"]=("<<v1[i]<<","<<v2[i]<<","<<v3[i]<<")"<<std::endl;
    }

    std::random_shuffle(iterators::makeTupleIterator(v1.begin(),v2.begin(),v3.begin()),iterators::makeTupleIterator(v1.end(),v2.end(),v3.end()));

    std::cout<<"Shuffled"<<std::endl;
    for(int i=0;i<v1.size();++i)
    {
        std::cout<<"entry["<<i<<"]=("<<v1[i]<<","<<v2[i]<<","<<v3[i]<<")"<<std::endl;
    }

    std::sort(iterators::makeTupleIterator(v1.begin(),v2.begin(),v3.begin()),iterators::makeTupleIterator(v1.end(),v2.end(),v3.end()),myCompareFunc);

    std::cout<<"Sorted"<<std::endl;
    for(int i=0;i<v1.size();++i)
    {
        std::cout<<"entry["<<i<<"]=("<<v1[i]<<","<<v2[i]<<","<<v3[i]<<")"<<std::endl;
    }

    std::istream_iterator<std::string> cinIt(std::cin);

    writeTriple(*iterators::makeTupleIterator(cinIt,v1.begin(),v2.begin()));

    std::ostream_iterator<std::string> coutIt(std::cout);

    std::vector<std::string> vs;
    std::deque<int> di;
    std::list<int> li;

    *iterators::makeTupleIterator(coutIt,std::back_inserter(vs),std::back_inserter(di),std::back_inserter(li))=boost::make_tuple("hello\n","there",1,2);
    *iterators::makeTupleIterator(coutIt,std::back_inserter(vs),std::back_inserter(di),std::back_inserter(li))=boost::make_tuple("goodbye\n","world",3,4);

    std::for_each(iterators::makeTupleIterator(vs.begin(),di.begin(),li.begin()),iterators::makeTupleIterator(vs.end(),di.end(),li.end()),writeTriple);

    testStuff();

    std::cout<<"sizeof(tuplevectoriterator)="<<sizeof(iterators::TupleIt<boost::tuple<std::vector<bigstuff>::iterator,std::vector<bigstuff>::iterator,std::vector<bigstuff>::iterator> >)<<std::endl;
}