Let’s practice a while to see how it works. We will define a house with a surface and its construction’s year:

public class House implements Comparable<House> {
private int sqFt;
private int constructionYear;

public int getSqFt() {
return sqFt;
}
public void setSqFt(int sqFt) {
this.sqFt = sqFt;
}

public int getContructionYear() {
return constructionYear;
}
public void setContructionYear(int constructionYear) {
this.constructionYear = constructionYear;
}

public House(int sqFt, int contructionYear) {
setSqFt(sqFt);
setContructionYear(contructionYear);
}

public int compareTo(House house) {
final int BEFORE = -1;
final int EQUAL = 0;
final int AFTER = 1;

if(this == house) return EQUAL;

// bigger if surface is bigger
if(getSqFt() < house.getSqFt()) return BEFORE;
if(getSqFt() > house.getSqFt()) return AFTER;

// bigger if newer
if(getContructionYear() < house.getContructionYear()) return BEFORE;
if(getContructionYear() > house.getContructionYear()) return AFTER;

// else equal
return EQUAL;
}

public String toString() {
return getSqFt()+" sq ft, build in "+getContructionYear();
}
}

Our House class implements the Comparable<T> interface where T defines the type of Object which the House will be compare to. In our example we’ll compare a House to another, so it’s Comparable<House>.

Next we have defined the compareTo(<T> object) Comparable method. This method will be used to sort our houses. We decide to order them in this way:

• by surface (if house A is smaller than house B, house A is less than house B)
• by construction year (if two houses have the same surface, the newest is the biggest)

Now, we will define a list of houses and try to sort them in ascending order and in descending order:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
public static void showHouseList(List<House> houseList) {
for(House house : houseList)
System.out.println(house);
}

public static void main(String[] args) {
List<House> houseList = new ArrayList<House>();

houseList.add(new House(2000, 1976));
houseList.add(new House(20000, 1999));
houseList.add(new House(5000, 1990));
houseList.add(new House(2900, 1982));
houseList.add(new House(20000, 1998));
houseList.add(new House(10000, 1979));
houseList.add(new House(10000, 2005));
houseList.add(new House(15000, 1995));
houseList.add(new House(3000, 1980));
houseList.add(new House(5000, 1999));
houseList.add(new House(6000, 1968));

System.out.println("- Mixing the list...");
// Mixing the house list
Collections.shuffle(houseList);
// Checking the state of our list
showHouseList(houseList);

System.out.println("\n- After sorting in ascending order...");
// Sorting our house in ascending order
Collections.sort(houseList);
// Checking that the sort action works
showHouseList(houseList);

System.out.println("\n- Re mixing the list...");
// Re-Mixing the house list
Collections.shuffle(houseList);
// Checking the state of our list
showHouseList(houseList);

System.out.println("\n- After sorting in descending order...");
// Sorting our house in descending order
Collections.sort(houseList, Collections.reverseOrder());
// Checking that the sort action works
showHouseList(houseList);
}
}

Here is the output:

- Mixing the list...
15000 sq ft, build in 1995
2900 sq ft, build in 1982
5000 sq ft, build in 1999
6000 sq ft, build in 1968
10000 sq ft, build in 2005
10000 sq ft, build in 1979
20000 sq ft, build in 1999
2000 sq ft, build in 1976
20000 sq ft, build in 1998
5000 sq ft, build in 1990
3000 sq ft, build in 1980

- After sorting in ascending order...
2000 sq ft, build in 1976
2900 sq ft, build in 1982
3000 sq ft, build in 1980
5000 sq ft, build in 1990
5000 sq ft, build in 1999
6000 sq ft, build in 1968
10000 sq ft, build in 1979
10000 sq ft, build in 2005
15000 sq ft, build in 1995
20000 sq ft, build in 1998
20000 sq ft, build in 1999

- Re mixing the list...
3000 sq ft, build in 1980
15000 sq ft, build in 1995
10000 sq ft, build in 2005
5000 sq ft, build in 1990
2900 sq ft, build in 1982
2000 sq ft, build in 1976
20000 sq ft, build in 1998
10000 sq ft, build in 1979
6000 sq ft, build in 1968

