Names of design patterns appear in small capitals: e.g., Adapter. Page numbers in bold indicate the definition of a term. Numbers in italics indicate a diagram for the term. Letters after a diagram's page number indicate the kind of diagram: a "c" denotes a class diagram, an "i" denotes an interaction diagram, and an "o" denotes an object diagram. For example, 88co means that a class and object diagram appears on page 88.

A

abstract class 15, 16c, 359, 364, 365c
abstract coupling, see coupling, abstract: in Observer 296
Abstract Factory 87: extensibility of 91; in catalog summary 8; Lexi's use of 51; used to configure a subsystem 193
Abstract Factory: participant of Abstract Factory 88c, 89
abstract operation, see operation, abstract: use to implement Adapter 144
abstract syntax tree 244, 251, 331: class structure for 244c, 331c; constructing in Smalltalk 250; object structure for 244o
AbstractExpression: participant of Interpreter 245c, 245
Abstraction: participant of Bridge 153c, 154
AbstractProduct: participant of Abstract Factory 88c, 89
accumulating state 336
acquaintance 22, 359: C++, defined in 23; compared with aggregation 23; Smalltalk, defined in 23
Action, see Command
active iterator, see iterator, active
Ada 4, 21
Adaptee: participant of Adapter 141, 141c
Adapter 139: compared with Bridge 161, 219; compared with Decorator 184; compared with Proxy 216; in catalog summary 8
Adapter: participant of Adapter 141, 141c
adapter 140: class adapter 141, 141c; object adapter 141, 141c; parameterized 145; pluggable, see pluggable adapter; two-way 143, 143c
adorner 179
Aggregate: participant of Iterator 259, 259c
aggregate object 257
aggregation 22, 359: C++, defined in 23; compared with acquaintance 23; notation for 23; Smalltalk, defined in 23
Alexander, Christopher xiii, 2, 356, 358
algorithm: avoiding dependence on 24; defining steps of 326; family of 317; skeleton 327
AlternationExpression 244co, 343: implemented in Smalltalk 249
aluminum alloy 76
Ambassador, see also Proxy: C++ idiom 208
AnalogClock 303
analysis object model: transforming to design object model 353
ancestor class 361, see also class, parent
Anderson, Bruce xi, 357
AndExp 253
Andrew Toolkit: use of Observer 303
Application 107, 107c, 223o, 224ci, 231, 325, 325c
application programs 25
ApplicationWindow 53, 54c, 55c, 157, 233c, 234c
ArrayCompositor 42c, 315, 315c, 322
ASCII7Stream 183, 183c
aspect of an object 298
AssignmentNode 333c
associations, see also acquaintance, aggregation: in OMT 364

B

BTree 202
base class, see class, parent
Beck, Kent xi, 357
Bedrock: use of Decorator 179, 180
behavioral pattern 10, 221: comparison between class and object scope 221; discussion 345
black-box reuse, see reuse, black-box
block, Smalltalk 270
BNF form 247: examples of 243, 248, 251
BombedMazeFactory 93
BombedMazeGame 115
BombedWall 93, 94, 124
Booch Components: use of Iterator 270; use of Strategy 323
Booch, Grady xiii, 260
Booch method 363
Boolean: expression 251; variable 254
BooleanExp 252
Border 44, 45c, 46o
BorderDecorator 176o, 176c, 180
Bridge 151: compared with Adapter 219; configured by Abstract Factory 155; in catalog summary 8; Lexi's use of 58; use of delegation in 21
bridge 152
broadcast communication 296
Builder 97: compared with Abstract Factory 105, 135; compared with Prototype 135; in catalog summary 8; use in compiler example 189
Builder: participant of Builder 98, 98c
Bureaucrat 232, see also Chain of Responsibility
Button 50c, 223o, 224ci, 229, 279

C

