1. Figure 9-1, the class implementor, the class extender, and the class user role.
Call Class
Class User
Realize Class
Developer
Class Implementor
Refine Class
Class Extender

2. Figure 9-2, ARENA Game abstract class with user classes and extender classes.
League
Game 1 *
TicTacToe
Chess
Tournament

3. Figure 9-3, Declaration for the Tournament class.
-maxNumPlayers: int
+acceptPlayer(p:Player)
+removePlayer(p:Player)
+getMaxNumPlayers():int
+getPlayers(): List
+isPlayerAccepted(p:Player):boolean
public class Tournament {
private int maxNumPlayers;
/* Other fields omitted */
public Tournament(League l, int maxNumPlayers)
public int getMaxNumPlayers() {…};
public List getPlayers() {…};
public void acceptPlayer(Player p) {…};
public void removePlayer(Player p) {…};
public boolean isPlayerAccepted(Player p) {…};
/* Other methods omitted */ }

4. Figure 9-4, Examples of invariants, preconditions, and postconditions in OCL attached as notes to the UML model.
«invariant»
«precondition»
getNumPlayers() <
getMaxNumPlayers()
getMaxNumPlayers() > 0
Tournament
«postcondition» isPlayerAccepted(p)
-maxNumPlayers: int
«precondition» !isPlayerAccepted(p)
+getNumPlayers():int
+getMaxNumPlayers():int
«postcondition» !isPlayerAccepted(p)
+acceptPlayer(p:Player)
«precondition» isPlayerAccepted(p)
+removePlayer(p:Player)
+isPlayerAccepted(p:Player):boolean

5. Tournament invariant context Tournament inv:
self.getMaxNumPlayers() > 0

6. Tournament.acceptPlayer contract
context Tournament::acceptPlayer(p) pre:
not isPlayerAccepted(p)
getNumPlayers() < getMaxNumPlayers()
context Tournament::acceptPlayer(p) post:
isPlayerAccepted(p)
getNumPlayers() + 1

7. Tournament.removePlayer contract
context Tournament::removePlayer(p) pre:
isPlayerAccepted(p)
context Tournament::removePlayer(p) post:
not isPlayerAccepted(p)
getNumPlayers() - 1

8. Figure 9-5, Method declarations for the Tournament class annotated with preconditions, postconditions, and invariants
public class Tournament {
/** The maximum number of players  * is positive at all times. maxNumPlayers > 0  */
private int maxNumPlayers;
/** The players List contains    * references to Players who are  * are registered with the  * Tournament. */
private List players;
/** Returns the current number of  * players in the tournament. */
public int getNumPlayers() {…}
/** Returns the maximum number of  * players in the tournament. */
public int getMaxNumPlayers() {…}
/** The acceptPlayer() operation  * assumes that the specified  * player has not been accepted * in the Tournament yet. !isPlayerAccepted(p) getNumPlayers()<maxNumPlayers isPlayerAccepted(p) getNumPlayers() = * @pre.getNumPlayers() + 1 */
public void acceptPlayer (Player p) {…}
/** The removePlayer() operation * assumes that the specified player * is currently in the Tournament. isPlayerAccepted(p) !isPlayerAccepted(p) getNumPlayers() = @pre.getNumPlayers() - 1 */
public void removePlayer(Player p) {…} }

9. Figure 9-6, Associations among League, Tournament, and Player classes in ARENA.
+start:Date
+end:Date
+getActivePlayers() *
{ordered} *
tournaments
Tournament
+start:Date
+end:Date
+acceptPlayer(p:Player) *
tournaments *
players
players
Player *
+name:String
+ String

10. Figure 9-7, Example situation with two Leagues, two Tournaments, and five Players.
tttExpert:League
chessNovice:League
winter:Tournament
xmas:Tournament
start=Dec 21
start=Dec 23
end=Dec 25
end=Dec 22
alice:Player
bob:Player
marc:Player
joe:Player
zoe:Player

11. Figure 9-8, There are only three basic types of navigation
Figure 9-8, There are only three basic types of navigation. Any OCL constraint can be built using a combination of these three types.
1. Local attribute
2. Directly related class
3. Indirectly related class
Tournament
League
League
start:Date
end:Date * * *
Player
Tournament * *
Player

12. Examples of constraints using each type of navigation
1. Local attribute
context Tournament inv:
end - start <= Calendar.WEEK
2. Directly related class
context Tournament::acceptPlayer(p) pre:
league.players->includes(p)
3. Indirectly related class
context League::getActivePlayers post:
result = tournaments.players->asSet

13. OCL forall quantifier
/* All Matches in a Tournament occur within the Tournament’s time frame */
context Tournament inv: matches->forAll(m:Match | m.start.after(t.start) and m.end.before(t.end))

14. OCL exists quantifier
/* Each Tournament conducts at least one Match on the first day of the Tournament */
context Tournament inv: matches->exists(m:Match | m.start.equals(start))

15. Figure 9-9, Analysis objects of ARENA identified during the analysis of Announce Tournament use case.
TournamentForm 1 1
applyForTournament()
TournamentControl *
selectSponsors()
advertizeTournament()
acceptPlayer()
announceTournament() * 1 1
Tournament
name *
start * * *
players
end
sponsors * *
Player
Advertiser
acceptPlayer()
removePlayer()
schedule() *
matches *
Match
matches *
start
status
playMove()
getScore()

16. Figure 9-10, a sequence diagram for the applyForTournament() operation.
:Player
:TournamentForm
:TournamentControl
t:Tournament
p:Player
applyForTournament(p)
isPlayerOverbooked(p)
getStartDate()
getEndDate()
getTournaments()
tournaments