5000 sq ft, build in 1999
20000 sq ft, build in 1999

- After sorting in descending order...
20000 sq ft, build in 1999
20000 sq ft, build in 1998
15000 sq ft, build in 1995
10000 sq ft, build in 2005
10000 sq ft, build in 1979
6000 sq ft, build in 1968
5000 sq ft, build in 1999
5000 sq ft, build in 1990
3000 sq ft, build in 1980
2900 sq ft, build in 1982
2000 sq ft, build in 1976

To install Eclipse Ganymede, it must be done manually.

Java installation

By default, Ubuntu comes with a free Java interpreter: gij, so if you want to use the Sun Microsystems Java™ Development Kit (JDK), you will need to install it.

Java is available in the depots. You have a choice between two versions: Java5 and Java6.

• Java5 is available in multiverse deposits for all versions of Ubuntu currently supported.
• Java6 is available in multiverse deposits since Feisty. For Edgy and Dapper you’ve gor to check the backports multiverse deposits.

You can install the following packages according to your needs:

• sun-java6-bin: Sun Java™ Runtime Environment (JRE) 6 (depending on the architecture)
• sun-java6-demo: Sun Java™ Development Kit (JDK) 6 (demos and examples)
• sun-java6-doc: JDK™ Documentation – integration installer
• sun-java6-fonts: Lucida TrueType fonts.
• sun-java6-javadb: Java™ DB, Apache Derby by Sun Microsystems
• sun-java6-jdk: Java™ Development Kit (JDK) 6
• sun-java6-jre: Java™ Runtime Environment (JRE) 6 (independent from the architecture)
• sun-java6-plugin: Web navigator Java™ Plugin.
• sun-java6-source: JDK™ sources.

The above list is the list of available packages for Java6. For the Java5 packages list, simply replace "java6" by "java5".

For example to install the Java6 JRE execute the following commands:

sudo apt-get install sun-java6-jre sun-java6-plugin sun-java6-fonts

Eclipse 3.4 Ganymede installation

Download the version that suits you on the official website.

For example Eclipse IDE for Java Developers (eclipse-java-ganymede-linux-gtk.tar.gz):

wget http://download.eclipse.org/technology/epp/downloads/release/ganymede/R/eclipse-java-ganymede-linux-gtk.tar.gz
tar xzvf eclipse-java-ganymede-linux-gtk.tar.gz
mv eclipse eclipse3.4

You should be ready to launch

eclipse3.4/eclipse

Wait for your eclipse 3.4 Ganymede to start, and go to Windows -> Preferences. Find Java -> Installed JREs. You should see the list of the JREs known by eclipse. If the Sun Microsystems JREs doesn’t appear, you’ll have to show it to eclipse. To do this, Click the “Search” button and select the /usr/lib/jvm/ path. Eclipse should find JREs intalled on your system and list them. Just select the one that you want to use, and you’re ready to program on your nice new Eclipse 3.4 Ganymede

Hi everyone,

The symbolic 1,000th hit was achieved today!
I’m happy to see that so much people visit my blog

See you!

JDOM is a Java API developed regardless of Sun Microsystems. It can handle XML data more simply than with conventional API. Its use is convenient for any Java developer and is based on Sun’s XML API.

Let’s show you an example to see how it works...

First of all you need to download and install JDOM. Go to http://www.jdom.org/dist/binary/ and download jdom-1.1. Then unzip it and make the build/jdom.jar file accessible trought to the classpath (if you are under Eclipse you simply have to configure the build path of your project with “Add External Archives...” and select jdom.jar).

Now we are ready to use JDOM. We will create a XML file from scratch. You just have to build your XML tree by adding elements one to the other. A node is a org.jdom.Element instance.
Let’s create a JDOMDVD class which will create the following XML tree:

<dvd_collection>
<dvd_list genre="action">
<dvd>
<title>Die Hard</title>
<year>1988</year>
</dvd>
<dvd_list>
<dvd_collection>