C 4
Calder, Paul 33, 38
callback function 235
Caretaker: participant of Memento 285, 285c, 286i
Cargill, Tom 308
Chain of Responsibility 223: combined with Composite 166, 232; compared with Mediator 348; compared with Observer 348; defined by parent references 166, 232; in catalog summary 8; use of delegation in 21
ChangeManager 282, 299, 300c
Character 38, 38c
character: represented as object 38, 195196
Cheshire Cat 155
Choices operating system: use of Facade 192; use of Proxy 209
class 14, 359: abstract, see abstract class; adapter, see adapter, class; compared with type 16; concrete, see concrete class; derived 360; friend, see friend class; inability to alter 24; inheritance, see inheritance; instance 15; library, see toolkit; mixin, see mixin class; notation for 15, 363; parent 15, 361; subclass 15; template, see template
class diagram 363, 365c, 359
class hierarchy: adding operations to 356; connecting parallel 109, 258; explosion 25, 43, 151, 177; minimizing size of 113, 120, 177, 277, 317, 348; visiting multiple 336
class operation 359: alternatives provided by Singleton 128
Client: participant of Abstract Factory 88c, 89; participant of Adapter 141, 141c; participant of Builder 98, 98c, 99i; participant of Chain of Responsibility 225ci, 226, 348i; participant of Command 236, 236c, 237i; participant of Composite 164c, 165; participant of Flyweight 198c, 199; participant of Interpreter 245c, 246; participant of Prototype 119, 119c
client 11: isolating concrete classes from 89
ClockTimer 302
clone operation 117: used in Prototype 117; implementing 121
cloned object 117: initializing 121
CLOS 4, 260, 338
closure 260, 267
Coad, Peter 357
code structure: run-time versus compile-time 23
CodeGenerationVisitor 332c
Colleague: communicating with Mediator 278, 282; participant of Mediator 276co, 277, 348i
Command 233: combined with Memento 239, 287; combined with Prototype 238; in catalog summary 8; use in Lexi 64
Command 60, 61c, 233, 233c, 239: configured in MenuItem 61; history of 62; participant of Command 236, 236c, 237i, 347i
command: C++ idiom, see functor; copying before execution 238; history, see history list; implemented through C++ templates 239, 240; intelligence of 238
common vocabulary 352
communication: encapsulated or distributed 346; between Strategy and Context 318; between Visitor and Element 337
compilation dependencies: reducing using Facade 188
Compiler 185, 186c, 191
compiler: example in Facade 185, 186c, 188; implemented using Visitor 331; Smalltalk, see RTL Smalltalk compiler
Component: participant of Composite 164c, 165, 168; participant of Decorator 177, 177c
Composite 163: caching children of 169; child management 167; combined with Interpreter 255; combined with Iterator 262; combined with Visitor 339; compared with Decorator 219220; compared with Interpreter 247; data structure for 169, 170; in catalog summary 8; interface of 167; Lexi's use of 40; parent references 166; sharing components 166; use in Model/View/Controller 5
Composite: participant of Composite 164c, 165, 165o, 168
CompositeEquipment 171
Composition 41, 42c, 315, 315c, 320
composition, see object composition
Compositor 41, 42, 315, 315c, 321: interface 41
CompressingStream 183c, 184
concrete class, 15, 359: avoiding specification of 24; isolating clients from 89
ConcreteAggregate: participant of Iterator 259, 259c
ConcreteBuilder: participant of Builder 98c, 99, 99i
ConcreteCommand: participant of Command 236, 236c, 238
ConcreteComponent: participant of Decorator 177, 177c
ConcreteDecorator: participant of Decorator 177c, 178
ConcreteElement: participant of Visitor 334, 334c, 335i
ConcreteFactory: participant of Abstract Factory 89
ConcreteFlyweight: participant of Flyweight 198co, 199
ConcreteHandler: participant of Chain of Responsibility 225c, 226
ConcreteImplementor: participant of Bridge 153c, 154
ConcreteIterator: participant of Iterator 259, 259c
ConcreteObserver: participant of Observer 294c, 295, 295i
ConcreteProduct: participant of Abstract Factory 88, 89; participant of Factory Method 108, 108c
ConcretePrototype: participant of Prototype 119, 119c
ConcreteState: participant of State 307, 307c
ConcreteStrategy: participant of Strategy 316c, 316
ConcreteSubject: participant of Observer 294c, 295, 295i
ConcreteVisitor: participant 334, 334c, 335i
conditional statements: avoiding using State 307; avoiding using Strategy 317
consolidation phase of lifecycle 353
constraint solving 282, 283: see also ThingLab, QOCA
ConstraintSolver 283284, 288
constructor 360
Context 252: participant of Interpreter 245c, 246; participant of State 306, 306c; participant of Strategy 316c, 316
control flow: encapsulating, see Mediator; inversion of 27
Coplien, James 125, 153, 160, 242, 313, 357
copy: deep 121; on write 210; shallow 121
CountingMazeBuilder 104
coupling 360: abstract 188, 278, 296, 359; loose 24, 26, 277, 347, see also decoupling; reducing 24, 187, 188, 223, 226; tight 24
CreateMaze operation 84: Abstract Factory variant (C++) 92; Abstract Factory variant (Smalltalk) 94; Builder variant 102; Factory Method variant 114; Prototype variant (Smalltalk) 123, 125
creational pattern 10, 81: discussion of 135
Creator: participant of Factory Method 108, 108c; implementation of 111, 113
Cursor, see Iterator
cursor, see iterator, cursor

