// AOP example based on code by J. Hannemann and G. Kiczales

import java.util.HashSet; 
import java.util.HashMap; // for associating observees with observers

public abstract aspect ObserverPattern
{
    protected interface Observer
    {
	void update(Observed s);
    }

    protected interface Observed {}

    // structure to associate observers with observed
    protected HashMap<Observed,HashSet<Observer>> ObvHM =
	new HashMap<Observed,HashSet<Observer>>();
     
    protected HashSet<Observer> getObservers(Observed s)
    {
	HashSet<Observer> V = ObvHM.get(s);
	if (V==null) { V=new HashSet<Observer>(); ObvHM.put(s,V); }
	return V;
    }

    public void addObserver(Observed s, Observer v)
    {
	getObservers(s).add(v);
    }
    public void removeObserver(Observed s, Observer v)
    {
	getObservers(s).remove(v);
    }

    abstract protected pointcut ObservedChange(Observed s);

    // add code to notify observers after each ObservedChange
    after(Observed s): ObservedChange(s)
	{
	    for(Observer v:getObservers(s)) v.update(s);
	}
}// aspect ObserverPattern


// sample usage of abstract pattern:

class stock
{
    public double price;
    public final String symbol;
    public stock(String s, double p)
    { symbol = s; price = p;
	SymMap.put(s,this);
    }
    public void changePrice(double dp) { price += dp; }

    // global map from symbols to stock objects
    public static HashMap<String,stock> SymMap= new HashMap<String,stock>();
}//stock

class investor
{
    public final String name; // name of investor
    public HashMap<String,Integer> investments; // maps symbols to num. shares
    public investor(String n)
    {
	name = n;
	investments = new HashMap<String,Integer>();
    }
    public void sell(String sym, int shares)
    {
	Integer s = investments.get(sym);
	if (s==null || s<shares) return;
	investments.put(sym,s-shares);
    }
    public void buy(String sym, int shares)
    {
	Integer s = investments.get(sym);
	if (s==null) s = 0;
	investments.put(sym,s+shares);
    }    
}//investor


// compile with ajc -8

class bullInvestor extends investor
{ public bullInvestor(String n) { super(n); } }
class nervousInvestor extends investor
{ public nervousInvestor(String n) { super(n); } }

// All other code must be inside aspects.

// Create an aspect that outputs appropriate trace messages whenever
// an investor sells or buys stock, and when a stock changes its price.
aspect Output
{
}

/*
Create two "subclasses" of investor: a bullInvestor that buys stock 
agreesively when the price of a stock drops below $20.  Create another
nervousInvestor that sells all shares of a stock whenever its price drops
below $30.  Create other investors optionally.

Write all code inside an aspect that extends the abstract aspect.
*/