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

The two nearly identical methods, loadGuests and loadRooms, I would like
to consolidate by passing in a Factory. However, I haven't found much
documentation on what that looks like.

Guest and Room implement Factory, but that's just part of the picture.

public Guest new() {return new Guest());} //in Guest.java
public Room new() {return new Room());} //in Room.java

Is the idea to make a single method, outside of Room and Guest, which
returns an instance of, well, type <T>?

But, how? I understand that one approach is to pass a Factory to
FileUtils.load(), which is fine, but how is that Factory instance first
created? Where's it created, in the driver which invokes FileUtils.load
()?

Here's what I have, it's just the top method which I'm working on right
now:

thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/interfaces/
Factory.java

package a00720398.interfaces;

public interface Factory <T>{
       T make();
}
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/util/
FileUtil.java
/**
* FileUtil.java
*/

package a00720398.util;

import java.util.*;
import java.io.*;
import a00720398.data.*;
import a00720398.interfaces.*;

public abstract class FileUtil {

       public static <E> List<E> load(File file) {
               List<E> foos = new ArrayList<E>();
               List<String> lines = getLines(file);
               for(String line : lines){
       // <E> foo = new <E>(); //how do I pass in a
        // //factory to return an "E"?
               }
               return new ArrayList<E>();
       }

       /*
       a00720398/util/FileUtil.java:31: cannot find symbol
       symbol : class T
       location: class a00720398.util.FileUtil
               public static void factoryTest(Factory<T> factory) {}
                                                      ^
       1 error */
       public static void factoryTest(Factory<T> factory) {} //

/**

interface Factory<T> { T make();}
public <T> Collection<T> select(Factory<T> factory, String statement) {
    Collection<T> result = new ArrayList<T>();
    /* run sql query using jdbc
    for (/* iterate over jdbc results ) {
       T item = factory.make();
       /* use reflection and set all of itemOOs fields from sql results
       result.add(item);
    }
    return result;
}
You can call this either as
select(new Factory<EmpInfo>(){ public EmpInfo make() {
                                       return new EmpInfo();
                                }}
   , OOselection stringOO);

       public static <T> factory<T>(T type) {
               return new List<T>(type);
       }

       @see http://www.ibm.com/developerworks/java/library/j-
djc02113.html

       Utilities.make(Integer(0)) //called from driver
       <T extends Object> public static <T> factory (T first) {
               return ew List<T>(first);
       }

class Utilities {
  <T extends Object> public static List<T> make(T first) {
    return new List<T>(first);
  }
}

*/

       //this method is a repaid of loadGuests
       public static List<Room> loadRooms(File file) {
               List<Room> rooms = new ArrayList<Room>();
               List<String> lines = getLines(file);

               for (String line : lines) {
                       List<String> tokens = getTokens(line);
                       Room room = new Room();
                       System.out.println(rooms);
               }

               return rooms;
       }

       public static List<Guest> loadGuests(File file) {
               List<Guest> guests = new ArrayList<Guest>();
               List<String> lines = getLines(file);

               for (String line : lines) {
                       List<String> tokens = getTokens(line);
                       Guest guest = new Guest(tokens);
                       System.out.println(guest);
               }
               return guests;
       }

       private static List<String> getTokens (String string){
               List<String> tokens = new ArrayList<String>();
               Scanner lineScanner = new Scanner(string);
               while (lineScanner.hasNext()){
                       String token = lineScanner.next();
                       tokens.add(token);
               }
               return tokens;
       }

       private static Guest newGuest(String string) {
               List<String> guestData = getTokens(string);
               Guest guest = new Guest(guestData);
               return guest;
       }

       private static List<String> getLines(File file) {
               List<String> lines = new ArrayList<String>();
               try {
                       Scanner scanner = new Scanner(file);
                       while (scanner.hasNextLine()) {
                               String line = scanner.nextLine();
                               Scanner lineScanner = new Scanner(line);
                               lineScanner.useDelimiter("\n");
                               while (lineScanner.hasNextLine()) {
                                       String oneLine = lineScanner.next
();
                                       lines.add(oneLine);
                               }
                       }
               } catch (FileNotFoundException e) {
                       e.printStackTrace();
               }
               return lines;
       }
}