import java.io.FileOutputStream;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class JDOMDVD {
// Create the XML root Element
static Element root = new Element("dvd_collection");

// Create a JDOM Document based on the root Element
static Document document = new Document(root);

public static void main(String[] args) {
// Create a new "dvd_list" Element
// that we will add to the root Element
Element actionDvdList = new Element("dvd_list");
root.addContent(actionDvdList);

// Create a new Attribute and add it
// to the actionDvdList Element
Attribute genre = new Attribute("genre","action");
actionDvdList.setAttribute(genre);

// Create a new "dvd" Element and add it
// to the actionDvdList Element
Element dvd = new Element("dvd");
actionDvdList.addContent(dvd);

// Create a new "title" Element, set its text,
// and add it to the dvd Element
Element dvdTitle = new Element("title");
dvdTitle.setText("Die Hard");
dvd.addContent(dvdTitle);

// Create a new "year" Element, set its text,
// and add it to the dvd Element
Element dvdReleaseYear = new Element("year");
dvdReleaseYear.setText("1988");
dvd.addContent(dvdReleaseYear);

// show the XML output
try {
// We use classic output format with getPrettyFormat()
XMLOutputter xmlOutputter = new XMLOutputter(Format.getPrettyFormat());
xmlOutputter.output(document, System.out);
}
catch (java.io.IOException e) {
e.printStackTrace();
}

// Save it to a "dvd.xml" file
try {
// We use classic output format with getPrettyFormat()
XMLOutputter xmlOutputter = new XMLOutputter(Format.getPrettyFormat());
xmlOutputter.output(document, new FileOutputStream("dvd.xml"));
}
catch (java.io.IOException e) {
e.printStackTrace();
}
}
}

The result:

<?xml version="1.0" encoding="UTF-8"?>
<dvd_collection>
<dvd_list genre="action">
<dvd>
<title>Die Hard</title>
<year>1988</year>
</dvd>
<dvd_list>
<dvd_collection>

I said you that it was easy !

Now let’s see how it works with exisiting XML files. We will parse a XML file to a JDOM tree. To do this, we’ll use the org.jdom.input.SAXBuilder class, based on the SAX API...
First, create the following XML file in your JDOMDVD class directory. Let’s call it “dvd_collection.xml”

<?xml version="1.0" encoding="UTF-8"?>
<dvd_collection>
<dvd_list genre="action">
<dvd>
<title>Die Hard</title>
<year>1988</year>
</dvd>
<dvd>
<title>Die Hard 2</title>
<year>1990</year>
</dvd>
<dvd>
<title>Die Hard with a Vengeance</title>
<year>1995</year>
</dvd>
<dvd>
<title>Die Hard 4.0</title>
<year>2007</year>
</dvd>
</dvd_list>
<dvd_list genre="comedy">
<dvd>
<title>There’s Something about Mary</title>
<year>1998</year>
</dvd>
<dvd>
<title>Monty Python and the Holy Grail</title>
<year>1975</year>
</dvd>
</dvd_list>
</dvd_collection>

We will try to show all the DVD titles from our DVD collection XML file...
Let’s create the JDOMDVDTitles class:

import java.io.File;

import javax.swing.JFileChooser;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

public class JDOMDVDTitles {
static Document document;
static Element root;

public static void main(String[] args) {
// Create a SAXBuilder instance
SAXBuilder sxb = new SAXBuilder();

// Dialog to choose the XML file to parse
JFileChooser jfc = new JFileChooser(".");
int result = jfc.showOpenDialog(null);
switch(result) {
case JFileChooser.APPROVE_OPTION:
try {
// Create a new JDOM document from a XML file
File file = jfc.getSelectedFile();
System.out.println("Parsing "+file+"...");
document = sxb.build(file);
// Parsing done !
}
catch(Exception e) {
e.printStackTrace();
}
break;
case JFileChooser.CANCEL_OPTION:
System.out.println("Operation canceled...");
System.exit(0);
break;
case JFileChooser.ERROR_OPTION:
System.out.println("!! An error has occured !!");
System.exit(0);
break;
}

// Initialize the root Element with the document root Element
try {
root = document.getRootElement();
}
catch(NullPointerException e) {
e.printStackTrace();
}

// Browse the XML tree to retrieve dvd titles
for(Object dvd_list : root.getChildren("dvd_list")) {
Element courant = (Element) dvd_list;
for(Object dvd : courant.getChildren("dvd")) {
Element dvdElt = (Element) dvd;
System.out.println(dvdElt.getChild("title").getText());
}
}
}
}