D

data member 360
DebuggingGlyph 182
Decorator 175: compared with Adapter 175, 184; compared with Composite 44, 173, 219220; compared with Proxy 216, 219220; compared with Strategy 179; in catalog summary 8; Lexi's use of 45c, 46o, 47; lightweight versus heavyweight 179
Decorator 176, 180: participant of Decorator 177, 177c, 180o
decorator 175
decoupling, see also coupling, loose: interface and implementation 154; senders and receivers 346
deep copy, see copy, deep
delegate 20, 144
delegation 20, 278, 360: compared with inheritance 2021; implementing pluggable adapters with 144; patterns that rely on 21
dependency 293: managing complex 299
Dependents, see Observer
derived class, see class, derived
design: dj-vu 2; density 358; documenting with patterns 27, 352; for change 23; poetry of 356; for reuse 23
design object model 353
design pattern 360: adjunct to design methodology 353; aspects of design varied by 30; benefits 351; catalog summary 8; catalog template 6; classification 10; compared with frameworks 28; diagram of relationships 12; documenting designs with 27, 352; essential elements 3; finding 355; history of 355; how to use 29; purpose 10; refactoring with 353; scope 10; selection of 28; table of 10
destructor 360: ensuring iterator's is called 266
Dialog 223, 231
DialogDirector 274o, 275ci, 278
DialogWindow 53, 54c, 55c
DigitalClock 302
Director: participant of Builder 98c, 99, 99i
DirectoryBrowser 144, 144c, 145c
discretionary glyph 75
dispatch: double 338; multiple 339; single 338
Doc 205, see also Lexi
Document 107, 107c, 233c, 234, 234c, 325, 325c
document: color 42, 322; formatting 40; logical structure 40; physical structure 35
documenting design with patterns 27, 352
doesNotUnderstand message: used to implement Chain of Responsibility 229; used to implement Proxy 212, 215
Domain 192, 192c
Door 82c, 83: extensions for Prototype 123
double-dispatch, see dispatch, double
downcast 91
Dylan 4: use of Memento 289
dynamic binding 14, 360
dynamic inheritance 309
dynamic_cast in C++ 91, 168

E

