STL containers of templated classes

typedef std::string Column1; // Column 1 is a string value
typedef std::pair<std::string,std::string> NVpair; // one name-value pair
typedef std::vector<NVpair> Column2; // Column 2 is a sequence of name-value pairs
typedef std::pair<Column1, Column2> Row; // one row of the table
typedef std::vector<Row> sequentialTable; // the table is a sequence of rows

Select allOpen in new window

// testpad.cpp : Defines the entry point for the console application.
//
#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
#include <iomanip>
#include <utility>
#include <vector>

typedef std::string Column1; // Column 1 is a string value

// base class of template class NVpair. 
// STL containers cannot contain templated types
// so use a wrapper and an abstract base class
class basic_NVpair 
{
protected:
	virtual ~basic_NVpair(){};
public:
	virtual const std::type_info& GetType() = 0; 
};

// This class is the template for Column2 name-value pairs
template <class  T1> class NVpair : public basic_NVpair
{
public:
	std::pair<std::string,T1> data;
	const std::type_info& GetType(){ return typeid(this); }
};

// Column 2 is a sequence of pointers to name-value pairs
// We use a base class pointer because vectors can't contain templated types
typedef std::vector<basic_NVpair*> Column2; 

// a row is a pair of pointers to Column1 and Column2 data
typedef std::pair<Column1*, Column2*> Row; 

// a table is a sequence of pointers to row data
typedef std::vector<Row*> sequentialTable; 

class Table 
{
public:
	Table(){};
	~Table(){};
	void InsertRow(Row* prow)
	{
		m_Rows.push_back(prow);
	}
	void Print (std::ostream& os)
	{
		// iterate through the table over each row
		sequentialTable::iterator it;
		for ( it = m_Rows.begin(); it < m_Rows.end(); ++it) {
			// print column 1
			os << std::setw(15) << ((*it)->first)->c_str() << "||";
			// print column 2 name-value pairs
			Column2::iterator it2;
			for ( it2 = (*it)->second->begin(); it2 < (*it)->second->end(); ++it2) {
				// we have to decode the correct type to print the value
				// so try dynamic casting to the various types
				if ( NVpair<int>* nvp = dynamic_cast<NVpair<int>*>(*it2) ) {
					os << nvp->data.first.c_str() << nvp->data.second;
				} else if ( NVpair<char>* nvp = dynamic_cast<NVpair<char>*>(*it2) ) {
					os << nvp->data.first.c_str() << nvp->data.second;
				} else if ( NVpair<std::string>* nvp = dynamic_cast<NVpair<std::string>*>(*it2) ) {
					os << nvp->data.first.c_str() << nvp->data.second.c_str();
				} else {
					os << "\n***ERROR***: Type not handled: " << (*it2)->GetType().name() ;
				}
				// some space between data items
				os << "  ";
			}		
			// next line
			os << std::endl;
		}
	}
private:
	sequentialTable m_Rows;
};

// the application entry point
int _tmain(int argc, _TCHAR* argv[])
{

	Column1 myColumn1;
	Column2 myColumn2;
	Table myTable;
	Row	myRow;

	// first column text 
	myColumn1 = "Column 1 txt";

	// create some data of varying types
	NVpair<int>	myNVpair1;
	myNVpair1.data = std::make_pair("1st (int) = "	,34);
	NVpair<char> myNVpair2;
	myNVpair2.data = std::make_pair("2nd (char) = "	,'x');
	NVpair<std::string> myNVpair3;
	myNVpair3.data = std::make_pair("3rd (string) = ",std::string("a STL string"));
	NVpair<double> myNVpair4;
	myNVpair4.data = std::make_pair("4th (double) = " ,7.934);

	// point Column2 to the data
	myColumn2.push_back(&myNVpair1);
	myColumn2.push_back(&myNVpair2);
	myColumn2.push_back(&myNVpair3);
	myColumn2.push_back(&myNVpair4);

	// point the Row to the data
	myRow.first = &myColumn1;
	myRow.second = &myColumn2;

	// insert pointers to the data into the table
	myTable.InsertRow(&myRow);

	// print the data
	myTable.Print(std::cout);

	return 0;
}

Select allOpen in new window