I, J. Key-value observing (KVO), Label component, 32 text property, 39

Transcription

1 Index A Abstract factory pattern, 207 concrete factory, 213 examples in Cocoa, 227 groups of objects, 212 implementing, 213 abstract factories, 214 concrete factories, operations, pitfalls, 227 variations, 217 hiding the abstract factory, 217 using a singleton, 220 using the prototype pattern, Adapter pattern, 253 examples in Cocoa, 266 implementing, migrating data, 261 integrating new components, 257 operations, 259 pitfalls, 266 variations, 261 defining a wrapper class, two-way adapter, Assistant editor. See Xcode, assistant editor Auto layout. See Xcode, auto layout B Bridge pattern, 271 examples in Cocoa, 288 exploding class hierarchy, 275 implementing, 277 collapsing the bridge, creating channels, creating new features, creating the bridge, dealing with messages, multiplicity of features, 274 pitfalls, 288 separate abstraction from implementation, 275 variations, Builder pattern, 233 avoiding inconsistent configurations, 244 builder as an intermediary, 238 convenience initializers, 237 examples in Cocoa, implementing, 239 changing the object, consuming the builder, 240 defining the builder class, 239 operations, 238 pitfalls, 247 telescoping initializers, 236 variations, C Calling components, 4 Chain of responsibility pattern examples in Cocoa, 396 first link, 387 implementing, applying the pattern, creating the chain, links in the chain, 387 pitfalls, 396 variations, 391 implementing the outcome, links notification, in chain, using the factory method pattern,

2 554 Index Classes, 60 Cloning, prototype pattern. See Prototype pattern Cocoa, 3 Command Line Tool projects. See Xcode, Command Line Tool projects Command pattern, 401 command object, 404 deferred execution, 403 examples in Cocoa, 418 execution method, 404 implementing, 405 command implementation, command protocol, 405 concurrency protections, creating an undo feature, 410 invoker, 404 packaging method invocations as objects, 403 pitfalls, 418 receiver object, 404 undo operations, 403 variations, 411 composite commands, macros, using closures, Composite pattern, 311 composites, examples in Cocoa, 320 fixed structure, 318 implementing, leaf nodes, 315 pitfalls, tree hierarchies, 314 Concurrency asynchronous method, 329 barriers, 132, 160, 171, 433 blocks, 123, 168, 327 dispatch_async function, 143 dispatch_barrier_async function, 132 dispatch_barrier_sync function, 347, 433 dispatch_group_async function, 124 dispatch_group_create funciton, 124 dispatch_group_wait function, 124 DISPATCH_QUEUE_CONCURRENT value, 124 dispatch_queue_create function, 124, 143, 433 DISPATCH_QUEUE_SERIAL value, 126, 143 dispatch_queue_t type, 124 dispatch_semaphore_create function, 144 dispatch_semaphore_signal function, 145 dispatch_semaphore_wait function, 144, 170 dispatch_sync function, 127, , 347, 410, 433 DISPATCH_TIME_FOREVER value, 124, 169 dispatch_time function, 169 FIFO ordering, 174 global queues, 153 NSEC_PER_SEC, 169 overlapping calls, 124 println function, 171 queues, 124, 327, 372 concurrent, 124 serial, 126, 374 reader/writer locking, 132 semaphores, 144, 160, 174, 363 semaphore_wait function, 177 serial execution, 126 serializing access to data, singleton pattern, thread sleep, 147 Control hierarchy, 34 CORBA distributed systems, 360 Core Data, 486 D Decorator pattern, 293 avoiding subclasses, 298 examples in Cocoa, 307 implementing, wrapped object, 298 side-effect pitfall, 306 variations, 300 consolidated decorators, creating decorators with new functionality, wrapper classes, 298 Deep copying, 87 Design patterns, 3 4 Abstract factory pattern. (see Abstract factory pattern) adapting patterns, 7 (see also Adapter pattern) as a form of insurance, 3