Here is the output:

Parsing D:\eclipse3.4\workspace\JDOM\dvd_collection.xml ...
Die Hard
Die Hard 2
Die Hard with a Vengeance
Die Hard 4.0
There’s Something about Mary
Monty Python and the Holy Grail

As easy as our first example ! Now let’s do something a little more complex...
We will try to make a filtered search on our DVD collection: Let’s find the “action” movies from 1995 and more. To do this, we will use the org.jdom.filter.Filter interface

import java.io.File;

import javax.swing.JFileChooser;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.filter.Filter;
import org.jdom.input.SAXBuilder;

public class JDOMDVDFilter {
static Document document;
static Element root;

public static void main(String[] args) {
// Create a SAXBuilder instance
SAXBuilder sxb = new SAXBuilder();

// Dialog to choose the XML file to parse
JFileChooser jfc = new JFileChooser(".");
int result = jfc.showOpenDialog(null);
switch(result) {
case JFileChooser.APPROVE_OPTION:
try {
// Create a new JDOM document from a XML file
File file = jfc.getSelectedFile();
System.out.println("Parsing "+file+"...");
document = sxb.build(file);
// Parsing done !
}
catch(Exception e) {
e.printStackTrace();
}
break;
case JFileChooser.CANCEL_OPTION:
System.out.println("Operation canceled...");
System.exit(0);
break;
case JFileChooser.ERROR_OPTION:
System.out.println("!! An error has occured !!");
System.exit(0);
break;
}

// Initialize the root Element with the document root Element
try {
root = document.getRootElement();
}
catch(NullPointerException e) {
e.printStackTrace();
}

// Create a new Filter
Filter myDvdFilter = new Filter() {
// Define filter properties with the ‘matches’ method
public boolean matches(Object ob) {
// Check ob is an Element
if(!(ob instanceof Element)){return false;}
Element element = (Element) ob;
boolean genreChecked = false;
boolean yearChecked = false;
if(element.getParentElement() != null) {
// Check genre = "action"
genreChecked = element.getParentElement().getAttributeValue("genre").equals("action");
// Check date >= 1995
yearChecked = Integer.parseInt(element.getChild("year").getText()) >= 1995;
}
return genreChecked && yearChecked;
}
};

// Browse "dvd" item and do a Filtered search
System.out.println("------\nFiltered Search...");
for(Object object : root.getChildren("dvd_list")) {
Element dvdList = (Element) object;
// Browse the list of "dvd" Element matching our Filter
for(Object searchResultOb : dvdList.getContent(myDvdFilter)) {
Element dvd = (Element) searchResultOb;
System.out.println(dvd.getChild("title").getText());
}
}
}
}

Here is the result:

Parsing D:\eclipse3.4\workspace\JDOM\dvd_collection.xml ...
------
Filtered Search...
Die Hard with a Vengeance
Die Hard 4.0

I only show you the basics functionalities of JDOM, just to show you its simplicity.
I invite you to take a look to the JDOM API Documentation to learn more about it

To spread a hierarchy of classes, normally you simply add methods which provide desired behavior. It can happen however that this behavior is not consistent with the logic of the existent object model. It is also possible that you do not have access to existent code. In such situations, it can be impossible to spread the behavior of hierarchy without changing his classes. The Visitor Pattern precisely allows the developer of a hierarchy to insert a support for cases where other developers would like to spread his behavior.

