## The Observer Design Pattern in Python.

# Observers: stock investors
# Observees: individual stocks.

# Each Observee class must implement the following methods:
#    attach(newobserver) : attaches a new observer
#    remove(someobserver) : removes an observer
#    notify() : notifies all attached observers

# Each Observer class must implement a 
#    update(sourceobservee): respond to notifications from
# the observee.

# When something inside an observee object changes, which is of potential
# interest to an observer, all the observers attached to the object are
# notified.  The notify function calls the update function inside each
# observer. Different kinds of observers can implement different update
# functions, so they can respond to the notification differently.  Usually,
# observer classes are subclasses of a common superclass for all observers.

# Design patterns such as Observer are ways in which we can structure
# objects effectively.  The observer pattern is a template for objects
# to interact autonomously (i.e., the interaction is encapsulated completely
# within the objects).

# The observee class:
class stock:
    def __init__(self,sym, initprice):
	self.symbol = sym
	self.price = initprice
	self.oldprice = 0      # needed to observe changes
	self.observers = []    # list of attached observers
        self.justsplit = False # signal to indicate when stock split
    # constructor

    def changeprice(self,dp):  # records a change in price
	self.oldprice = self.price
	self.price += dp  # use negative numbers for decrease
        self.notify()     # notify all observers    ***************
    # changeprice

    def split(self):  # stock splits - shares should double
        self.price = self.price / 2.0
        self.oldprice = self.price # don't confuse split with drop in price
        self.justsplit = True   # set signal that indicates split occured
        self.notify()           # notify observers of the split ********
        self.justsplit = False  # reset justsplit after notify.
    # split
    
    ##### Additional methods implement the observer pattern interface:
    def attach(self,x):  # add new observer x
	self.observers.append(x)

    def remove(self,x): # remove observer x
        self.observers.remove(x)

    def notify(self):   # notify all observers
    	i = 0
	while i<len(self.observers):
		self.observers[i].update(self)
		i += 1
	# while
	# can also use: for x in self.observers: x.update(self)
    # notify
# stock observee class


### Observer classes to respond differently to notifications:
### Each observer class needs to implement update differently.

### But observer classes will also have much in common, so we
### put them in a superclass

class investor:    # investor superclass
	def __init__(self):
		self.investments = {}  # hash table stores
				       # number of shares of
				       # each stock.
	# constructor
	
	def invest(self,stk,shares):  # invest in stock stk:
		self.investments[stk.symbol] = shares
		stk.attach(self)  #add self to stock's observer list

	def printportfolio(self):
		print "porfolio:"
		for key,val in self.investments.items():
			print key,":",val,"shares"
		print "-------"
# investor superclass

# We don't really want to create instances of 'investor', because an 'investor'
# doesn't have an update functions - it cannot react to a notification from
# an observee.  We only wrote this class because both bullinvestors and
# bear investors have this much in common.


### "Concrete" Observer classes must implement the update function.
class bullinvestor(investor):   # bullinvestor is a SUBCLASS of investor

        def __init(self):
            investor.__init__(self)  # call the superclass constructor
        # init

        ##### observer pattern interface:
	def update(self,obv):  # respond to observee obv notification:
                if (obv.justsplit):  # buy more after split
                        self.investments[obv.symbol] *= 2  # double shares
                if (obv.oldprice>obv.price): # stock fell; BUY!
			print "BUY BUY BUY"
                        self.investments[obv.symbol] += 200 # buy 200 shares
	# update
	
# bullinvestor


class bearinvestor(investor):

        def __init(self):
                investor.__init__(self)  # call the superclass constructor
        # init

        ##### observer pattern interface:
	def update(self,obv):  # respond to observee notify:
                if (obv.justsplit):  # double shares after split
                        self.investments[obv.symbol] *= 2  # double shares
                if (obv.oldprice>obv.price): # stock fell; SELL OFF!
			print "DUMP",obv.symbol,"NOW!"
                        self.investments[obv.symbol] = 0
                        obv.remove(self)  # stop observing this stock
		if (obv.oldprice<obv.price): # stock rose; BUY
			print "Let's buy some", obv.symbol
                        self.investments[obv.symbol] += 100
	# update
# bearinvestor


##### tests:

## observees:
intel = stock("INTC",20);
microsoft = stock("MSFT",40);
nvidia = stock("NVDA",10);

## observers

me = bearinvestor()
you = bullinvestor()

## attach observers to observees:
me.invest(intel,100)   # invest in 100 shares of intel
me.invest(nvidia,200)
you.invest(intel,300)
you.invest(microsoft,100)
me.printportfolio()

intel.changeprice(-1.5)    # automatically triggers update of all investors
microsoft.changeprice(-0.5)
nvidia.changeprice(1.0)
microsoft.split()
you.printportfolio()
# bullinvestor.printportfolio(you)  # same as you.printportfolio

#### The above tests demonstrates the potential of "object oriented
# abstraction": the algorithmic details of stock investment are encapsulated
# within the object-oriented structure of the program.


#### Better overall organization:
# instead of using variables like intel and microsoft to reprsent stocks,
# use instead a global hash table to hold the stock objects.  Don't confuse
# this hash table with the ones inside each investor-observer.

Stocks = {}
Stocks["IBM"] = stock("IBM",30)
Stocks["AAPL"] = stock("AAPL",50)  # apple computer stock
# each hash table entry is a pointer to a stock object

me.invest(Stocks["AAPL"],100)
you.invest(Stocks["IBM"],200)
Stocks["IBM"].changeprice(-2.0)
Stocks["AAPL"].changeprice(1.0)

# The advantage here is that the Stocks hashtable can be arbitrarily large.
# For example, we can pass the entire hashtable to another function.
# Secondly, we can lookup a stock object by just knowing its symbol.