Type Safe Classes - 2

In my previous post about Type Safe Classes, we can add two additional public API's

<br /> /*<br /> * Push all elements from input to stack<br /> */<br /> public void pushAll(Iterable<e> input){<br /> for (E e : input){<br /> push(e);<br /> }<br /> }<br /> /*<br /> * Pop all the elements into the given collection<br /> */<br /> public void popAll(Collection<e> collection){<br /> while(isEmpty()){<br /> collection.add(pop());<br /> }<br /> }<br />

The above two API's look very decent and type safe and there is some hard to find problems here. Lets take this by example; In the below example, we can create a stack of animals and add any Type of animal to the stack. But unfortunately with our published APIs, we can add a Dog to animals [Stack] but cannot add List dogs to same stack using pushAll API, its not allowed (But this is what we want to achive, isn't it.)

<br /> public static void main(String[] args){<br /> Stack<animal> animals = new Stack<animal>();<br /> animals.push(new Cat());<br /> animals.push(new Dog());<br /> animals.push(new SomeDog());<br /> //we can push any kind of animals.<br /> while(!animals.isEmpty()){<br /> Animal a = animals.pop();<br /> a.makeSound();<br /> }<br /> <br /> //lets try to add some more dogs.<br /> List<dog> dogs = new ArrayList<dog>();<br /> dogs.add(new Dog());<br /> dogs.add(new SomeDog());<br /> <br /> //we cannot do this, wont compile<br /> animals.pushAll(dogs);<br /> }<br />

Also, there is a similar problem with popAll API as well. Consider the below example, Also we know that its acceptable to collect animal object (any Type) in an Object, but we cannot collect all the animals in List<Object> at once using the above mentioned popAll() API

<br /> public static void main(String[] args){<br /> Stack<animal> animals = new Stack<animal>();<br /> animals.push(new Cat());<br /> animals.push(new Dog());<br /> animals.push(new SomeDog());<br /> //we can push any kind of animals.<br /> while(!animals.isEmpty()){<br /> //we can collect animal in an object.<br /> Object obj = animals.pop();<br /> Animal animal = (Animal)obj;<br /> animal.makeSound();<br /> }<br /> <br /> //lets try to popout all the elements from animal stack.<br /> List<object> objs = new ArrayList</object>();<br /> <br /> //this wont work either, compilation will fail<br /> animals.popAll(objs);<br /> }<br />

This wont work either because popAll API only take Collection<E> that means Collection<Animal> in our case. Note that Collection<Animal> is not same as Collection<Object> & similarly Iterable<Animal&tt; is not same as Iterable<Dog>. Question is, if the below code works [we can push any Type of E in the stack]

<br />public void push(E element){<br /> ensureCapacity();<br /> elements[size++] = element;<br /> }<br />

Below code should have also worked [see below code], for all the Types of E, but it doesn't because thought Animal & Dog has covarient type relationship [the referenced object's type parameter is a subclass], List<Animal> & List<Dog> defines "invariant type relationship", [List<Dog> is not a subtype of List<Animal>]

<br /> /*<br /> * Push all elements from input to stack<br /> */<br /> public void pushAll(Iterable<e> input){<br /> for (E e : input){<br /> push(e);<br /> }<br /> }<br /><br />

So, Java 1.5 generics also provide us with wild cards, which is what we have to use here. We have to define a "covarient type relationship" using wild cards.

<br /> /*<br /> * Push all elements from input to stack<br /> */<br /> public void pushAll(Iterable<? extends E> elements){<br /> for (E e : elements){<br /> push(e);<br /> }<br /> }<br /> /*<br /> * Pop all the elements into the given collection<br /> */<br /> public void popAll(Collection<? super E> collection){<br /> while(isEmpty()){<br /> collection.add(pop());<br /> }<br /> }<br />

Our same code which was not working before, will work because we converted our invarient type relationship to covarient type.

<br /> public static void main(String[] args){<br /> Stack<animal> animals = new Stack<animal>();<br /> animals.push(new Cat());<br /> animals.push(new Dog());<br /> animals.push(new SomeDog());<br /> //we can push any kind of animals.<br /> while(!animals.isEmpty()){<br /> Object obj = animals.pop();<br /> Animal animal = (Animal)obj;<br /> animal.makeSound();<br /> }<br /> <br /> List<dog> dogs = new ArrayList<dog>();<br /> dogs.add(new Dog());<br /> dogs.add(new Dog());<br /> dogs.add(new SomeDog());<br /> <br /> //push all dogs, works<br /> animals.pushAll(dogs);<br /> <br /> //pop all animals in List<object><br /> List</object> objs = new ArrayList<object>();<br /> // works<br /> animals.popAll(objs);<br /> </object>}<br />

One more interesting thing is PECS principle [producer extends, consumer super], what it means is; when we only want to read or use the elements in a collection, we use extends keyword. e.g. pushAll(Iterable<? extends E> elements), we can just read the elements but cannot add anything in elements because the input is producer not a consumer. Even if we had pushAnimal(List<? extends Animal> animals) API, we cannot add any elements, except null, in the collection. So, if we want to add elements in the collection as well, we should use a consumer like popAll(Collection<? super E> collection.

I guess PECS rule is the most tricker of all the rules we have to follow while making our code generic.

Type Safe Classes

We always try to use type safe collections where ever possible, for example
<br />List<String> list = new ArrayList<String>();<br />
What would it take to implement a type safe Collection like Stack ? Below is the implementation of type safe Stack class
<br />public class Stack<E> {<br /> private E[] elements;<br /> private int size = 0;<br /> private static final int INITIAL_CAPACITY = 16;<br /> private static final int INCREMENTAL = 10;<br /> <br /> @SuppressWarnings("unchecked")<br /> public Stack(){<br /> /* problem here is we cannot create new E[], we'll always get into<br /> * these issues if we try to use generics with arrays.<br /> */<br /> elements = (E[]) new Object[INITIAL_CAPACITY];<br /> }<br /> public void push(E element){<br /> ensureCapacity();<br /> elements[size++] = element;<br /> }<br /> public E pop(){<br /> if (size == 0)<br /> throw new EmptyStackException();<br /> E result = elements[--size];<br /> elements[size] = null;<br /> return result;<br /> }<br /> public boolean isEmpty(){<br /> return size == 0;<br /> }<br /> @SuppressWarnings("unchecked")<br /> private void ensureCapacity(){<br /> if (elements.length == size){<br /> E[] oldData = elements;<br /> int length = elements.length;<br /> elements = (E[]) new Object[elements.length + INCREMENTAL];<br /> System.arraycopy(oldData, 0, elements, 0, length);<br /> }<br /> }<br />}<br />

Why I have used "@SuppressWarnings("unchecked")", and still claiming it to be type safe ? First, its type safe for the client using this Stack, its pushes and pops element of type E. Second, we know what we are doing, we are typecasting Object[] to E[]; hence a "@SuppressWarnings("unchecked")."

<br />Stack<String> stack = new Stack<String>();<br />stack.push("one");<br />stack.push("two");<br /><br />//no type cast required<br />String element = stack.pop();<br />

Groovy & Java

Closure(s) Groovy Closures, loosely speaking are method pointers. Also, Groovy is a 2nd standard language for JVM. So, does it mean we have function pointers in Java / JVM ? No, if you read about Closures carefully enough, they are actually objects. Let’s see if we can do something close to what Groovy can do in Java.

Below is a sample code written in Groovy script

def list = []
for (i in 1..5)
 list.add(i);
/*I am treating doThis as a Closure, I could have written 'Closure doThis' as well */
def doSomething(toMe, doThis){
 toMe.each(doThis)
}

doSomething(list, {print it + " "})
print("\n")
doSomething(list, {print it * 5 + " "})
print("\n")
list.each{print it + " "}

Below are the results

1 2 3 4 5 
5 10 15 20 25 
1 2 3 4 5 

In the above example, "doThis" can be anything (its loosly typed, feature of dynamic language) but I am using it as a Closure. Method named "doSomething" simply applies the "doThis" closure to "toMe" variable. yea, I know its painful when on one side you say "Following generics, it’s good for you and your code's health" and on the other side "Look @ the really cool features of Groovy, you don’t even need to declare Type".. WTF. Anyways, the point is, what will it take to do the same thing in Java, Groovy style.

Lets first declare something like closure :)
<br />interface Closure<E>{<br /> public void invoke(E obj);<br />}<br />/*Multiply for Integer Type*/<br />class Multiply implements Closure<Integer>{<br /> int value;<br /> public Multiply(int value){<br /> this.value = value;<br /> }<br /> public void invoke(Integer obj){<br /> System.out.print(obj * value + " ");<br /> }<br />}<br /><br />

Also, lets implement our own version of List (just to include groovy stype "each" method)

<br /><br />interface MyList<E> extends Iterable<E>{<br /> void add(E element);<br /> E getAt(int index);<br /> void each(Closure<E> def);<br /> Iterator<E> iterator();<br />}<br />/*My style list*/<br />class MyGroovyList<E> implements MyList<E>, Iterable<E> {<br /><br /> List<E> elements = null;<br /> public MyGroovyList(){<br /> elements = new ArrayList<E>();<br /> }<br /> public void add(E element) {<br /> elements.add(element);<br /> }<br /><br /> public void each(Closure<E> def) {<br /> for (E e : elements){<br /> def.invoke(e);<br /> }<br /> }<br /> public E getAt(int index) {<br /> //can throw IndexOutOfBondException<br /> return elements.get(index);<br /> }<br /> public Iterator<E> iterator() {<br /> return elements.iterator();<br /> }<br /> <br />}<br />

Now, let’s see our code in Action

<br />/**<br /> * <br /> * @author pfarwaha<br /> *<br /> */<br />public class MyGroovy {<br /> public static void main(String[] args){<br /> MyList<Integer> list = new MyGroovyList<Integer>();<br /> for(int i = 1; i<6; i++)<br /> list.add(i);<br /> <br /> for (Integer obj : list)<br /> System.out.print(obj + " ");<br /> <br /> System.out.println();<br /> list.each(new Closure<Integer>(){<br /> public void invoke(Integer obj){<br /> System.out.print(obj * 5 + " ");<br /> }<br /> });<br /> System.out.println();<br /> /* Or we can use the implementation as below */<br /> list.each(new Multiply(10));<br /> <br /> System.out.println();<br /> <br /> for (Integer obj : list)<br /> System.out.print(obj + " ");<br /> }<br />}<br /><br />
Below are the results: as expected

1 2 3 4 5 
5 10 15 20 25 
10 20 30 40 50 
1 2 3 4 5 

Then only thing interesting in MyGroovy class is below code:
<br /><br /> list.each(new Closure<Integer>(){<br /> public void invoke(Integer obj){<br /> System.out.print(obj * 5 + " ");<br /> }<br /> });<br /> System.out.println();<br /> /* Or we can use the implementation as below */<br /> list.each(new Multiply(10));<br /> <br />

In Groovy list.each() method takes a closure, which is internally just an Object. So, in our implementation of List, we are also passing instance of Closure :). BTW, I do not know how Groovy implements this concept, but this technique is a good candidate. Also, given that SpringSource owns Groovy & Grails, we might see Groovy getting even more popular for web application development. According to me, it is going to be maintenance nightmare if that happens.

ConcurrentModificationException

While iterating over the List, or anything which implements iteratable, we cannot modify the contents of that particular collection. Not a surprise, but today while implementing iteratable (@ work) I din't know how to achieve this. BTW, why do I need to throw this exception ?? do I care ?? should I not just use object locking ?? I guess all of us know the reason, object state in multithreaded applications & performance. Anyways, I think below implementation looks decent enough:

<br />/**<br /> * Bag<br /> * @author pardeep<br /> */<br />public class Bag<E> implements Iterable<E> {<br /><br /> List<E> elements = null;<br /> int modifications = 0;<br /> <br /> public Bag(){<br /> elements = new ArrayList<E>();<br /> }<br /><br /> public Iterator<E> iterator(){<br /> return new Itr();<br /> }<br /> public int size(){<br /> return elements.size();<br /> }<br /> public void add(E element){<br /> elements.add(element);<br /> modifications ++;<br /> }<br /> public void remove(E element){<br /> elements.remove(element);<br /> modifications ++;<br /> }<br /> public void removeAll(){<br /> for (int i = 0; i < elements.size() ; i++)<br /> elements.remove(i);<br /> }<br /><br /> private class Itr implements Iterator<E>{<br /> int curr = 0;<br /> int expectedMod = modifications;<br /> public void remove(){<br /> // lets not implements this one right now.<br /> throw new UnsupportedOperationException();<br /> }<br /><br /> public boolean hasNext(){<br /> return curr < size();<br /> }<br /><br /> public E next(){<br /> checkForModification();<br /> return elements.get(curr++);<br /> }<br /> private void checkForModification(){<br /> if (expectedMod != modifications)<br /> throw new ConcurrentModificationException();<br /> }<br /> }<br />}<br />