Re: To wrap or not to wrap?

Aaron Fude <aaronfude@[EMAIL PROTECTED]
> writes:
>These functions catch exceptions and return null

  You must like the classic C idiom

if( f = fopen( "alpha", "r" ))
{ use( f );
  close( f ); }
else
{ handle_failure( "alpha", "r" ); }

  more than exception idioms like

try
{ f = fopen( "alpha", "r" );
  try
  { use( f ); }
  finally
  { close( f ); }}
catch( final Exception exception )
{ handleFailure( "alpha", "r", exception ); }

  I also like structured programing, and it is not easy
  for me to cope with the exception style. I hope that
  I at least have done the above translation correctly.

  The above code already looks complicated, but it becomes even
  more complicated, when you need to obtain and release
  /multiple/ resources. This should be done as a kind of
  transaction: When you need n resources, you might have
  obtained m already (m < n), but the next attempt might
  fail. Then you need to return to a orderly state and
  release exactly those resources that have been allocated
  so far and re****t the whole operation to be failed. So 
  the above patterns need to be nested, which makes the
  result even more complicated.

  I have invented another style, that use an object to handle
  control flow and should take care of the problem to allocate
  multiple resources

  Here is an example (explanation follows below):

public void digest( final java.io.File file )
{ final de.dclj.ram.system.program.Program program 
  = new de.dclj.ram.system.program.Program();
  try
  { 
    final java.io.FileInputStream fileInputStream = 
    program.'new java.io.FileInputStream'( file ); /* first attempt */

    final java.io.BufferedInputStream bufferedInputStream = 
    program.'new java.io.BufferedInputStream'( fileInputStream );

    final java.security.MessageDigest messageDigest =
    program.'new java.security.MessageDigest'( type );
    
    if( program.succeeded() )
    { this.process( bufferedInputStream, messageDigest ); }
    else
    { java.lang.System.out.println( program.'opening exceptions'() ); }}

  finally
  { program.close();
    if( !program.closed() )
    { java.lang.System.out.println( program.'closing exceptions'() ); }}}}

  A preprocessor converts everything withing single quotes to
  Java names. This is not necessary for this approach, but just
  an additional convenience.

  The operation »this.process« needs three resources: A file
  input stream, a buffered input stream and a message digest.

  The object »program« has operations to request the allocations
  needed. If the first attempt fails, it will skip the next two
  attempts and »program.succeeded()« will be false. The client
  above does not have to use »if« or »try« for each attempt.
  He can request the exceptions from the program object.

  »program.close()« will then close exactly those resources that
  have been obtained successfully before, because »program« has
  kept track of the release operations required to release
  everything that has been allocated successfully using this
  program object.

  Drawback: Each type of resource needs a special implementation
  in »de.dclj.ram.system.program.Program«, and right now there are
  only few types implemented. I will add additional code as I
  need it. See also:

http://www.purl.org/stefan_ram/html/ram.jar/de/dclj/ram/system/program/Program.html

  (with links to the source code.) This is part of the library

http://www.purl.org/stefan_ram/pub/ram-jar