Hi!
It's very common to have the same structure when handling resources that should be disposed after using -normally when they belong outside the image- like files, aliens, database transactions, mutex semaphores...
[
open the file
do something with the file
] ensure: [ close the file ]
[
create an alien
do something with the alien
] ensure: [ free the alien ]
[
open the transaction
do something with the transaction
transaction commit
] ensure: [ transaction if open, transacction rollback. ]
Some times, this structure is abstracted in a high order method(?) using blocks..
session inTransactionDo: [ "do something with the transaction" ]
Semaphore forMutualExclusion critical: [
�� "do something with the semaphore
]
Ok, Python and C# add the with and using statement, handling the resource disposing in a polymorphic way block of code is executed, like:
with aFile:
�� #use the file
or
using (aDatabaseTransaction){
� /* use the database transaction */
}
Even in Java 7 they've included a construction for auto-dispose of resources:
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
return br.readLine();
}
What about adding a polimorphic (for example) #releaseAfter: method like
Object>>releaseAfter: aBlock
� self retain.
� [ aBlock cull: self ] ensure: [ self dispose ]
Object>>dispose
� "hook for disposable resources"
Object>>retain
� "hook for resources which can be retained"
Alien>>dispose
� self free
File>>retain
� self open
File>>dispose
� self close
Stream>>dispose
� self close
Transaction>>dispose
� self isOpen ifTrue: [ self rollback ]
And so? this way resources can be handled in an uniform way.
Cheers,
Guille