Domain-Driven Design: Tackling Complexity in the Heart of Software

Share Pie
seems to be obscuring the
relationship of the 
Share Pie
and the 
Shares
. What would happen if we made 
Share Pie
a 
VALUE
OBJECT
?
This would mean that 
increase(Map)
and 
decrease(Map)
would not be allowed, because the
Share Pie
would have to be immutable. To change the 
Share Pie
's value, the whole 
Pie
would
have to be replaced. So you could have operations such as 
addShares(Map)
that would return a
whole new, larger 
Share Pie
.
Let's go all the way to 
CLOSURE OF OPERATIONS
. Instead of "increasing" a 
Share Pie
or adding
Shares
to it, just add two 
Share Pies 
together: the result is the new, larger 
Share Pie
.

---

We can partially close the 
prorate()
operation over 
Share Pie 
just by changing the return type.
Renaming it to 
prorated()
emphasizes its lack of side effects. "Shares Math" starts to take shape,
initially with four operations.
Figure 10.20.
We can make some well-defined 
ASSERTIONS
about our new 
VALUE OBJECTS
, the 
Share Pies
. Each
method means something.
[View full width]
public class SharePie {
private Map shares = new HashMap();
//Accessors and other straightforward methods are omitted
public double getAmount() {
double total = 0.0;
Iterator it = shares.keySet().iterator();
while(it.hasNext()) { 
The whole is equal to the sum of its parts.
Share loanShare = getShare(it.next());
total = total + loanShare.getAmount();
}
return total;
}
public SharePie minus(SharePie otherShares) {
SharePie result = new SharePie();
Set owners = new HashSet();
owners.addAll(getOwners());
owners.addAll(otherShares.getOwners()); 
The difference between two
Pies
is the
 difference between each owner's share.
Iterator it = owners.iterator();
while(it.hasNext()) {
Object owner = it.next();
double resultShareAmount = getShareAmount(owner) –
otherShares.getShareAmount(owner);

---

result.add(owner, resultShareAmount);
}
return result;
}
public SharePie plus(SharePie otherShares) { 
The combination of two
Pies
is the
 combination of each owner's share.
//Similar to implementation of minus()
}
public SharePie prorated(double amountToProrate) {
SharePie proration = new SharePie();
double basis = getAmount(); 
An amount can be divided proportionately among all
 shareholders.
Iterator it = shares.keySet().iterator();
while(it.hasNext()) {
Object owner = it.next();
Share share = getShare(owner);
double proratedShareAmount =
share.getAmount() / basis * amountToProrate;
proration.add(owner, proratedShareAmount);
}
return proration;
}
}