17. Figure 9-11, Adding type information to the object model of ARENA.
TournamentForm 1 1
+applyForTournament()
TournamentControl *
+selectSponsors(advertisers):List
+advertizeTournament()
+acceptPlayer(p)
+announceTournament()
+isPlayerOverbooked():boolean * 1 1
Tournament
+name:String
+start:Date
+end:Date * * * *
players
sponsors * *
Player
Advertiser
+acceptPlayer(p)
+removePlayer(p)
+schedule() *
matches *
Match
matches *
+start:Date
+status:MatchStatus
+playMove(p,m)
+getScore():Map

18. Pre- and post-conditions for ordering operations on TournamentControl
+selectSponsors(advertisers):List
+advertizeTournament()
+acceptPlayer(p)
+announceTournament()
+isPlayerOverbooked():boolean
Pre- and post-conditions for ordering operations on TournamentControl
context TournamentControl::selectSponsors(advertisers) pre:
interestedSponsors->notEmpty and
tournament.sponsors->isEmpty
context TournamentControl::selectSponsors(advertisers) post:
tournament.sponsors.equals(advertisers)
context TournamentControl::advertiseTournament() pre:
tournament.sponsors->isEmpty and
not tournament.advertised
context TournamentControl::advertiseTournament() post:
tournament.advertised
context TournamentControl::acceptPlayer(p) pre:
tournament.advertised and
interestedPlayers->includes(p) and
not isPlayerOverbooked(p)
context TournamentControl::acceptPlayer(p) post:
tournament.players->includes(p)

19. Specifying invariants on Tournament and Tournament Control
All Matches of in a Tournament must occur within the time frame of the Tournament
context Tournament inv: matches->forAll(m| m.start.after(start) and m.start.before(end))
No Player can take part in two or more Tournaments that overlap
context TournamentControl inv: tournament.players->forAll(p| p.tournaments->forAll(t| t <> tournament implies not t.overlap(tournament)))

20. Specifying invariants on Match
players *
Player
Tournament *
tournaments
players *
matches
Match *
A match can only involve players who are accepted in the tournament
context Match inv: players->forAll(p| p.tournaments->exists(t| t.matches->includes(self)))
context Match inv: players.tournaments.matches.includes(self)

21. «invariant» email <> nil
Figure 9-13, A simple example of contract inheritance: An invariant specified in a superclass must hold for all of its subclasses.
User
«invariant» <> nil
String
notify()
LeagueOwner
Player
Advertiser
Spectator

22. Figure 9-14, Embedded ODD approach
Figure 9-14, Embedded ODD approach. Class stubs are generated from the object design model.
Analysis
Analysis model
Document
analysis
RAD
System design
Subsystem
Design goals
decomposition
Object design
Initial object
design model
Generate class stubs
Initial class
stubs
Implementation
Commented code
Document
object design
ODD

23. Figure 9-16, new Round class and changes in the TournamentStyle, Tournament, and Round APIs.
League 1 *
TournamentStyle
getTournamentStyle()
:TournamentStyle
planRounds(Tournament)
legalNumPlayers(n:int)
:boolean
:List *
Tournament
players
tournaments *
name
start
end
Player
name:String
String
acceptPlayer()
removePlayer()
plan()
notify(Player,Message)
getMatches(Tournament)
{ordered}
players * *
Match
matches 1
Round *
start
score
status
plan()
getPreviousRound():Round
isPlanned():boolean
isCompleted():boolean
playMove(Player,Move)
getMoves():List

24. Constraints on TournamentStyle
Only tournaments without rounds and with the right number of players can be planned.
context TournamentStyle::planRounds(t:Tournament) pre: t <> nil and t.rounds = nil and legalNumPlayers(t)->contains(t.players->size)
All players are assigned to at least one match
context TournamentStyle::planRounds(t:Tournament) post: t.getPlayers()->forAll(p| p.getMatches(tournament)->notEmpty)
context TournamentStyle::planRounds(t:Tournament) post: result->forAll(r1,r2| r1<>r2 implies r1.getEndDate().before(r2.getStartDate()) or r1.getStartDate().after(r2.getEndDate())

25. Invariant on Round
A player cannot be assigned to more than one match per round
context Round inv: matches->forAll(m1:Match| m1.players->forAll(p:Player| p.matches->forAll(m2:Match| m1 <> m2 implies m1.round <> m2.round)))

26. Constraints on Round.plan()
Invoking plan() on a Round whose previous Round is completed results in a planned Round
context Round.plan() post: @pre.getPreviousRound().isCompleted() implies isPlanned()
A round is planned if all matches have players assigned to them
context Round.isPlanned() post: result implies matches->forAll(m|   m.players->size =     tournament.league.game.numPlayersPerMatch)
A round is completed if all of its matches are completed.
context Round.isCompleted() post: result implies matches->forAll(m| m.winner <> nil)

27. Constraints on KnockOutStyle
The number of players should be a power of two.
context KnockOutStyle::legalNumPlayers(t:Tournament) post: result Sequence[2..t.maxNumPlayers]->select(elem| floor(log(elem)/log(2)) = (log(elem)/log(2)))
The number of matches in a round is 1 for the last round. Otherwise, the number of matches in a round is exactly twice the number of matches in the subsequent round.
context KnockOutStyle::planRounds(t:Tournament) post: result->forAll(index:Integer|    if (index = result->size) then       result->at(index).matches->size = 1    else       result->at(index).matches->size = (2*result->at(index+1).matches->size))    endif)

28. Constraints on KnockOutRound
A player can play in a round only if it is the first round or if it is the winner of a previous round.
context KnockOutRound inv: previousRound = nil or matches.players->forAll(p| round.previousRound.matches->exists(m| m.winner = p))
If the previous round is not completed, this round cannot be planned.
context KockOutRound::plan() post: not implies not isPlanned()