e-mail address: reaching the authors xii
Eiffel 17, 21
Element: participant of Visitor 334, 334c
encapsulation 11, 360: breaking with inheritance 19; breaking with Visitor 337; preserving boundaries of 286; of algorithms, see Strategy; of complex update semantics, 299, see also ChangeManager; of concept that varies 29, 54; of document analysis and traversal 71; of protocol between objects, see Mediator; of how objects are created, see Abstract Factory, Builder,; Prototype; of traversal, see Iterator; of requests 59, see also Command; of state-specific behavior, see State
EnchantedMazeFactory 93
envelope-letter idiom 313
Equipment 170, 340
EquipmentVisitor 341
error accumulation: avoiding during undo/redo 239
ET++: use of Abstract Factory 95; use of Adapter 126, 148; use of Bridge 160; use of Builder 105; use of Chain of Responsibility 232; use of Composite 172; use of Command 242; use of Decorator 182, 183; use of Facade 192; use of Factory Method 115; use of Flyweight 206; use of Iterator 261; use of Mediator 281; use of Observer 303; use of Prototype 120, 125; use of Proxy 216; use of Strategy 322323
ET++SwapsManager: use of Strategy 323
ETgdb 125
expansion phase of lifecycle 353, 354
explosion, see class hierarchy, explosion
ExtendedHandler 228
external iterator, see iterator, external
extrinsic state, see state, extrinsic

F

Facade 185: compared with Mediator 193, 282; in catalog summary 8; use in Choices 192
Facade: participant of Facade 185c, 187, 187c
facade 185
Factory Method 107: in catalog summary 8; language-specific variants 112; parameterized with product identifier 110; used to implement Abstract Factory 90, 91, 110; used to create an iterator 258
FileStream 183, 183c
Flyweight 195: combined with Composite 167, 200; combined with Interpreter 247; combined with State 308; in catalog summary 9; Lexi's use of 39; participant of Flyweight 198, 198co
flyweight 196, 196o: managing shared 200
FlyweightFactory 204: participant of Flyweight 198co, 199
FontDialogDirector 274, 274o, 275ci
Foote, Brian 353
forwarding requests 229
framework 26, 360: compared with design patterns 28; documenting with patterns 27; graphical editor 117; see Bedrock; see Choices; see ET++; see HotDraw; see MacApp; see NEXTSTEP; see NeXT AppKit; see RApp; see RTL Smalltalk compiler; see Unidraw; trade-offs associated with 27
Fresco 344
friend class 360: used to grant Iterator privileged access to collection 262; used to support Memento 287
functor 242
future cash flow 323

G

gdb 126
generics 21
Glyph 38, 38c, 42c, 43o, 45c, 46o, 50c, 54c, 67c: implemented as a flyweight 201204; interface 39; interface for traversal 66
Glue, see Facade
GlyphArrayIterator 67, 67c
GNU gdb 126
grammar 243: maintaining complex 247
Graphic 163c, 208c, 213
GraphicTool 117, 118c
guaranteed receipt of request 226
GUIFactory 49, 50c, 51

H

Hamlet 1
Handle/Body, see also Bridge: C++ idiom 155, 160
Handler: participant of Chain of Responsibility 225, 225ci, 348i
hardware platform: isolating application from 24
help: context-sensitive 223; on-line 223
HelpHandler 224, 224c, 227, 229
history list 6264, 238: copying commands onto 238
Hollywood principle 327
hook operation 326, 328: in Abstract Factory 109; in Factory Method 109; in Proxy 212; in Template Method 326, 328
HotDraw: use of State 313
hub of communication 274
hyphenation 64

I