3 Index 555 assessing applicability, 5 avoiding tightly coupled components, 6 bridge pattern (see Bridge pattern) builder pattern (see Builder pattern) calling components, 4 command pattern (see Command pattern) composite pattern (see Composite pattern) decorator pattern (see Decorator pattern) façade pattern (see Façade pattern) factory method pattern (see Factory method pattern) flyweight pattern (see Flyweight pattern) increasing modularity, 6 informal strategies, 3 inconsistencies, 4 increasing abstraction, 6 personal experiences, 4 limitations, 6 7 mediator pattern (see Mediator pattern) memento pattern (see Memento pattern) minimizing impact of changes, 6 MVC pattern (see Model View Controller (MVC) pattern) object pool pattern (see Object pool pattern) object template pattern (see Object template pattern) observer pattern (see Observer pattern) patterns as receipes, 7 prototype pattern (see Prototype pattern) proxy pattern (see Proxy pattern) quantifying value of, 5 6 reducing code duplication, 6 singleton pattern (see Singleton pattern) strategy pattern (see Strategy pattern) template pattern (see Template pattern) visitor pattern (see Visitor pattern) Detecting shake gestures, 421 Double dispatch, 508 E Encapsulation, 55 F Façade pattern, 325 consolidating complexity, 329 enforcing a specific order, 328 examples in Cocoa, implementing, 330 applying the façade, pitfalls, 333 variations, 332 Factory method pattern, 187 abstract class, 192 examples in Cocoa, implementing, 192 base class, delgating decisions, global factory method, logic encapsulation, 191 operations, 192 pitfalls, 201 selecting protocol implementations, variations, Flyweight pattern, 339 common data, 342 examples in Cocoa, extrinsic data, 343 flyweight factory, 343 implementing, 343 concurrency protections, factory class, flyweight implementing class, flyweight protocol, intrinsic data, 343 pitfalls, 352 concurrent access, 352 extrinsic data duplication, 352 misapplication, 353 mutable extrinsic data, 352 over-optimization, variations, First-in first-out (FIFO), 174 G, H Gang of Four (GoF), 4 Grand central dispatch. See Concurrency

4 556 Index I, J IBAction attribute. See Xcode, actions attribute, 38. See also Xcode, outlets Informal strategies. See Design Patterns, informal strategies Inspectors, 32 33, 47 Instances, 60 Interface Builder. See Xcode, interface builder K Key-value observing (KVO), L Label component, 32 text property, 39 M Mediator pattern, 423 breaking dependencies, 428 colleagues, 428 examples in Cocoa, 444 observer pattern, 445 implementing, 429 concurrency protections, conforming to the peer protocol, creating the mediator, defining the peer protocol, 429 mediator object, 428 NSNotificationCenter class, peer objects, 428 pitfalls, variations, 435 additional mediator logic, generalized messages, generalized relationships, Memento pattern, 473 capturing the complete state of an object, 473 caretaker object, 476 example in Cocoa, 484 implementing, 478 immutable state, 478 memento implementing class, memento protocol, 478 originator protocol, 478 limitations of single undo operations, 476 memento, 477 operations, 477 originator object, 476 pitfalls, unwinding object state, 477 variations, Multi-threaded. See Concurrency Model View Controller (MVC) pattern, 527 adding structure to an application, 528 controllers, 529, 532 cross-cutting concerns, 529, 533 domain data, 531 examples in Cocoa, 551 implementing, 533 common code, 534 controller, framework, 535, Model.swift File, 536 repository pattern, views, model, 529, 531 pitfalls, 550 sections, 529 separation of concerns, 528 variations, 550 view, 529 view model, 532 Multi-threaded. See Concurrency N Navigator pane, 21 NSCopying protocol, NSData class, 486 NSFileHandle class, 329 NSJSONSerialization class, 481 NSKeyedArchiver class, 486 NSKeyedUnarchiver class, 487 NSLayoutManager class, 334 NSMutableDictionary class, 482 NSNotificationCenter class, 444 NSNumber class, 353 NSObject, 86 NSProxy class, 375 NSUndoManager class, 419

5 Index 557 O Objective-C bridging header, 222 enumerations, 221 file template, 221 KVO, 467 selectors, 445 Object library. See Xcode, object library Object pool pattern, 137 amortizing expensive initializers, 139 common examples, 139 concurrent access, 140 examples in Cocoa, fair and equitable use, 139 implementing, 141 concurrecy protections, 142 ensuring object availability, generic pool class, 141 object creation policy, 146 managing identical, interchangeable objects, 139 object pool, object reuse, 139 operations, 139 pitfalls, 148 variations, 157 allocation strategy, 158, blocking strategy, 167 calling threads, 167 creation strategy, 158 demand mismatch, 167 eager creation strategy, 158 elastic pools, empty pool strategy, 158, examples in Cocoa, 183 exhausted pools, expectation gap, 182 failing request strategy, FIFO allocation strategy, 179 lazy creation strategy, 159 least used strategy, 181 object creation strategy, 158 over and under utilization, 183 peak demand, 175 pitfalls, 182 reapers, 177 replacing objects, 163 responding to demand, 175 reuse strategy, 158, setting pool capacity, 168 temporary objects, 177 trusting and untrusting reuse strategy, 163 Object template pattern, 55, 59 benefits, 61 decoupling, encapsulation, evolving public presentation, examples in Cocoa, 67 implementing, operations, 59 pitfalls, 67 Observer pattern, 447 events, 450 examples in Cocoa, 466 observing property changes, user interface events, implementing, 451 applying the subject protocol, 453 creating the subject class, notifications, 451 observers, 450 pitfalls, 466 notification object pitfall, subjects, 450 variations, 455 generalizing notifications, short-lived subjects, weak references, Open/closed design principle, 493 OS X Command Line Tool projects. See Xcode, Command Line Tool projects Outlets. See Xcode, outlets P, Q Patterns. See Design patterns Playgrounds. See Xcode, playgrounds Prototype pattern, benefits, cloning reference types, NSCopying protocol, NSObject base class, 86 cloning value types, 81 copying arrays, deep copying, examples in Cocoa,

