a Factory for creating LinkedLists of Objects

[Stuart Rogers]

Greetings all,

I'm developing using Eclipse, which prods incessantly to not use raw types.

I'm trying to create LinkedLists that set their parameter type at runtime.
I'd also like to have these lists have some useful methods associated with them.

I thought up class ExpandedLinkedListObject, which contains two elements:
public Class<?> typpe;
public LinkedList<?> lisst;

where typpe will contain the Class information of the objects I want to put in lisst;
This get around erasure - by refering to typpe the program can always know what
is the correct type of object to put in lisst. It also gives me access to the correct
constructors for the objects.

Goal: read several cvs's into the .lisst of several ExpandedLinkedListObjects. There
is a class defined to match each cvs, of course.

Here's what I've got so far

import java.io.*;
import java.util.*;
import java.lang.reflect.*;

class Asset_HP extends Asset {

    // fields
    private String  receiving_no;
    private String  qty;
    private String  part_no;

    //constructors
    public Asset_HP() {
        receiving_no = null;
        qty = null;
        part_no = null;
    }

    public Asset_HP( String[] str_arry)
    {
        receiving_no = str_arry[0];
        qty = str_arry[1];
        part_no = str_arry[2];
    }
 
}

class Asset_GPS extends Asset {

    // fields
    private String  cust_order_no;
    private String  po_no;
    private String  ship_date;

    //constructors
    public Asset_GPS() {
        cust_order_no = null;
        po_no = null;
        ship_date = null;
    }

    public Asset_GPS( String[] str_arry)
    {
        cust_order_no = str_arry[0];
        po_no = str_arry[1];
        ship_date = str_arry[2];
    }
 
}

abstract class Asset {
    public static final int twine = 0;
    // I'll put some stuff here later
}

class ExpandedLinkedListObject {
    public static final int HP_Asset  = 0;
    public static final int GPS_Asset = 1;
    public Class<?> typpe;       // will contain  Asset_GPS.class
    public LinkedList<?> lisst;
    
    public <T> void setComponentType( Class<?> tokken) {
        this.typpe = tokken;
    }
    
    //constructor
    ExpandedLinkedListObject( Class<?> tokken) {
    	setComponentType( tokken);
    	this.lisst = new LinkedList<tokken>();	//    <== tokken cannot be resolved to a type - what goes here?
    }
    
    public <tokken> LinkedList<tokken> makeList( Class<?> tokken) {
    	setComponentType( tokken);
        LinkedList<tokken> aList = null;
        
        aList = new LinkedList<tokken>();
        return aList;
    }
       
    public void populate( String innFileName)
    {
        String[]       innline_arry;
        String         innline, tmp_str, out_str;
       
        // Find the constructor that only takes a single String array.
        Class<?>[] ctorArgs1 = new Class[1];            // eclipse doesnt like raw type here
        ctorArgs1[0] = String[].class;
        Constructor<?> strCtor = this.typpe.getDeclaredConstructor( ctorArgs1);    // eclipse doesnt like raw type here
       
        File           innFile;
        FileReader     innFileReader;
        BufferedReader innFileBufferedReader;
        try {
            innFile = new File( innFileName);
            innFileReader = new FileReader( innFile);
            innFileBufferedReader = new BufferedReader( innFileReader);
            try {
                while( (innline = innFileBufferedReader.readLine() ) != null) {
                    innline_arry = innline.split("\t");
//                  System.out.println( Arrays.toString( innline_arry) );
                    try {
                        this.lisst.add( strCtor.newInstance( innline_arry) );   // eclipse tosses lots of complaints here
                    } catch (InstantiationException x) {
                        x.printStackTrace();
                    } catch (IllegalAccessException x) {
                        x.printStackTrace();
                    } catch (InvocationTargetException x) {
                        x.printStackTrace();
                    } catch (NoSuchMethodException x) {
                        x.printStackTrace();                   
                    }
                }
                innFileReader.close();
            } catch (IOException e) {
                System.out.println("Cannot read file" + innFileName);
                return;
            }
        } catch (FileNotFoundException e) {
            System.out.println("Cannot open file" + innFileName + " for reading");
            return;
        }
    
    }	

}

class ExpandedLinkedListObjectFactory {
    public static final int HP_Asset  = 0;
    public static final int GPS_Asset = 1;

    public static ExpandedLinkedListObject make( Class<?> tokken) {  // nname is "Asset_GPS"
        
        return new ExpandedLinkedListObject(tokken);
    }
    
}

