Design Pattern ->Composite

Layering & Contract Philosophy With additional indirection

class CComponent
{  
    public: virtual void Operation() = 0;
        public: virtual void AddComponent(Component* p)= 0;
        public: virtual void RemoveComponent(Component* p)= 0;
        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.