DesignPatterns_Composite

// Composite
// - Compose objects into tree structures to represent part-whole 
//   hierarchies. Composite lets client treat individual objects and 
//   compositons of objects uniformly.
//
// Author     : ZAsia
// Date       : 15/05/09
// Warning    : In practice, declaration and implementation should
//              be separated(.h and .cpp).

#include 
   
   
    
    
#include 
    
    
     
     
using namespace std;

// Component
// - declares the interface for objects in the composition
// - implements default behavior for the interface common to all 
//   classes, as appropriate.
// - declares an interface for accessing and managing its child components.
// - (optional) defines an interface for accessing a component's parent in
//   the recursive structure, and implements it if that's appropriate.
class Component
{
public:
	Component(const char *name) : _name(name) { }
	// The destructor needs to be virtual to allow objects
	// in the heritance hierarchy to be dynamically allocated.
	virtual ~Component() { }
	const char *Name() { return _name; }
	virtual void Operation() = 0;
	virtual void Add(Component *com) { }
	virtual void Remove(Component *com) { }
	virtual Component *GetChild(unsigned int) { return nullptr; }
private:
	const char *_name;
};

// Leaf
// - represents leaf objects in the composition. A leaf has no children.
// - defines behavior for primitive objects in the compositon.
class Leaf : public Component
{
public:
	Leaf(const char *name) : Component(name) { }
	~Leaf() { cout << "delet " << Name() << endl; }
	virtual void Operation() { cout << "I'm " << Name() << endl; }
};

// Composite
// - defines behavior for components haveing children
// - stores child components
// - implements chile-related operations in the Component interface
class Composite : public Component 
{
public:
	Composite(const char *name) : Component(name) { }

	~Composite()
	{
		cout << "delet " << Name() << endl;
		for (vector
     
     
      
      ::iterator iter = vecComponent.begin();
			iter != vecComponent.end(); iter = vecComponent.begin())
		{
			delete *iter;
			vecComponent.erase(iter);	
		}
	}

	virtual void Operation()
	{
		cout << "I'm " << Name() << " , now children introduce yourself:" << endl;
		for (vector
      
      
       
       ::iterator iter = vecComponent.begin();
			iter != vecComponent.end(); ++iter)
		{
			(*iter)->Operation();
		}
	}

	virtual void Add(Component *com)
	{
		vecComponent.push_back(com);
	}

	virtual void Remove(Component *com)
	{
		for (vector
       
       
         ::iterator iter = vecComponent.begin(); iter != vecComponent.end(); ++iter) { if (strcmp((*iter)->Name(), com->Name()) == 0) { delete *iter; vecComponent.erase(iter); break; } } } virtual Component *GetChild(unsigned int index) { if (index >= vecComponent.size()) { return nullptr; } return vecComponent[index]; } private: vector 
        
          vecComponent; }; // Client // - manipulates objects in the composition through the Component interface // // Collaborations // - Clients use the Component class interface to interact with objects in the // composite structure. If the recipient is a Leaf, then the request is handled // directly. If the recipient is a Composite, then it usually forwards requests // to its child components, possibly performing additional operations before // and/or after forwarding. int main() { // Composite Component *pComposite = new Composite("Suzhou Head Office"); // Add ChildLeaf pComposite->Add(new Leaf("Suzhou Human Resource Department")); pComposite->Add(new Leaf("Suzhou Research and Development Department")); // Add ChildComposite pComposite->Add(new Composite("Beijing Branch")); // Add Leaf to ChildComposite pComposite->GetChild(2)->Add(new Leaf("Beijing Human Resource Department")); pComposite->GetChild(2)->Add(new Leaf("Beijing Research and Development Department")); // Operation pComposite->Operation(); pComposite->GetChild(2)->Operation(); // Close Beijing Branch pComposite->Remove(pComposite->GetChild(2)); // Close Suzhou Head Office if (pComposite != nullptr) { delete pComposite; pComposite = nullptr; } return 0; } // 1. defines class hierarchies consisting of primitive objects and composite // objects. Primitive objects can be composed into more complex objects, // which in turn can be composed, and so on recursively. Wherever client // code expects primitive object, it can also take a composite object. // 2. Who should delete components? In language without garbage collection, // it's usually best to make a Composite responsible for deleting its // children when it's destroyed.