// Purpose. Composite design pattern lab.
//
// Problem. Approach is now more space efficient, but casting and type
// checking are required to coerce the compiler. The abstraction needs to
// be improved so that Primitive and Composite can be treated
// transparently in a sibling context, while still maintaining their
// specialization.
//
// Assignment.
// o Create a class Component to serve as a base class. Primitive and
// Composite should inherit from Component.
// o Move anything that is (or needs to be) common in both Primitive and
// Composite up into Component.
// o Currently class Composite is coupled to itself (the argument to add() and
// the children private data member). It needs to be coupled only to its
// abstract base class.
// o You can now remove: NodeType, reportType(), the casting in main() and
// Composite::traverse(), and the "type checking" in Composite::traverse()

#include <iostream.h>
enum NodeType { LEAF, INTERIOR };

class Primitive {
public:
Primitive( int val ) : value(val), type(LEAF) { }
NodeType reportType() { return type; }
void traverse() { cout << value << " "; }
private:
int value;
NodeType type;
};

class Composite {
public:
Composite( int val ) : value(val), type(INTERIOR) { total = 0; }
NodeType reportType() { return type; }
void add( Composite* c ) { children[total++] = c; }
void traverse() {
cout << value << " ";
for (int i=0; i < total; i++)
if (children[i]->reportType() == LEAF)
((Primitive*) children[i])->traverse();
else
children[i]->traverse();
}
private:
int value;
NodeType type;
int total;
Composite* children[99];
};

void main( void ) {
Composite first(1), second(2), third(3);

first.add( &second );
first.add( &third );
first.add( (Composite*) new Primitive(4) );
second.add( (Composite*) new Primitive(5) );
second.add( (Composite*) new Primitive(6) );
third.add( (Composite*) new Primitive(7) );
first.traverse();
cout << endl;
}

// 1 2 5 6 3 7 4