IconWindow 53, 54c, 151152, 151c, 157
Image 207o, 208c, 213
ImageProxy 207o, 208c
Implementor: participant of Bridge 153c, 154
implicit receiver, see receiver, implicit
incremental changes 287
inheritance 15, 360: C++, defined in 17; class versus interface 16; combined with polymorphism 18; compared with object composition 18, 178; compared with parameterized types 21; dynamic 309; Eiffel, defined in 17; implementation 17, 360; interface 17, 360; mixin, see mixin class; notation for 15, 364, 365c; proper use of 18; reuse through 18; Smalltalk, defined in 17
inorder traversal, see traversal, inorder
instance, see also class, instance: ensuring uniqueness, see Singleton; variable 15, 360
instantiation 15: abstracting process of 48; notation for 15, 364, 365c
integrated circuit 323
interaction diagram 7, 366: in Builder 99i; in Chain of Responsibility 224i, 348i; in Command 237i, 347i; in Mediator 274i, 348i; in Memento 286i; in Observer 295i, 347i; in Visitor 335i; Lexi's Visitor 74i
interface 13: benefits of programming to 18; bloat 257; conversion, see Adapter; for iteration 262; inheritance 13, 17; narrow versus wide in Memento 285; specifying in C++ 17; simplifying subsystems, see Facade
internal iterator, see iterator, internal
Interpreter 243: combined with Composite 255; combined with Visitor 247, 255; in catalog summary 9
InterViews: use of Abstract Factory 95; use of Adapter 148; use of Command 242; use of Composite 172; use of Decorator 182; use of Flyweight 205; use of Observer 303; use of Singleton 133; use of Strategy 320, 322323
intrinsic state, see state, intrinsic
inversion of control flow 27
invitation 358
Invoker: participant of Command 236, 236c, 237i, 347i
IRIS Inventor: use of Visitor 344
Iterator 257: combined with Composite 362; combined with Visitor 339; compared with Visitor 336; in catalog summary 9; use in Lexi 69
Iterator 67, 67c, 258c, 263, 372: participant of Iterator 259, 259c
iterator 66, 257, 339: access to aggregate 262; active 260; alternative to in Smalltalk 270; controlling 260; cursor 261; ensuring deletion of 266; external 260, 339, 269; interface to 261, 263; internal 260, 267, 339, see also ListTraverser; null 262, see also NullIterator; over recursive structures 262; parameterized with an operation 267; passive 260; polymorphic 258, 261, 265; privileged access to Aggregate 262; robust 261

K

Kit, see also Abstract Factory: in InterViews 95
Knuth, Donald 357

L

lazy initialization 112
Leaf: participant of Composite 164c, 165, 165o, 168
Lempel-Ziv compression 183
Lexi 33: document structure 35; document traversal and analysis 64; look-and-feel standards 47; multiple window systems 51; user interface 33, 34; user operations 58
libg++: use of Bridge 160
lifecycle of software 353, 354
Linton, Mark 344
List 257, 257c, 258c, 263, 369
list box 274
list traversal 257
ListBox 274o, 275ci, 279
ListIterator 67, 257, 257c, 258c, 264, 372
ListTraverser 267
LiteralExpression 244co, 344: implemented in Smalltalk 250
look-and-feel standards 87: support in Lexi 35, 47

M

MacApp: use of Chain of Responsibility 232; use of Command 242; use of Decorator 179, 180; use of Factory Method 113, 115
Macbeth 1
MacFactory 50c
Macintosh 48, 52
MacroCommand 235, 235c, 241
magic token 346
Manipulator 109, 110c
MapSite 82, 82c
Marriage of Convenience 149
Maze 82c, 84
MazeBuider 101
MazeFactory 92: as singleton 133
MazeGame 84, 114
MazePrototypeFactory 122
Mediator 273: combined with Observer 299; compared with Chain of Responsibility 348; compared with Facade 282; compared with Observer 346, 348; in catalog summary 9; use of delegation in 21
Mediator: communicating with Colleague 278, 282; participant of Mediator 276co, 277, 348i; omitting abstract class of 278
mediator 274
member function 361, see also operation
Memento 283: in catalog summary 9
Memento: combined with Command 239, 287; participant of Memento 285, 285c, 286i
memento 284: costs associated with 286; language support for 287
MemoryStream 183
Menu 50c, 233c
menu 233: configuring 60, 234; pull-down 58
MenuItem 59, 61c, 233, 233c
metaclass 133, 361
method 361, see also operation
Microsoft Windows 52
mixin class 16, 16c, 361
Model/View/Controller 4, 5: use of Composite 5, 172; use of Factory Method 115; use of Observer 5, 303; use of Strategy 6
MonoGlyph 44, 45c
Motif 35, 47, 48, 49, 51, 87
MotifFactory 49, 50c
multiple dispatch, see dispatch, multiple
multiple inheritance, see also mixin class: used to implement class adapter 141; used to implement Bridge 156
MVC, see Model/View/Controller
Meyer, Bertrand 149