This design pattern allows an external class to reach the internal variables of other classes (going contrary to concepts of POO). This model is useful when they have a reasonable number of instances of a small number of classes and that we want to perform operations which implicate them all (or many of them).

If deporting operations contained in a class towards another one can seem bad for POO, there are good reasons to make it. Indeed, if these operations are identical for every class instead of duplicating this method it is preferable to put these operations in a visitor (operation centralization). The visitor will use then the internal data of every object to perform asked operation.

In practice, the Visitor Pattern is realized in the following way: every class that can be “visited” must make available a public method « accept » taking as argument an object of type “visitor”. The « accept » method will call the « visit » method of the visitor object with the visited object as argument. In that way, a visitor object will be able to know the reference of the visited object and call his public methods to acquire data necessary for the treatment to perform (counting, generation of report, etc).

Here is an example to make the whole thing much more understandable

Let’s create a hierarchy: We will define a house in which we will put a list of house elements (living room, bathroom, bedroom, garden, garage…) and implements the visitor pattern in this hierarchy…

First, let’s define the visit able interface to make our house elements able to accept the visitor:

public interface IHouseElement {
public void accept(IVisitor visitor);
}

Then, let’s define the house and its elements:

public class Garden implements IHouseElement {
private int sq_ft;
private boolean swimmingPool;
public int getSq_ft() {
return sq_ft;
}
public boolean hasSwimmingPool() {
return swimmingPool;
}
public Garden(int sq_ft, boolean swimmingPool) {
this.sq_ft = sq_ft;
this.swimmingPool = swimmingPool;
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}

public class CarPark implements IHouseElement {
private int carNb;
public int getCarNb() {
return carNb;
}
public CarPark(int carNb) {
this.carNb = carNb;
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}

public class Room implements IHouseElement {
private String name;
private int sq_ft;
public String getName() {
return name;
}
public int getSq_ft() {
return sq_ft;
}
public Room(String name, int sq_ft) {
this.name = name;
this.sq_ft = sq_ft;
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}

public class Bedroom extends Room {
private int bedNb;
public int getBedNb() {
return bedNb;
}
public Bedroom(String name, int sq_ft, int bedNb) {
super(name, sq_ft);
this.bedNb = bedNb;
}
public void accept(IVisitor visitor) {
visitor.visit((Room) this);
visitor.visit(this);
}
}

public class Bathroom extends Room {
private int showerNb;
private int bathNb;
public int getShowerNb() {
return showerNb;
}
public int getBathNb() {
return bathNb;
}
public Bathroom(String name, int sq_ft, int showerNb, int bathNb) {
super(name, sq_ft);
this.showerNb = showerNb;
this.bathNb = bathNb;
}
public void accept(IVisitor visitor) {
visitor.visit((Room) this);
visitor.visit(this);
}
}

public class House {
private String name;
private IHouseElement[] houseElements;
public String getName() {
return name;
}
public IHouseElement[] getHouseElements() {
return houseElements;
}
public House() {
this.name = "My house";
this.houseElements = new IHouseElement[] {
new Room("Living room", 600),
new Bedroom("first bedroom", 300, 1),
new Bathroom("little bathroom", 100, 1, 0),
new Bedroom("second bedroom", 500, 1),
new Bathroom("big bathroom", 400, 1, 1),
new Garden(1200, true),
new CarPark(1)};
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}

Next we have to define the visitor interface and we’ll create two different possible visitor implementations.

public interface IVisitor {
public void visit(House house);
public void visit(Room room);
public void visit(Bathroom bathroom);
public void visit(Bedroom bedroom);
public void visit(Garden garden);
public void visit(CarPark carPark);
}

First implementation: Visit the house and list its elements

public class PrintVisitor implements IVisitor {
public void visit(House house) {
System.out.println("Visiting house: "+house.getName());
for(IHouseElement room : house.getHouseElements()) {
room.accept(this);
}
System.out.println("House visited...\n");
}
public void visit(Room room) {
System.out.println("Visiting room: "+room.getName()+" ("+room.getSq_ft()+" sq ft)");
}
public void visit(Bathroom bathroom) {
System.out.println("  - "+bathroom.getShowerNb()+" shower(s)");
System.out.println("  - "+bathroom.getBathNb()+" bath(s)");
}
public void visit(Bedroom bedroom) {
System.out.println("  - "+bedroom.getBedNb()+" bed(s)");
}
public void visit(Garden garden) {
System.out.println("Visiting Garden: ");
if(garden.hasSwimmingPool())
System.out.println("  - With a swimming pool");
}
public void visit(CarPark carPark) {
System.out.println("Visiting CarPark: ");
System.out.println("  - "+carPark.getCarNb()+" parking place(s)");
}
}

Second implementation: Visit the house to get its total surface

public class SurfaceVisitor implements IVisitor {
private int totalSqFt;
public SurfaceVisitor() {
this.totalSqFt = 0;
}
public void visit(House house) {
System.out.println("Visiting house: "+house.getName());
for(IHouseElement room : house.getHouseElements()) {
room.accept(this);
}
System.out.println("\nHouse total surface = "+totalSqFt+" sq ft\n");
}
public void visit(Room room) {
System.out.println("Visiting room: "+room.getName());
System.out.println(" – "+room.getSq_ft()+" = "+(this.totalSqFt += room.getSq_ft()));
}
public void visit(Bathroom bathroom) {
// nothing to do
}
public void visit(Bedroom bedroom) {
// nothing to do
}
public void visit(Garden garden) {
System.out.println("Visiting Garden: ");
System.out.println(" – "+garden.getSq_ft()+" = "+(this.totalSqFt += garden.getSq_ft()));
}
public void visit(CarPark carPark) {
// nothing to do
}
}

Finally, run a little test:

public class Test {
public static void main(String[] args) {
House house = new House();
IVisitor printVisitor = new PrintVisitor();
IVisitor surfaceVisitor = new SurfaceVisitor();
house.accept(printVisitor);
System.out.println("--------");
house.accept(surfaceVisitor);
}
}

Here is the output:

Visiting House: My house
Visiting Room: Living room (600 sq ft)
Visiting Room: first bedroom (300 sq ft)
  - 1 bed(s)
Visiting Room: little bathroom (100 sq ft)
  - 1 shower(s)
  - 0 bath(s)
Visiting Room: second bedroom (500 sq ft)
  - 1 bed(s)
Visiting Room: big bathroom (400 sq ft)
  - 1 shower(s)
  - 1 bath(s)
Visiting Garden
  - With a swimming pool
Visiting CarPark
  - 1 parking place(s)
House visited...

--------
Visiting House: My house
Visiting Room : Living room
– 0 + 600 = 600
Visiting Room : first bedroom
– 600 + 300 = 900
Visiting Room : little bathroom
– 900 + 100 = 1000
Visiting Room : second bedroom
– 1000 + 500 = 1500
Visiting Room : big bathroom
– 1500 + 400 = 1900
Visiting Garden
– 1900 + 1200 = 3100

House total surface = 3100 sq ft

This example show you the power and the interest of this pattern. But you’ve got to take care; Even if the visitor pattern is great, he has some limits: He is very dependent of the data structure.

Look at our house example: Let’s imagine that the Bedroom and Bathroom classes are not implemented in the IVisitor interface. The Bedroom and Bathroom instance would never been visited, so we wouldn’t be able to distinguish those two different type of Room. Of course you will say that to avoid this problem we just have to take care to include all the subclasses of our hierarchy in the visitor interface (like we do in the example). But if our data structure improves? For example if a new Room type is defined in the future, you won’t be able to visit it without redefining the IVisitor interface .

Another problem is the risks present in the data structure itself. If you develop a visitor without knowing the code of the visited hierarchy, you can’t be aware of everything concerning the original behavior of this hierarchy and the way it’s coding, so you can get trapped.

I hope that now you are aware of what’s the Visitor Pattern

Cannot find a solution where both Match[requiredCapability: org.eclipse.equinox.p2.iu/org.eclipse.team.svn.feature.group/[0.7.1.I20080612-1500,0.7.1.I20080612-1500]] and Match[requiredCapability: org.eclipse.equinox.p2.iu/org.eclipse.team.svn.feature.group/[0.7.3.I20080814-1500,1.0.0)] can be satisfied.
Unsatisfied dependency: [org.polarion.eclipse.team.svn.connector.svnkit.feature.group 2.0.3.I20080814-1500] requiredCapability: org.eclipse.equinox.p2.iu/org.eclipse.team.svn.feature.group/[0.7.3.I20080814-1500,1.0.0)
Unsatisfied dependency: [org.polarion.eclipse.team.svn.connector.svnkit.feature.group 2.0.3.I20080814-1500] requiredCapability: org.eclipse.equinox.p2.iu/org.polarion.eclipse.team.svn.connector.feature.group/0.0.0
Unsatisfied dependency: [org.polarion.eclipse.team.svn.connector.svnkit15.feature.group 2.0.3.I20080814-1500] requiredCapability: org.eclipse.equinox.p2.iu/org.eclipse.team.svn.feature.group/[0.7.3.I20080814-1500,1.0.0)
Unsatisfied dependency: [org.polarion.eclipse.team.svn.connector.svnkit15.feature.group 2.0.3.I20080814-1500] requiredCapability: org.eclipse.equinox.p2.iu/org.polarion.eclipse.team.svn.connector.feature.group/0.0.0
Unsatisfied dependency: [org.polarion.eclipse.team.svn.connector.feature.group 2.0.3.I20080814-1500] requiredCapability: org.eclipse.equinox.p2.iu/org.eclipse.team.svn.feature.group/[0.7.3.I20080814-1500,1.0.0)

Just like everyone I add this url in p2 :
http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/
The error comes out when I tried to Install the followings:

So I tried again but this time I unchecked the SVN Connectors and kept the SVN Team Provider. This time the installation worked well and I restarted my Eclipse to finish it. Of course, even if the SVN Team Provider was installed, I can’t use it without a SVN Connector. So I retried to install the SVN Connector, but the error cames out again…

On the subversive website they talk about the Subversive plug-in update site:
http://download.eclipse.org/technology/subversive/0.7/update-site/
So I add it in p2 and I retried the install but it failed again…

At this time I really don’t understand what was appening. But after some google search, I got the solution: The SVN Team Provider version in the Ganymede update site is not the latest version. To get it works with the Connectors you’ve got to update it to the latest version. Here are the steps to make it works :

1. Go to Help->Software Updates.
2. Click on the “Available Software” tab.
3. Unfold the Ganymede->Collaboration Tools node, and if your experience is like mine, you will see the “SVN Team Provider (Incubation)” item with this version identifier, “0.7.1.I20080612-1500″. What you really need (since the Subversive/Polarion team posted updates) is the version from 2008-08-01.
4. Click on “Manage Sites…”.
5. Uncheck the “Ganymede” checkbox (http://download.eclipse.org/releases/ganymede)
6. Scroll down to find “http://download.eclipse.org/technology/subversive/0.7/update-site/”, select it and click “OK”.
7. You should be back on the “Available Software” tab, with only the subversive items present. Unfold the “Subversive SVN Team Provider Plugin (Incubation)” item, and you will see the “SVN Team Provider (Incubation)” item. Note that the version identifier is “0.7.3.I20080814-1500″.
8. Check the box, and click”install”. The install will be change to an update. Restart Eclipse at the end of the install.
9. Go to “Help->Software Updates”.
10. Choose the “Available Software” tab.
11. Click the “Add Site” button, and add “http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/”.
12. Check the SVNKit Connectors and click “Install”. Restart Eclipse at the end of the install.
13. Subversive should be working !

Thanks to Frank Carver and Graig Thomas

I’m starting this blog just to share and do a backup of the interesting things I found about Java & Eclipse.
I will try to update the blog the most often I can.

Enjoy.