Heterogeneous map and generics

[Yaroslav Chinskiy]

All,

I am trying to write a heterogeneous map where I can get compile time type safety.

The goal is to have a map of attributes where a producer can put data in and consumer can retrieve it without casting.
I am not using any messaging API. This will be used in pure JAVA app without any fancy frameworks.
What do you think about this approach:

Some of my colleges say that type safety if overrated and we should use regular Object->Object dictionary. This approach will assume that users know that source of information and can appropriately cast it at run time. Do you think it is batter to keep it simple or enforce type safety?


Attribute class (I can not use enum. I want to use this as an API and do not want anyone to stick new attributes in the jar once it was released. Unfortunately, enum does not support inheritance. User of the API can extend the attribute to create new keys.):

  
public class Attribute<T> implements Serializable {
// ------------------------------ FIELDS ------------------------------


    private static final long serialVersionUID = 2708920784383418114L;
    private static final transient Map<AttributeID, Attribute> ATTRIBUTES = new HashMap<AttributeID, Attribute>();
    private final Object id;
    
    // ------------------------------ ATTRIBUTES ------------------------------
    // All constants are transient to prevent serialization
    public static final transient Attribute<String> STRING = Attribute.build("String");
    public static final transient Attribute<Date> DATE = Attribute.build("DATE");
    public static final transient Attribute<Double> DOUBLE = Attribute.build("DOUBLE");
    public static final transient Attribute<Integer> INTEGER = Attribute.build("INTEGER");

    // -------------------------- STATIC METHODS --------------------------

    protected static <T> Attribute<T> build(AttributeID id) {

        Attribute<T> attribute = ATTRIBUTES.get(id);
        if(attribute == null){
            attribute = new Attribute<T>(id);
            ATTRIBUTES.put(id, attribute);
        }

        return attribute;
    }

// --------------------------- CONSTRUCTORS ---------------------------

    protected Attribute(AttributeID id) {
        if (id == null) throw new NullPointerException("ID can not be null");
        this.id = id;
    }

    // ------------------------ CANONICAL METHODS ------------------------

    public final boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Attribute)) return false;
        Attribute attribute = (Attribute) obj;
        return id.equals(attribute.id);
    }

    public final int hashCode() {
        return id.hashCode();
    }

 
    public final String toString() {
        return super.toString() + " " + id;
    }

// -------------------------- OTHER METHODS --------------------------

    final T get(Map map) {
        return (T) map.get(this);
    }

    private Object readResolve() throws ObjectStreamException {
        return ATTRIBUTES.get(this.id);
    }


    final T set(T data, Map map) {
        return (T) map.put(this, data);
    }
}

AttributeList(not using collection):

public final class AttributeList implements Cloneable, Serializable{
// ------------------------------ FIELDS ------------------------------

    private final Map<Attribute, Object> delegate;
    private static final long serialVersionUID = 7286898337467366119L;

    public AttributeList() {
        this.delegate = new HashMap<Attribute, Object>();
    }

    // ------------------------ CANONICAL METHODS ------------------------

    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        AttributeList that = (AttributeList) obj;
        return delegate.equals(that.delegate);
    }

    public int hashCode() {
        return delegate.hashCode();
    }

    public String toString() {
        return delegate.toString();
    }

// -------------------------- OTHER METHODS --------------------------

    public void clear() {
        delegate.clear();
    }

    public <T> T get(Attribute<T> key) {
        return key.get(delegate);
    }

    public boolean isEmpty() {
        return delegate.isEmpty();
    }

    public <T> T put(Attribute<T> key, T data) {
        return key.set(data, delegate);
    }

    public int size() {
        return delegate.size();
    }

Simple test:

  
        AttributeList list = new AttributeList();
        list.put(Attribute.DOUBLE, 3.0);
        list.put(Attribute.STRING, "TEST");
        list.put(Attribute.INTEGER, 5);

        ByteArrayOutputStream os = new ByteArrayOutputStream(1024);
        ObjectOutputStream outputStream = new ObjectOutputStream(os);
        outputStream.writeObject(list);
        byte[] buffer = os.toByteArray();

        ByteArrayInputStream is = new ByteArrayInputStream(buffer);
        ObjectInputStream inputStream = new ObjectInputStream(is);

        AttributeList list1 = (AttributeList) inputStream.readObject();
        double  dd = list1.get(Attribute.DOUBLE);

[Paul Clapham]

As far as I can see, this is just a complicated way of writing a container which can optionally contain a String, a Date, a Double, and an Integer. It would be simpler to do this:

public class Container {
  private String theString;
  private Date theDate;
  private Integer theInteger;
  private Double theDouble;

  // insert suitable constructor, getters, and setters

}

Also, you're using a static Map to store the data, which means you've sort of written a Singleton object but don't have the proper controls, and you've created that map in the Attribute class and not in the AttributeList class where I think it belongs. So creating two of those objects (whichever class has the static variable) is going to lead you into trouble.

Also I think it's a bad practice to name something "SomethingList" when it uses a Map to store things. Calling it a "List" leads the user to believe he/she can add as many Dates as he/she likes, when it doesn't actually work that way.

I don't see anything about type safety in your question, really. You'll notice that in my equivalent class, the question of type safety doesn't arise.

[Yaroslav Chinskiy]

Paul Clapham wrote:
Also, you're using a static Map to store the data, which means you've sort of written a Singleton object but don't have the proper controls, and you've created that map in the Attribute class and not in the AttributeList class where I think it belongs. So creating two of those objects (whichever class has the static variable) is going to lead you into trouble.

I tried to simulate enum. I want to use this class in different layers of the app which will communicate via simple messaging interface.
This is not singleton since it is expendable. However, I enforce "singleton property" for each attribute. I use combination of readResolve(), protected constructor and builder to enforce single instance of the attribute of a particular id.

Since I want users to extend it before use, it should be a class and not part of the AttributeList.

Also I think it's a bad practice to name something "SomethingList" when it uses a Map to store things. Calling it a "List" leads the user to believe he/she can add as many Dates as he/she likes, when it doesn't actually work that way.

I totally agree to that. Will rename ASAP.

My sample may have been misleading. I will have a message that will contain attributes. The messages will be exchanged through a message broker between different components of the app. I want complete decoupling and have similar system to NotificationCenter of Objective C.

Your container will work but has some limitations. I have to store this container in some sort of the collection.
I may have two containers with the same type. For example start Date and end Date. How will consumer distinguish them without extra information (some tag may be)?

public class Container<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public static void main(String[] args) {

        List<Container> attributes = new ArrayList<Container>();
        
        attributes.add(new Container<Date> ()); // start date
        attributes.add(new Container<Date> ()); // end date
        attributes.add(new Container<Double> ()); // price
        attributes.add(new Container<Double> ()); // size
   }
}

On the other hand, we can create a class per type (similar to what I do with attribute). This may lead to a maintenance issue. Also, I will need some construct for this containers to make all of them immutable/mutable. I would like to keep it simple and use a dictionary where anyone can put/get data. This concept is easy to understand and use but will lead to type safety issue. For example, if I use a map and decide to use String for data while consumer was expecting another object, the issue will arise at run time only. I want to know about it at compile time and not hear about it from production env.