N

naming conventions 29, 31: Factory Method 31, 113; Template Method 329; Visitor 337
NeXT AppKit: use of Adapter 149; use of Bridge 160; use of Chain of Responsibility 232; use of Template Method 329
NEXTSTEP: use of Adapter 145; use of Proxy 208, 212, 216
Node 333c
NodeVisitor 332c
nonterminal symbol 246
NonTerminalExpression: participant of Interpreter 245c, 246
notification 294
null iterator, see iterator, null
NullIterator 67c, 6768, 262
NXProxy 208, 212

O

object 11, 361: adapter, see adapter, object; acquaintance 22; aggregation 22; as argument to request 345; aspect of 298; avoiding dependence on implementation of 24; composition, see object composition; finding 11; granularity of 13, see also Flyweight; guts 179; reference 361; shared, see Flyweight; skin 179; specifying implementation of 14; specifying interface to 13
object composition 18, 361: compared with inheritance 1820; compared with parameterized types 22; reuse through 19
object diagram 364, 361
Objects for States, see State
Object Modeling Technique 7, 14, 363, 364
Objective C 90, 120, 121, 135, 144
Objectory 363
ObjectWindows: use of Iterator 270; use of Strategy 323
ObjectWorks\Smalltalk, see also Smalltalk: use of Adapter 148149; use of Decorator 182; use of Facade 191
Observer 293: combined with Mediator 278, 282; compared with Chain of Responsibility 346, 348; compared with Mediator 346, 348; in Model/View/Controller 5; in catalog summary 8; limiting unexpected updates in 296
Observer 300: combining with Subject 300; participant of Observer 294c, 295, 295i, 300c, 347i
OMT, see Object Modeling Technique
operation 11, 361: abstract 15, 359; adding to classes 335; avoiding dependence on specific 24; class, see class operation; concrete 327; dispatch, see dispatch; hook, see hook operation; overriding 16; primitive 327, 329
Orbix: use of Factory Method 116
Originator: participant of Memento 285, 285c, 286i
originator 284
overloading: used to implement Proxy 211; used to implement Visitor 72, 337

P

parameterized types 21, 361, see also template: compared with inheritance 22; compared with composition 22
parent class, see class, parent
parent references: defined in Composite 166
parser 247
part-whole, see recursive composition: see also aggregation
Pascal 4
passive iterator, see iterator, passive
PassivityWrapper 182
path: specifying multi-segment shapes 57
pattern language 356
Pattern Languages of Programs 357
pattern matching 243
persistence 209
Picture 163c, 164o
PLoP, see Pattern Languages of Programs
pluggable adapter 142: implementation of 144145, 144c, 145c, 148, 149c
PMFactory 50c
PMIconWindow 151, 151c
PMWindow 151, 151c
PMWindowImp 152, 152c, 158159
Point 373
Policy, see Strategy
polymorphic iteration 258: implementing in C++ 261
polymorphism 14, 361: used with inheritance 18
postorder traversal, see traversal, postorder
preorder traversal, see traversal, preorder
PreorderIterator 67: member functions 6869
Presentation Manager 35, 48, 52, 56, 57, 87, 151, 158
PricingVisitor 341
PrintDialog 223o, 224i
private inheritance 361, see also inheritance, implementation
Product: participant of Builder 98c, 99; participant of Factory Method 108, 108c
product objects 49: changing at run-time 119; creating in Abstract Factory 90; exchanging 89; family of 87; varying representation of 100
protection proxy, see proxy, protection
protocol 361
Prototype 117: compared with Abstract Factory 126, 135; combined with Command 238; compared with Factory Method 116, 120; in catalog summary 9; participant of Prototype 119, 119c; used to implement Abstract Factory 90
prototype 117
prototype manager 121
prototyping phase of lifecycle 353
Proxy 207: combined with Iterator 262; compared with Decorator 220; in catalog summary 9
Proxy: participant of Proxy 209co, 209
proxy 207: protection 208, 210; remote 208, 210; virtual 208, 210
pseudocode 16, 16c, 365c
Publish-Subscribe, see Observer
pull model 298
pull-down menu, see menu, pull-down
purpose of design pattern, see design pattern, purpose
push model 298

