Design Pattern ->Composite

Layering & Contract Philosophy With additional indirection

 class CComponent
 {
     public: virtual void Operation() = ;
         public: virtual void AddComponent(Component* p)= ;
         public: virtual void RemoveComponent(Component* p)= ;
         public: virtual Component* GetChild(int i) { return NULL;}
 }
 class CComposite: public CComponent
 {
        public: virtual void Operation()
        { foreach ( i ) GetChild(i)->Opeartion(); };
        public: virtual void AddComponent(Component* p)
        { v.add( p );};
        public: virtual void RemoveComponent(Component* p)
        { v.remove(p);}
        public: virtual Component* GetChild(int i)
        { return v[i];}
        private: vector< CComponent* > v;
 }
 class CLeaf: public CCompoent
 {
     public: virtual void Operation()
         {    do_something_for_leaf(); };
 }
 class Client
 {
     CLeaf* pleaf1 = new CLeaf; CLeaf* pleaf2 = new CLeaf;
     CLeaf* pleaf3 = new CLeaf; CLeaf* pleaf4 = new CLeaf;
     CLeaf* pleaf5 = new CLeaf;   CLeaf* pleaf6 = new CLeaf;
     CComposite* pcomposite1, pcomposite2 = new CComposite;
      pcomposite1.addcomponent(pleaf1);
      pcomposite1.addcomponent(pleaf2);
      pcomposite1.addcomponent(pleaf3);
      pcomposite2.addcomponent(pleaf4);
      pcomposite2.addcomponent(pleaf5);
      pcomposite2.addcomponent(pcomposite1);
      CComposite* pAll = new CComposite;
      pAll.addComponent(pcomposite1);
      pAll.addComponent(pcomposite2);
      pAll.addComponent(pleaf6);
      pAll.Opearation();
 }

Applicability

Use the Composite pattern when:

• you want to represent part-whole hierarchies of objects.
• you want clients to be able to ignore the difference between compositions of objects and individual objects. Clients will treat all objects in the composite structure uniformly.

Participants

Component (Graphic)

• 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.

Leaf (Rectangle, Line, Text, etc.)

• represents leaf objects in the composition. A leaf has no children.
• defines behavior for primitive objects in the composition.

Composite (Picture)

• defines behavior for components having children.
• stores child components.
• implements child-related operations in the Component interface.

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.