composite pattern

{{Cleanup section|date=May 2024|reason=The subsection headers should not redundantly refer back to the article title and should not be phrased as questions. But do these headers even accurately describe the subsection content? If yes, changing them to "Problems solved" and "Solution described" may be appropriate.}}

The Composite{{cite book|author=Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides|title=Design Patterns: Elements of Reusable Object-Oriented Software|year=1994|publisher=Addison Wesley|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/163 163ff]|url=https://archive.org/details/designpatternsel00gamm/page/163}}

design pattern is one of the twenty-three well-known

GoF design patterns

that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

• Represent a part-whole hierarchy so that clients can treat part and whole objects uniformly.
• Represent a part-whole hierarchy as tree structure.

When defining (1) Part objects and (2) Whole objects that act as containers for Part objects, clients must treat them separately, which complicates client code.{{cite web|title=The Composite design pattern - Problem, Solution, and Applicability|url=http://w3sdesign.com/?gr=s03&ugr=proble|website=w3sDesign.com|access-date=2017-08-12}}

• Define a unified Component interface for part (Leaf) objects and whole (Composite) objects.
• Individual Leaf objects implement the Component interface directly, and Composite objects forward requests to their child components.

This enables clients to work through the Component interface to treat Leaf and Composite objects uniformly:

Leaf objects perform a request directly,

and Composite objects

forward the request to their child components recursively downwards the tree structure.

This makes client classes easier to implement, change, test, and reuse.

See also the UML class and object diagram below.

When dealing with Tree-structured data, programmers often have to discriminate between a leaf-node and a branch. This makes code more complex, and therefore, more error prone. The solution is an interface that allows treating complex and primitive objects uniformly. In object-oriented programming, a composite is an object designed as a composition of one-or-more similar objects, all exhibiting similar functionality. This is known as a "has-a" relationship between objects.{{cite book|url=http://perldesignpatterns.com/?CompositePattern|title=Perl Design Patterns Book|author=Scott Walters|year=2004|access-date=2010-01-18|archive-url=https://web.archive.org/web/20160308182256/http://perldesignpatterns.com/?CompositePattern|archive-date=2016-03-08|url-status=dead}} The key concept is that you can manipulate a single instance of the object just as you would manipulate a group of them. The operations you can perform on all the composite objects often have a least common denominator relationship. For example, if defining a system to portray grouped shapes on a screen, it would be useful to define resizing a group of shapes to have the same effect (in some sense) as resizing a single shape.

Composite should be used when clients ignore the difference between compositions of objects and individual objects. If programmers find that they are using multiple objects in the same way, and often have nearly identical code to handle each of them, then composite is a good choice; it is less complex in this situation to treat primitives and composites as homogeneous.

File:w3sDesign Composite Design Pattern UML.jpg

In the above UML class diagram, the Client class doesn't refer to the Leaf and Composite classes directly (separately).

Instead, the Client refers to the common Component interface and can treat Leaf and Composite uniformly.

The Leaf class has no children and implements the Component interface directly.

The Composite class maintains a container of child

Component objects (children) and forwards requests

to these children (for each child in children: child.operation()).

The object collaboration diagram

shows the run-time interactions: In this example, the Client object sends a request to the top-level Composite object (of type Component) in the tree structure.

The request is forwarded to (performed on) all child Component objects

(Leaf and Composite objects) downwards the tree structure.

;Defining Child-Related Operations

File:w3sDesign Composite Design Pattern Type Safety UML.jpg

There are two design variants for defining and implementing child-related operations

like adding/removing a child component to/from the container (add(child)/remove(child)) and accessing a child component (getChild()):

• Design for uniformity: Child-related operations are defined in the Component interface. This enables clients to treat Leaf and Composite objects uniformly. But type safety is lost because clients can perform child-related operations on Leaf objects.
• Design for type safety: Child-related operations are defined only in the Composite class. Clients must treat Leaf and Composite objects differently. But type safety is gained because clients cannot perform child-related operations on Leaf objects.

The Composite design pattern emphasizes uniformity over type safety.

Image:Composite UML class diagram (fixed).svg.]]

;Component

• is the abstraction for all components, including composite ones
• declares the interface for objects in the composition
• (optional) defines an interface for accessing a component's parent in the recursive structure, and implements it if that's appropriate

;Leaf

• represents leaf objects in the composition
• implements all Component methods

;Composite

• represents a composite Component (component having children)
• implements methods to manipulate children
• implements all Component methods, generally by delegating them to its children

Image:Composite pattern in LePUS3.png.]]

As it is described in Design Patterns, the pattern also involves including the child-manipulation methods in the main Component interface, not just the Composite subclass. More recent descriptions sometimes omit these methods.{{cite web |last1=Geary |first1=David |date=2002-09-13 |df=dmy |url=https://www.infoworld.com/article/2074564/a-look-at-the-composite-design-pattern.html |title=A look at the Composite design pattern |department=Java Design Patterns |work=JavaWorld |access-date=2020-07-20}}

This C++14 implementation is based on the pre C++98 implementation in the book.

1. include
2. include
3. include
4. include
5. include

typedef double Currency;

// declares the interface for objects in the composition.

class Equipment { // Component

public:

// implements default behavior for the interface common to all classes, as appropriate.

virtual const std::string& getName() {

return name;

}

virtual void setName(const std::string& name_) {

name = name_;

}

virtual Currency getNetPrice() {

return netPrice;

}

virtual void setNetPrice(Currency netPrice_) {

netPrice = netPrice_;

}

// declares an interface for accessing and managing its child components.

virtual void add(std::shared_ptr) = 0;

virtual void remove(std::shared_ptr) = 0;

virtual ~Equipment() = default;

protected:

Equipment() :name(""), netPrice(0) {}

Equipment(const std::string& name_) :name(name_), netPrice(0) {}

private:

std::string name;

Currency netPrice;

};

// defines behavior for components having children.

class CompositeEquipment : public Equipment { // Composite

public:

// implements child-related operations in the Component interface.

virtual Currency getNetPrice() override {

Currency total = Equipment::getNetPrice();

for (const auto& i:equipment) {

total += i->getNetPrice();

}

return total;

}

virtual void add(std::shared_ptr equipment_) override {

equipment.push_front(equipment_.get());

}

virtual void remove(std::shared_ptr equipment_) override {

equipment.remove(equipment_.get());

}

protected:

CompositeEquipment() :equipment() {}

CompositeEquipment(const std::string& name_) :equipment() {

setName(name_);

}

private:

// stores child components.

std::list equipment;

};

// represents leaf objects in the composition.

class FloppyDisk : public Equipment { // Leaf

public:

FloppyDisk(const std::string& name_) {

setName(name_);

}

// A leaf has no children.

void add(std::shared_ptr) override {

throw std::runtime_error("FloppyDisk::add");

}

void remove(std::shared_ptr) override {

throw std::runtime_error("FloppyDisk::remove");

}

};

class Chassis : public CompositeEquipment {

public:

Chassis(const std::string& name_) {

setName(name_);

}

};

int main() {

// The smart pointers prevent memory leaks.

std::shared_ptr fd1 = std::make_shared("3.5in Floppy");

fd1->setNetPrice(19.99);

std::cout << fd1->getName() << ": netPrice=" << fd1->getNetPrice() << '\n';

std::shared_ptr fd2 = std::make_shared("5.25in Floppy");

fd2->setNetPrice(29.99);

std::cout << fd2->getName() << ": netPrice=" << fd2->getNetPrice() << '\n';

std::unique_ptr ch = std::make_unique("PC Chassis");

ch->setNetPrice(39.99);

ch->add(fd1);

ch->add(fd2);

std::cout << ch->getName() << ": netPrice=" << ch->getNetPrice() << '\n';

fd2->add(fd1);

}

The program output is

3.5in Floppy: netPrice=19.99

5.25in Floppy: netPrice=29.99

PC Chassis: netPrice=89.97

terminate called after throwing an instance of 'std::runtime_error'

what(): FloppyDisk::add

• Perl Design Patterns Book
• Mixin
• Law of Demeter

{{reflist}}

{{wikibooks|Computer Science Design Patterns|Composite|Composite implementations in various languages}}

• [http://designpattern.co.il/Composite.html Composite Pattern] implementation in Java
• Composite pattern description from the Portland Pattern Repository
• [https://web.archive.org/web/20151002170520/http://www.lepus.org.uk/ref/companion/Composite.xml Composite pattern in UML and in LePUS3, a formal modelling language]
• [http://search.cpan.org/dist/Class-Delegation/lib/Class/Delegation.pm Class::Delegation on CPAN]
• [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/149878 "The End of Inheritance: Automatic Run-time Interface Building for Aggregated Objects"] by Paul Baranowski
• [http://perfectjpattern.sourceforge.net/dp-composite.html PerfectJPattern Open Source Project], Provides componentized implementation of the Composite Pattern in Java
• [https://web.archive.org/web/20090531030742/http://www.theresearchkitchen.com/blog/archives/57] A persistent Java-based implementation
• [http://sourcemaking.com/design_patterns/composite Composite Design Pattern]

{{Design Patterns Patterns}}

{{DEFAULTSORT:Composite Pattern}}

Category:Software design patterns

Category:Articles with example Java code

Category:Articles with example C Sharp code