Q

QOCA: use of Adapter 143; use of Interpreter 255; use of Memento 291

R

RApp: use of Strategy 323
RealSubject: participant of Proxy 209co, 210
Receiver: participant of Command 236, 236c, 237i, 238
receiver 361: decoupling from sender 346; implicit 224
Rect 374
Rectangle 20, 20c
recursive composition 36, see also Composite: iteration over 262; of document structure 36; of graphic elements 163; of part-whole structures 164
redesign, causes of 24
redo, see undo/redo
refactoring 326, 353
reference counting 210
RefinedAbstraction: participant of Bridge 153c, 154
regular expression 243: representing in Smalltalk 248
RegularExpression 244c
remote proxy, see proxy, remote
RepetitionExpression 244co, 343: implemented in Smalltalk 249
request 11, 361: automatic forwarding of 229; encapsulation of 59, see also Command; guaranteed receipt of 226; representing 227; sequencing 234
Responder 232
reuse: black-box 19, 354, 359; by composition 19; by parameterized types 21; by subclassing 19; code 26; designing for 2425; frameworks 26; internal 25; maximizing 23; of implementation 18; toolkits 26; white-box 19, 354, 362
Rich Text Format 97
robust iterator, see iterator, robust
Room 82c, 83
RTF, see Rich Text Format
RTFReader 97, 97c
RTL Smalltalk compiler: use of Composite 172; use of Strategy 323

S

scope of design pattern, see design pattern, scope
Scrollbar 50c
ScrollDecorator 176o, 176c
Scroller 45, 46o
Self 4, 121, 309
sender: decoupling from receiver 346
SequenceExpression 244co, 343: implemented in Smalltalk 249
sequencing requests 234
shallow copy, see copy, shallow
Shape 139, 140c, 146
shrinkability 320
signature 13, 361
SimpleCompositor 42, 42c, 315, 315c, 321
single static assignment form, SSA 172
single-dispatch, see dispatch, single
Singleton 127: C++ implementation 129, 131; in catalog summary 9; registry of 130; subclassing 130; used to implement Abstract Factory 90
Singleton: participant of Singleton 127c, 128
Sketchpad 125
SkipList 258c, 265
skiplist 258
Smalltalk-80, see also ObjectWorks\Smalltalk, Smalltalk/V: use of Builder 105; use of Composite 172; use of Factory Method 115; use of Interpreter 251; use of Iterator 270; use of Observer 303; use of Singleton 133; use of Visitor 344
Smalltalk/V: use of Interpreter 251; use of Mediator 278, 281
smart pointers 209
smart references 209
software platform: isolating application from 24
Solitaire, see Singleton
SolverState 283284
SPECTalk: use of Interpreter 255
spelling checking 64
SpellingChecker 7173
SpellingCheckerVisitor 75
StandardMazeBuilder 103
State 305: C++ idiom for, see envelope-letter idiom; in catalog summary 9; use of delegation in 21
State: participant of State 306, 306c
state: accumulating during traversal 336; avoiding inconsistent 308; extrinsic 196; incremental changes to 287; intrinsic 196; sharing 308, see also Flyweight
state transitions: atomic 308; defining 308; table-driven 308
Strategy 315: compared with Decorator 179; in catalog summary 8; Lexi's use of 42; use in Choices 193; use in Model/View/Controller 6; use of delegation in 21
Strategy 180o: making optional 320; participant of Strategy 316c, 316
strategy 315
Stream 183, 183c
StreamDecorator 183, 183c
stretchability 320
Stroustrup, Bjarne 160
structural pattern 10, 137: comparison between class and object scope 137; discussion of 219
subclass, see class, subclass
subclassing: extending functionality by 24
Subject 301: avoiding dangling references to 297; combining with Observer 300; participant of Observer 294c, 295, 295i, 300c, 347i; participant of Proxy 209co, 210
subject 294: mapping to observers 297; observing more than one 297
subsystem 361: simplifying interface to, see Facade
subtype, see type, subtype
successor 224: connecting in chain 227; implementing chain of 225
superclass 361, see also class, parent
supertype, see type, supertype
Surrogate, see Proxy
Sutherland, Ivan 125
swaps 323

