Re: passing a Factory to a method to create a generic instance

thufir wrote:


I didn't have time to read through all the code thoroughly, but a couple of
ideas occur to me.

First, you might want to define an interface for loading data, rather than
define a loadGuest, loadRoom, loadEtc.

public interface AssignmentLoadable {
 void assignmentLoad( IOStream io ) throws IOException;
}

Now you can take all your objects, add this interface, and load them all the
same way.

This is called a mix-in interface, btw, because it's an interface that's easy
to add to a class.

For the factory pattern, it might be better to use package private
constructors, then make the factory object part of the package, so it
has access to the constructors.

Static methods are ok, but they aren't inheritable and therefore can't
be added to interfaces, so they're a little awkward to work with.

public class Room implements AssignmentLoadable {
 Room() {} // NOTE: package private
 // etc.
}

public class HotelFactory {
 public List<AssignmentLoadable > newGuestList( File file ) { // etc.
 }
}

You'll need to do a little work massaging AssignmentLoadable into whatever
top level class you want. I took the cheap and easy way out. I didn't make
HotelFactory itself generic because I want a concrete object at the top level
so it's easy to work with.

Now you have to parse the file into classes. This means matching up strings
with objects. A really sophisticated parser might read it's configuration
out of a separate file, so you could confiure it on the fly.

<parse-token>
 <parse-string>Room:</parse-string>
 <parser-class>my.parser.RoomParser</parser-class>
 <object>a00720398.etc.Room</object>
</parse-token>

But for your assignment you might just want to tell the HotelFactory that the
string "Room:" is associated with the class "a00720398.Room" for example.
This gives you a bit of flexibility. It also might be complete overkill for
your assignment. Just building the Strings and classes into HotelFactory as
literals would probably work ok. However, using this setter (and a few
others) to configure the HotelFactory object does give you the ability to
inject a test object into the HotelFactory, which might be handy if you run
into real trouble debugging it.

public class HotelFactory {

 Map<String,Class<? extends AsignmentLoadable>> parserStrings =
   new HashMap<String,Class<? extends AssignmentLoadable>>();

 public void setRoomParsing( String s,
        Class<? extends AssignmentLoadable> c )
 {
   parserStrings.put( s, c );
 }

}

Set this up externally when you make the Factory:

 HotelFactory h = new HotelFactory();
 h.setRoomParseing( "Room:", a00720398.Room.class );
 // etc. for other setters...
 List guests = h.newGuestList( myFile );

Then read your input file, match up strings with classes, and load the
classes up with the assginmentLoad() method, something like this:

class HotelFactory {
 public List<AssignmentLoadable> newGuestList( File file )
         throws FileNotFoundException,
         IOException,
         InstantiationException,
         IllegalAccessException
 {

     List<AssignmentLoadable> guestList = new
LinkedList<AssignmentLoadable>();

     FileInputStream fios = new FileInputStream(file);
     BufferedReader bin = new BufferedReader( new InputStreamReader(fios) );

     String line;
     while( (line = bin.readLine()) != null )
     {
         Class<AssignmentLoadable> c
                 = (Class<AssignmentLoadable>) parserStrings.get( line );
         AssignmentLoadable a = c.newInstance();
         a.assignmentLoad(fios);
         guestList.add(a);
     }
     return guestList;
 }

// etc.

}

There are probably a couple of good design patterns that I'm missing
(parsing is not my strong suit) but this will hopefully at least give
you some ideas.