observer pattern question #2 (notification chain)

[Alan Isaac]

I have two questions about the "observer pattern" in Python.

This is question #2. (I'll put the other is a separate post.)



Consider this standard example of the observer pattern in Python:



<URL:http://en.wikipedia.org/wiki/Observer_pattern>



Now suppose I have a variant.

(I am not a programmer, so this may be a separate related pattern.)

To make it a little concrete and relate it to the discussion at

<URL:http://www.dofactory.com/Patterns/PatternObserver.aspx#_self1>,

suppose there are stocks, mutual funds, and investors.

Let us say that funds are observers for stocks,

and investors are observers for funds.

Once a "month" I want all stocks to notify their observing funds

of their end-of-month price, and *then* all fund to notify their

observing investors of their end-of-month investment value.



I see a couple differences from the standard pattern referenced above,

and one problem.



Differences:



- observer/subject linked hierarchy (funds are both observers and subjects)

- many-many relation (a fund is an observer of many stocks)



I think (?) these differences are inessential, but the

second does create the following problem: if I do not want

a fund to notify an its investors until all stocks have

reported, what is the best way to determine the "last report

in" event?



Here is one way: create a ``reportreceived`` dict that maps

stocks to True or False, and after each stock notification

change False to True and check ``all(reportreceived.values())``

to determine whether it is ok to notify investors. When it

is ok, then notify investors and reset all the

``reportreceived`` values.



This is meant to be a general description so please do not

focus on the "real world" aspects, which are only for

illustration.



Thank you,

Alan Isaac

 

[Alan Isaac]

A question related to the observer pattern...

Suppose I have a variant: there are stocks, mutual funds, and investors. Let us say that funds are observers for multiple stocks, and investors are observers for funds. Once a "month" all stocks notify their observing funds of their end-of-month price, and *then* all fund to notify their observing investors of their end-of-month investment value.

What is a good way to enforce this timing? (I.e., a fund should not notify an its investors until all stocks have reported.)

Here is one way:

- for each fund, create a ``reportreceived`` dict that maps stocks to booleans (initially False)
- as each stock notifies its funds, the fund changes False to True and checks ``all(reportreceived.values())`` to determine whether it is ok to notify investors.
- When it is ok, the fund notifies investors and resets all the ``reportreceived`` values.

Is this sensible enough? What are standard and better ways?

Thank you,
Alan Isaac

PS I am drawing on the description of the observer pattern at
<URL:http://www.dofactory.com/Patterns/PatternObserver.aspx#_self1>
The real world aspects are just to add some concreteness.

 

[J. Cliff Dyer]

That looks like a good approach to me. Alternative to a dict would just
be a count of reported stocks tested against the total number of stocks,
but if one stock reports twice before another reports at all, you'll get
funny results. Your method is probably better, in the general case.

Cheers,
Cliff

 

[Alan Isaac]

looks like a good approach to me

OK, thanks.

Another approach is to begin with a set of stocks

and remove them as they report. You can then trigger

a report with the empty set instead of repeatedly

calling ``all``. After a report the set can be

"refilled".



Cheers,

Alan Isaac

 

[Ville M. Vainio]

Here is one way:

- for each fund, create a ``reportreceived`` dict that maps stocks to booleans (initially False)
- as each stock notifies its funds, the fund changes False to True and checks ``all(reportreceived.values())`` to determine whether it is ok to notify investors.
- When it is ok, the fund notifies investors and resets all the
``reportreceived`` values.

Is this sensible enough? What are standard and better ways?

You could explore the performance of popping items from the dict/set,
instead of toggling the value so to true. Once the dict is empty, you
are done. Of course the dict/set would be called
stocks_that_havent_reported, or a saner & shorter variant of that.

The idea here is that checking a dict/set for emptiness is
close-to-zero time operation.

 

[Ville M. Vainio]

OK, thanks.

Another approach is to begin with a set of stocks

and remove them as they report. You can then trigger

a report with the empty set instead of repeatedly

calling ``all``. After a report the set can be

"refilled".

Ah, and I obviously didn't read the whole thread before posting ;-)