T

Target: participant of Adapter 141, 141c
TCP protocol 309
TCPConnection 305, 305c, 309
TCPState 305, 305c, 310
template 21, see also parameterized types: used to implement Command 239; used to implement Factory Method 113; used to implement Strategy 319, 323
Template Method 325: calling Factory Methods 116; in catalog summary 9; naming conventions for 329; used to implement Iterator 270
template method 326
terminal symbol 246: shared using Flyweight 247
TerminalExpression: participant of Interpreter 245c, 246
TEX 42, 97, 316
TeXCompositor 42c, 315, 315c, 322
TextShape 139, 140c, 146, 147
TextView: use in Adapter 139, 140c, 146; use in Decorator 176c, 176o
ThingLab 125
THINK: use of Command 242; use of Observer 303
Token, see Memento
Tool 117, 118c, 313, 313c
toolkit 26, 233, 362: see Andrew; see Booch Components; see Fresco; see InterViews; see IRIS Inventor; see Object Windows; see QOCA; see THINK
Transaction, see Command
transaction 236
transparent enclosure 43, see also Decorator
traversal of aggregate objects, see also Iterator: across class hierarchies 336; assigning responsibility for in Visitor 339; inorder, preorder, postorder 262
TreeAccessorDelegate 145, 145c
TreeDisplay 142, 144, 144c, 145c
two-way adapter, see adapter, two-way
type 13: compared with class 16; C++, definition in 17; Eiffel, definition in 17; Smalltalk, definition in 17; subtype 13; supertype 13
type-checking 332: to identify requests at run-time 228; see also dynamic_cast
TypeCheckingVisitor 332c

U

undo/redo 5960, 6264, 235, 238, 283, 287: avoiding error accumulation during 239
Unidraw: use of Adapter 143; use of Chain of Responsibility 232; use of Command 232, 242; use of Factory Method 111; use of Iterator 270; use of Mediator 282; use of Memento 289; use of Observer 303; use of Prototype 126; use of State 313
UnsharedConcreteFlyweight: participant of Flyweight 199
updates: encapsulating complex 299; limiting unexpected 296; protocol for in Observer 296; triggering 297

V

Validator 323
VariableExp 252
VariableRefNode 333c
ViewManager 281, 281o
Virtual Constructor, see Factory Method
virtual memory framework 192
virtual proxy, see proxy, virtual
Visitor 331: combined with Interpreter 247, 255; in catalog summary 9; interaction diagram for Lexi 74; use in Lexi 76; use in compiler example 190, 331; use of delegation in 21
Visitor 75, 337: participant of Visitor 334, 334c
visitor 74, 332
VisualComponent 176, 176c, 180
vocabulary, defining common 352

W

Wall 82c, 83
white-box reuse, see reuse, white-box
Widget 224c, 230, 275c, 278
widget 48, 87: Glyph hierarchy 50
WidgetFactory 87
Window 20c, 39, 54c, 55c, 152, 156: configuring with WindowImp 5758; interface 53
window systems 35: support in Lexi 51
WindowImp 55, 55c, 152, 152c, 157: subclasses 55
Windows, see Microsoft Windows
WindowSystemFactory 57
Wrapper, see Adapter, Decorator
WYSIWYG 33

X

X Window System 52, 56, 57, 151, 158
XIconWindow 151, 151c
XWindow 151, 151c
XWindowImp 152, 152c, 158