Designing Classes: Each class encapsulate object of other related class - oop

Question

I am stuck with the design problem. I could not come up with any good solution. Here is the problem statement.
I have set of devices, each of these devices has some common properties and behavior. Each device may contain 1 or more than one other type of devices connected to it. For example : If there are 4 set of devices A,B,C,D and A being the root of all the devices.
A will have one or many B devices.
B will have one or many C devices.
C will have one or many D devices.
All these different set of devices have some common properties while some are exclusive to themselves.
I have to create a report which will read the data from these objects and read it to file. Report is in XML format and will depict hierarchy of whole system.
How could I approach this problem ? Any suggestion comment would be of great help.

Answer 1

This sounds like a case for the Visitor pattern. You let the Visitor visit each of the children of A. For each child, it'll again visit all children, and so on.
While the Visitor traverses the tree, you collect data about each node. You can, in this case, for example collect the data directly in XML if you want.
The Visitor pattern works well with heterogeneous data types, but it's OK when some of the nodes have common structure as well.

Answer 2

Visitor pattern is a better way of performing operations that where all parent and child classes should be accepted as input and in which behavior is dictated by the object type.
Here's C++ Implementation for your reference:
#include <vector>
#include <iostream>
using namespace std;
class Visitor
{
public:
virtual void visit(class Node *, class Common*) = 0;
virtual void visit(class CompositeNode *, Common*) = 0;
};
class Common
{
int value;
public:
Common(int val)
{
value = val;
}
virtual void traverse()
{
cout << value << " | ";
}
virtual void accept(Visitor &, Common*) = 0;
};
class Node: public Common
{
public:
Node(int val): Common(val){}
virtual void accept(Visitor &v, Common *c)
{
v.visit(this, c);
}
};
class CompositeNode: public Common
{
vector < Common * > children;
public:
CompositeNode(int val): Common(val){}
void add(Common *ele)
{
children.push_back(ele);
}
virtual void accept(Visitor &v, Common *c)
{
v.visit(this, c);
}
virtual void traverse()
{
Common::traverse();
for (int i = 0; i < children.size(); i++)
children[i]->traverse();
}
};
class AddVisitor: public Visitor
{
public:
virtual void visit(Node *, Common*)
{
}
virtual void visit(CompositeNode *node, Common *c)
{
node->add(c);
}
};
int main()
{
Common *nodes[3];
nodes[0] = new CompositeNode(0); //Consider A
nodes[1] = new CompositeNode(1); //Consider B
nodes[2] = new CompositeNode(2); //Consider B
AddVisitor addVisitor;
nodes[0]->accept(addVisitor, nodes[1]); //B
nodes[0]->accept(addVisitor, nodes[2]); //B
nodes[1]->accept(addVisitor, new Node(3)); //Consider C
nodes[1]->accept(addVisitor, new Node(4)); //Consider C
nodes[2]->accept(addVisitor, new Node(5)); //Consider C
nodes[2]->accept(addVisitor, new Node(6)); //Consider C
for (int i = 0; i < 3; i++)
{
cout<<"--------------------------------"<<endl;
nodes[i]->traverse();
cout<<endl;
}
}
Output
--------------------------------
0 | 1 | 3 | 4 | 2 | 5 | 6 |
--------------------------------
1 | 3 | 4 |
--------------------------------
2 | 5 | 6 |