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.

 > public static List<AsignmentLoadable> loadAll(File file) {
 > List<AsignmentLoadable> al =
 > new ArrayList<AsignmentLoadable>();
 > //List<String> lines = getLines(file);
 > IOStream ios = new FileIOStream( file );
 >
 > while( (AssignmentLoadable a = getNextObject( ios )) != null )
 > a.assignmentLoad( ios );
 > al.add( a );
 > }
 > return al;
 > }

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.