construction of a concept lattice - c++

Question

I'm working for my project of the end of the year with c++ language and I'm really stressed because I have 5 days in this error and there is no enough time . I hope you help me :
the error is:
no match for 'operator<<' in 'std::operator<< <std::char_traits<char> >((* &(& std::operator<< <std::char_traits<char> >((* & tempout.std::basic_ofstream<char>::<anonymous>), ((const char*)"Node ")))->std::basic_ostream<_CharT, _Traits>::operator<< <char, std::char_traits<char> >(i.__gnu_cxx::__normal_iterator<_Iterator, _Container>::operator-><Lattice<std::pair<std::vector<int>, std::vector<int> > >::Node*
the line of the error is : tempout<<"Node " << i->index << ": " <<i->c<<endl; and more sepifically in i->c
My code is the following:
//template named N
template<typename N>
//class latice that contains structure Node and other attribytes
class Lattice {
public:
int count; //count is incremented at every Node insertion in the latticeSet
typedef std::pair<std::vector<int>, std::vector<int> > Concept;
// Node is a set of concepts
//a latticeSet is a set of Node
struct Node {
int index;
typedef std::pair<std::vector<int>, std::vector<int> > Concept;
Node() {}; //constructor
Node(const N& con, int i) : c(con), index(i) {};
N c;
bool operator== (const Node& n) const { return c.first == n.c.first; }
std::pair<std::vector<int>,std::vector<int> > lowerUpperNeighbors;
};
std::vector<Node> latticeSet;//a set of Node
int last_position_cached;
bool was_insert_called;
Lattice() : count(0), last_position_cached(0), was_insert_called(false) {} //constructor
friend ostream& operator<< ( std::ostream& out,const Concept &c) {
out << "{";
if (c.first.size()!=0) {
for(std::vector<int>::const_iterator j = c.first.begin(); j < c.first.end() - 1; ++j)
out << *j << ", ";
out << *(c.first.end() - 1);
}
out << "}, {";
if (c.second.size()!=0) {
for(vector<int>::const_iterator j = c.second.begin(); j < c.second.end() - 1; ++j)
out << *j << ", ";
out << *(c.second.end() - 1);
}
out << "}";
return out;
}
/* The following method is a combination of both insert(x, L) and lookup(x, L) from the FCA Lattice Algorithm.
insertLookup takes a reference to a concept x, and c as input.
Concept x is an upper neighbor of c found by Neighbors, and c is the concept in which x was found to be its upper neighbor.
First, latticeSet is searched for the upper neighborx of c, and if it is not found then it is inserted in the lattice (same fashion as insert).
Next, the lattice is checked if it contains concept c, and if it does then the method returns false due to some unexpected case.
This condition is checked if insert was called, and if the last position of a concept cached by next is not equal to c.
Then, the lattice is searched for concept c in order to add its upper neighbor x.
Finally, concept x/c adds concept c/x as its lower/upper neighbor, respectively.
This method returns true if concept x was inserted in the lattice and c was added to its upper neighbors.
*/
bool insertLookup(const N& x, const N& c) {
std::vector<Node> latticeSet;
typename vector<Node>::iterator x_pos = find(latticeSet.begin(), latticeSet.end(), Node(x, count));
if (x_pos == latticeSet.end()) {
latticeSet.push_back(Node(x, count++));
x_pos = latticeSet.end() - 1;
}
typename vector<Node>::iterator c_pos;
if (was_insert_called && !(latticeSet[last_position_cached].c.first == c.first)) {
c_pos = find(latticeSet.begin(), latticeSet.end(), Node(c, count));
if (c_pos == latticeSet.end()) {
return false;
}
}
else
c_pos = latticeSet.begin() + last_position_cached;
x_pos->lowerUpperNeighbors.first.push_back(c_pos->index);
c_pos->lowerUpperNeighbors.second.push_back(x_pos->index);
return true;
}
//This method inserts a concept in the concept lattice.
bool insert(const N& c) {
latticeSet.push_back(Node(c, count++));
was_insert_called = true;
return true;
}
bool next(const N& c, N& output) {
typename vector<Node>::iterator pos = find(latticeSet.begin(), latticeSet.end(), Node(c, 0));
if (pos == latticeSet.end() || ++pos == latticeSet.end())
return false;
output = pos->c;
last_position_cached = pos - latticeSet.begin();
return true;
}
/* The following method is used to generate the required input file for graphplace.
printGraphplaceInput takes a reference to an output file stream out, and a flag (with a default value of zero).
First an output file stream tempout is in- stantiated with a file called “explain.graph” (see section 4.2).
If the flag passed is zero, then each Node’s concept of the latticeSet is printed to the lattice output file out;
else if the flag passed equals one, then each Node’s unique index number of the latticeSet is printed to the lattice output file out.
During the creation of the lattice output file, “explain.graph” is created by writing each Node index and its corresponding concept to tempout.
This method returns nothing.
*/
void printGraphplaceInput(ofstream& out, int flag = 1) {
ofstream tempout("explain.graph");
for (typename std::vector<Node>:: iterator i = latticeSet.begin(); i!=latticeSet.end();++i) {
//the error is here in i->c it doesn't work .and the error is that na match for operator<< and i didi'nt find a solution
tempout << "Node " << i->index << ": " << i->c <<endl;
out << "(";
if(flag == 0) {
cout << i->index << endl;
}
else if(flag == 1) {
out << i->index;
}
out << ") " << i->index << " node" << endl;
for (typename vector<int>::iterator j = i->lowerUpperNeighbors.second.begin(); j < i->lowerUpperNeighbors.second.end();++j)
out << *j << " " << i->index << " edge" << endl;
}
};
//get the size of the lattice
unsigned int getLatticeSize() {
return latticeSet.size();
}
void LatticeAlgorithm(const Context& GMI, Lattice<Concept>& L) {
vector<int> temp;
Concept c;
GMI.objDPrime((const vector<int>&) temp, c.first);
GMI.objPrime((const vector<int>&) temp, c.second);
L.insert(c);
neighbors n;
vector<Concept> neighborSet;
do {
n.Neighbors(c, GMI, neighborSet);
for(vector<Concept>::const_iterator x = neighborSet.begin(); x < neighborSet.end(); ++x) {
L.insertLookup(*x, c);
}
}
while(L.next(c, c));
}