public class Lisa {
	ExpandedLinkedListObject gps_expanded_ll_obj;
	
    public static void main( String[] args) {

        Lisa theApp;

        theApp = new Lisa();

        theApp.gps_expanded_ll_obj = ExpandedLinkedListObjectFactory.make(Asset_GPS.class);
        theApp.gps_expanded_ll_obj.populate("/home/chris/lisa/Asset_GPS_test_data.csv");
        Class<?> garbbl = theApp.gps_expanded_ll_obj.typpe;
        LinkedList<?> fatrnrt_list = theApp.gps_expanded_ll_obj.lisst;
        

        System.out.println("done");

    }

}

I could use some help getting my <T>s <E>s <?>s in order to make this work.

Or has a simpler/better/faster/cheaper/std way to accomplish this already been invented? And if so send the link ;-)

TIA,

Still-learning Stuart

[Wouter Oet]

Stuart Rogers wrote:I'm developing using Eclipse, which prods incessantly to not use raw types.

Can be turned off

Why are you using generics when you're only adding Strings to the list?
And why are you using reflection for that?
Close your streams.

[Stuart Rogers]

But I'm not adding strings to the lists, I'm trying to instantiate objects with string arrays and add the objects to the list.
Thanks for your reply though.

[Paul Clapham]

Using reflection isn't going to make those messages go away. Reflection happens at run time, but generics are a compile-time feature. So if you don't know what type of object is going to be in the list at compile time, then just use the annotation which tells the compiler to ignore the fact that you are using a raw type.

[Stuart Rogers]

Updating these lines with wildcard type parameters solved the raw messages

        Class<?>[] ctorArgs1 = new Class[1];
        ctorArgs1[0] = String[].class;  // this is the arg of the constructor I want to use
        Constructor<?> strCtor = this.typpe.getDeclaredConstructor( ctorArgs1);
 

leaving only the line

                        this.lisst.add( strCtor.newInstance( innline_arry) );   // eclipse tosses lots of complaints here

now causing me grief, in the form of the message:
the method add(capture#12-of ?) in the type LinkedList(capture#12-of ?) is not applicable for the arguments (capture#13-of ?)

Now what?

Still-learning Stuart

[Stuart Rogers]

I solved my problem by refactoring my code to use a combination of Generics, reflection and patterns.

class ExpandedLinkedListObject
has transmorgified into

class t_AssetLinkedList<T> extends LinkedList<T> {
    public Class<?> typpe;
    ....

where the .populate method uses a .make( Class<?> typpe, String[] inn_str_arry) method from the AssetFactory,
which in turn uses reflection on typpe to pull the correct constructor.

the .writeOut method uses reflection on typpe to retreive and invoke the correct matching getAsArray method
prior to formatting and writing to the file.

Now my main() is this simple:

    public static void main( String[] args) {

        Lisa theApp;

        theApp = new Lisa();

        theApp.asset_HP_list = new t_AssetLinkedList<Asset_HP>(Asset_HP.class);
        theApp.asset_HP_list.populate("/home/chris/lisa/HP_EqptInventory_VIII.csv");
        theApp.asset_HP_list.removeFirst();  // removes header row
        Collections.sort( theApp.asset_HP_list, new Asset_HP_Comparator_PartNoSerialNumber() );
        theApp.asset_HP_list.writeOut("/home/chris/lisa/Asset_HP_out.csv");
        
        theApp.asset_GPS_list = new t_AssetLinkedList<Asset_GPS>(Asset_GPS.class);
        theApp.asset_GPS_list.populate("/home/chris/lisa/jasmine_VI.csv");
        theApp.asset_GPS_list.removeFirst();  // removes header row
        theApp.asset_GPS_list.removeLast();   // removes tail   row
        Collections.sort( theApp.asset_GPS_list, new Asset_GPS_Comparator_PartNoSerialNumber() );
        theApp.asset_GPS_list.writeOut("/home/chris/lisa/Asset_GPS_out.csv");

        System.out.println("done");

    }

Thanks to all who replied.

CASE CLOSED

Still-learning Stuart

[David Newton]

All that misspelling-to-avoid-confusion is really going to cause confusion in the real world. I mean, come on:

this.lisst.add(strCtor.newInstance(innline_arry));

Three in a single line?!

Also, using underscored properties (theApp.asset_HP_list) is really counter to any Java coding convention.

It's a lot easier for other people to understand your Java code if conventions are adhered to, and things aren't unnecessarily obfuscated.