6 558 Index Prototype pattern (cont.) implementing, operations, 81 pitfalls exposure distortion, 103 nonstandard protocols, 103 shallow vs. deep copying, 102 prototype object, 82 separating object creating from use, shallow copying, Prototyping Code. See Xcode, playgrounds Proxy pattern, authorization policy, 369 decoupling an operation from its use, 361 examples in Cocoa, 375 expensive operation problem, 359 general form of, 360 implementing, 362 access restriction proxy, 368 consolidating HTTP requests, 364 deferred operations, expensive operation proxy, remote object proxy, 362 intercepting requests, 362 pitfalls, 375 proxy object, 360 remote object problem, 359 RESTful web services, 360 restricted access problem, 359 variations, reference counting, 370, 373 R Reading from the console, 329 Repository pattern, RESTful web services, 360 S Shallow copying, 87 Single dispatch, 510 Singleton pattern, 113 examples in Cocoa, 130 global constant, 118 implementing, 118 concurrency, 122 conventional implementation, 121 quick implementation, 118 leakage, 128 pitfalls, 128 bad optimization, 129 concurrency, 129 inconsistent concurrency, 129 shared code, 129 reference types, 118 shared resource encapsulation problem, 115 using structs, 128 SportsStore application, 25 abstract factory pattern, 227 adapter pattern, 267 bridge pattern, 288 builder pattern, 248 chain of responsibility, 397 command pattern, 418 composite pattern, 320 creating the project, 27 data model, 28 decorator pattern, 307 façade pattern, 335 factory method pattern, flyweight pattern, interface mockup, 26 mediator pattern, 446 memento pattern, 487 object pool pattern, 149 object pool pattern variations, 183 object template pattern, 67 observer pattern, prototype pattern, 107 proxy pattern, 375 singleton pattern, 130 storyboard, 31 strategy pattern, 501 template method pattern, 524 view controller, 29 visitor pattern, 515 Strategy pattern, 491 context class, 494 defining new algorithms, 494 defining strategy and context class, 495 delegation, 494 examples in Cocoa, 498 selectors, UITableView data source,

7 Index 559 implementing, 495 pitfalls, 498 selecting algorithms at runtime, 494 variations, Structs, 60 Swift, 3, 7 access protection, 9, 71 internal keyword, 71 private keyword, 21, 71, 298, 372 public keyword, 71 adding file, 22 class keyword, applied to protocols, 452 copying arrays, double dispatch, extension, 260 final keyword, 119 global constants, 118 lazy initialization, 119 thread safety, 119 global == functions, attribute, 47 import statement, 12 KVO, method references, NSCoding protocol, 486 NSCopying protocol, 85 86, 223 NSFileHandle class, 364 NSNotificationCenter class, NSNumber class, NSObject, attribute, 163, 165, 223, 445 println function, 116 concurrency, 171 reduce function, 75 selectors, 445 single dispatch, 510 structs, static properties, 121 Table View Cell component, 40 tuples, 30 value types, 81 T Table data source, Template pattern, changing steps in an algorithm, 517 examples in Cocoa, 524 implementing, partially-defined algorithm, 520 pitfalls, 524 variations, Tightly coupled components, 57 Tuples. See Swift U UITableViewDataSource protocol, 44 UITextView class, 334 Unified Modeling Language (UML), 5 V, W Value types, 81 View controller, 29 Visitor pattern, algorithm selection, 507 algorithm separation, 507 examples in Cocoa, 515 implementing, applying visitors, 514 conforming to the protocol, 511 visitor creation, managing heterogeneous objects, 505 pitfalls, 514 variations, 514 X, Y, Z Xcode, 7 actions method, 47 assistant editor, 17, 37 Attributes Inspector, 32 auto layout, 34 building and running projects, 24 Command Line Tool projects, 9, 18 Connections Inspector, 47 developer mode, enabling, 11 interface builder, 31 interface layout, 20 console, 21 control hierarchy, 34 debug pane, 21 editor, 21

8 560 Index Xcode (cont.) inspector pane, 21, 32 navigator pane, 21 ios simulator, 35 Label component, 32 object library, 32 outlets, 37 playgrounds, 9 assitant editor, 17 creating, 10 displaying UI components, 16 displaying value histories, 12 displaying value timelines, 15 Size Inspector, 33 Swift file, adding, TableView component, 33 data source, 44 UITableViewDataSource protocol, 44