Yogesh's Tech Blog

Using EnumSet by Example

2011-12-24T10:44:00.001-08:00

In previous example I have explained using enum using color constants. Java util collection has provides EnumSet, it is a specialized Set implementation for use with enum types. In this post I have explained usage of EnumSet using an example.

A text can have multiple attributes like bold, italic, underlined etc. Given a text can have these properties, defined a sample Text class with bit fields as text properties

public class Text {

    //defining Text properties using int

    public static final  int BOLD = 1<<0;

    public static final  int ITALIC = 1<<1;

    public static final int UNDERLINED = 1<<2;

    private int style;

    public Text(int style){

        this.style = style;

    public boolean isBold(){

        return (BOLD&style)==BOLD;

    public boolean isItalic(){

        return (ITALIC&style)==ITALIC;

    public boolean isUnderlined(){

        return (UNDERLINED&style)==UNDERLINED;

    public static void main(String[] args) {

        Text t = new Text(BOLD|ITALIC);

        System.out.println("isBold = " + t.isBold());

        System.out.println("is Italic = "+ t.isItalic());

        System.out.println("is Underlined = " + t.isUnderlined());

Above class uses bit operation to apply properties. Usage of the Text class is shown in main() method.Text’s constructor accepts styles and based on bid operations the properties styles are decided. Output of above program

isBold = true
is Italic = true
is Underlined = false

As above program using bit field, it has all disadvantages of int enum constants as discussed in previous post. Above implementation is prone to error as well as not type safe.

Above functionalities can be achieved by EnumSet, EnumSet provides efficient way of representing set of values from same enum type.

public class Text {

    public static enum Style {

        BOLD, ITALIC, UNDERLINED

    Set<Style> styles = null;

    public Text(Set<Style> styles){

        this.styles = styles;

    public boolean isBold(){

        return styles.contains(Style.BOLD);

    public boolean isItalic(){

        return styles.contains(Style.ITALIC);

    public boolean isUnderlined(){

        return styles.contains(Style.UNDERLINED);

    public static void main(String[] args) {

        Text t = new Text(EnumSet.of(Style.BOLD,Style.UNDERLINED));

        System.out.println("isBold = " + t.isBold());

        System.out.println("is Italic = "+ t.isItalic());

        System.out.println("is Underlined = " + t.isUnderlined());

Unlike previous implementation, we have defined enum for styles constants and Text’s constructor accept Set<Style> as parameter.EnumSet.of(…) returns of instance of EnumSet which acts as Set of constants of Style enum. This instance is equivalent to any other Collection classes and supports all corresponding functionalities like contains(). This approach provides additional benefits compared to previous implantations.

Type Safe
All benefits of Collection framework
Error safe

Java Enum in details

2011-12-24T08:28:00.001-08:00

Java 5 has brought linguistic support for enumerated types. An enum type is a type whose fields consist of a fixed set of constants. The enum provides following features

Typesafe
Namespace
Printable constants values

Typical and often enum is being used to replace int constants. For example constants for color codes

public static final int RED = 0;

public static final int GREEN = 1;

public static final int BLUE = 3;

public static final int WHITE =4;

public static final int BLACK = 6;

This code can be replaced by following enum

public enum StandardColor {

    RED,GREEN,BLUE,WHITE,BLACK

Given the above enum declared, we can use the same to communicate the color preferences. For example we have Window class and it supports setting background color using setBackgroundColor(StandardColor color). One can call setBackgroundColor method on Window's instance to set background color, as shown in code below

public class Window{

    //..

    public setBackgroundColor(StandardColor color){

        if(color == StandardColor.Black){

            setBackgroundColor(#000000);

        } else if(color == StandardColor.WHITE){

            setBackgroundColor(#FFFFFF);

        //..

Windows myWindow = new Window();

myWindow.setBackgroundColor(StandardColor.BLACK);

Everything will go smooth till you have same understanding between StandardColor enum elements declaration and its implementers. Now consider the case you have to declare another color entry called “MY_COLOR” and corresponding html code will be “#0000A0”. To let the corresponding html code we may document in comment.

enum StandardColor {

    BLACK,WHITE,RED,GREEN,BLUE,

/**

     * HTML Code #0000A0

*/

    MY_COLOR

Addition to that we need to modify setBackgroundColor() method

public setBackgroundColor(StandardColor color){

    if(color == StandardColor.Black){

        setBackgroundColor(#000000);

    } else if(color == StandardColor.WHITE){

        setBackgroundColor(#FFFFFF);

    } else if(color == StandardColor.MY_COLOR){

        setBackgroundColor(#0000A0);

    //..

Here is the problems, it you modify the color code, then all corresponding needs to be changed.

Java programming language enum types are much more powerful, the enum class body can include methods and other fields.Each enum constants can be declared with values. These values are passed to the constructor when constants are created. Enum StandardColor constants with RGB values to represent its actual value will make it self explanatory.

enum StandardColor {

    RED(255,0,0),

    GREEN(0,255,0),

    BLUE(0,0,255),

    WHITE(255,255,255),

    BLACK(0,0,0) ;

    final int r,g,b;

    private StandardColor(int rParam, int gParam, int bPram){

        r = rParam;

        g = gParam;

        b = bPram;

    public String getHexValue(){

        return "#"+ Integer.toHexString(r)+Integer.toHexString(g)+Integer.toHexString(b);

    private String intToHex(int i){

        return Integer.toHexString(i);

Here enum StandardColor constants accept three integer representing red, green and blue values while declaring it. As seen in code above , it has private constructor with three integers and a public method getHexValue() to get html value of color. Now the Windows.setBackgroundColor(StandardColor) method will be much more simpler that previous version.

public setBackgroundColor(StandardColor color){

    setBackgroundColor(color.getHexValue());

Now doesn’t matter what modification you do in StandardColor enum like introducing new constants or changing constant’s value, all dependents need not to be cared.

Type Inference in Java

2011-12-10T06:11:00.001-08:00

As part of Generics , Java language supports type safe programming. It allows a type or method to operate on objects of various types while providing compile-time type safety. The most common use case is while using Java Collection framework. For example if you define a list of string and trying to add integer value to the list, compiler throws error.

List list = new ArrayList();

//Compilation Error : he method add(int, String) in the type List is not applicable for the arguments (int)

list.add(10);

As a developer you may always notice redundancy in defining parameter type information in both the side of declaration. As off Java 1.6, language doesn’t provide any feature to overcome it.

Using Static Factory : One possible way to overcome this problem by using static factory methods. If you frequently use typed list or map in application then you can define generic static factory methods which returns you required typed map or list.

public static   HashMap getMapInstance(){    
    return new HashMap();
}
public static  ArrayList getTypedList(){    
    return new ArrayList();
}

Above code snippet defines two static generic factory methods, which returns of specific parameter type list or map. While using these factory methods, java automatically infer parameter types based on left side type declaration.

//Using Static factory Methods,

Map> map2 = getMapInstance();

Map map3 = getMapInstance();

List doubleList = getTypedList();

Diamond feature in Java 7: In java 7 you can replace the type arguments required to invoke the constructor of a generic class with an empty set of type parameters (<>) as long as the compiler can infer the type arguments from the context. This pair of angle brackets is informally called the diamond ’ <>’.

Pattern matching using java.util.regex

2011-11-25T00:45:00.001-08:00

java.util.regex library is available since Java 1.4. It can be used for matching character sequences against pattern specified by regular expression. It has two main classes Pattern and Matcher. An instance of the Pattern class represents a regular expression that is specified in string form in a syntax.

Instances of the Matcher class are used to match character sequences against a given pattern. Input is provided to matchers via the CharSequence interface in order to support matching against characters from a wide variety of input sources.

Here is the simple example, If you have to extract part of string based on the fixed pattern defined. For example the simple greeting string

“Hello Yogesh, Welcome to Hyderabad.”

In this sentence, we have to extract two info like name and location ( Yogesh & Hyderabad). First of all we need to define pattern to extract the same information. Java support regular expression for pattern matching, go through Java Pattern documentation to know more about it.

Above figure shows building pattern for given text to get specific text out of it. Here we have using grouping ‘(‘ & ’)’ to exact what he want. Sample code is below

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class TestPattern {

    public static void main(String[] args) {

        String patternString = "Hi (.*), Welcome to (.*).";

        String sampleText =    "Hi Yogesh, Welcome to Hyderabad(India).";

        //Create Pattern from pattern string.

        Pattern pattern = Pattern.compile(patternString);

        Matcher matcher = pattern.matcher(sampleText);

        if(matcher.find()){

            System.out.println("Name = " + matcher.group(1));

            System.out.println("Location = " + matcher.group(2));

        }else{

            System.out.println("Didn't find anything");

Output of Above Program :

Name = Yogesh
Location = Hyderabad(India)

As per pattern string , we have grouped the sample text into three groups as shown in figure below.

By default group 0 will be the complete text and other groups are numbered from left to right. As result of this it prints “Yogesh” for group 1 and “Hyderabad(India)” for group 2.

Escaping the literals : There will be some text which includes regular expression literal like ‘.’, ’(‘, ’)’, ’+’ etc. Pattern class has provided with an utility method Pattern.quote() to escape such literals.

WeakHashMap by example

2011-11-17T01:25:00.001-08:00

Usually we read following explanation about java.util.WeakHashMap

“A hashtable-based Map implementation with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use”

Unlike java.util.HashMap, WeakHashMap maintain weak reference for the all keys objects and strong reference of value objects. As per features of weak reference, they are more prone to be collection by GC. WeakHashMap runs some kind of unknown services to remove all the entries from collection whose keys are already garbage collected.

It means entries in weak hash map may changes over the time. Whenever there is a need of more memory to your application, GC cycle will execute and its job is to collect all un-referenced objects or weak references. In some cases GC may collected keys of weak hash map as those are a weak references. Once keys are garbage collected , WeakHashMap’s implementation job is to clear all such entries.

See the following program, I have tried to create a situation where GC has to run and remove all un-referenced or weak references. Result of this WeakHashMap’s size changes time to time.

public class TestWeakHashMap {

    private static Map<Object, Object> global = new HashMap<Object, Object>();

    static String bigStr = "bnerobnrobnronbuiornb rtbnrnbrnbunrtbnrtnbirtnbintibnriiubnreneo;nbero;bnro;ebn" +

            ";ronbornbal;ndl;blxdnblsdnbo;ernhbel/abnesng;obnseobnl;sbnke;abnosei;bnserio;bhsrnpibnsdropbndro;" +

            "nbpserjbsp[jp[bneriopanbl;S";

    private static Map<Object, Object> map = new HashMap<Object, Object>();

    private static Map<Object, Object> weakMap = new WeakHashMap<Object, Object>();

    public static void main(String[] args) {

        Thread consumeMemoryThread = new Thread(new Runnable() {

            @Override

            public void run() {

                consumeMemory();

});

        Thread normalMapThread = new Thread(new Runnable() {

            @Override

            public void run() {

                testHashMap();

});

        Thread weakMapThread = new Thread(new Runnable() {

            @Override

            public void run() {

                testWeakHashMap();

});

        consumeMemoryThread.start();

        normalMapThread.start();

        weakMapThread.start();

        try {

            consumeMemoryThread.join();

            normalMapThread.join();

            weakMapThread.join();

        } catch (InterruptedException e) {

            e.printStackTrace();

        System.out.println("Size of HashMap = " + map.size());

        System.out.println("Size of Weak HashMap = " + weakMap.size());

/**

     * Putting values in HashMap.

*/

    public static void testWeakHashMap() {

        Object keyObj = new Object();

        weakMap.put(keyObj, new Object());

        for (int i = 0; i < 10000; i++) {

            weakMap.put(new Object(), bigStr);

            if (i % 1000 == 0) {

                try {

                    Thread.sleep(100);

                } catch (Exception e) {

                    e.printStackTrace();

/**

     * Putting values to Weak HashMap.

*/

    public static void testHashMap() {

        Object keyObj = new Object();

        weakMap.put(keyObj, new Object());

        for (int i = 0; i < 10000; i++) {

            map.put(new Object(), bigStr);

            if (i % 1000 == 0) {

                try {

                    Thread.sleep(100);

                } catch (Exception e) {

                    e.printStackTrace();

/**

     * Just Consuming the memory.

*/

    public static void consumeMemory() {

        for (int i = 0; i < 1000000; i++) {

            global.put(new Object(), bigStr);

Output of the Program :

Size of HashMap = 10000
Size of Weak HashMap = 5001

In above program, 10000 entries have been put in both HashMap , but at end of the program , HashMap contains proper 10,000 entries but WeakHashMap contains only 5001, rest entries has been removed because of key garbage collection.

Use case : WeakHashMap is useful when an application want to store some information in memory but it is not as important as other other application specific data, for example the data which can easily be retrieved from the source in case of garbage collected .

It is an idea solution for in-memory cache implantation where cache miss is not big deal. It helps the application to maintain required information in the memory without affecting whole memory usage or avoiding OutOfMemoryException.

Disadvantage : The main limitation of the this implementation is lack of control. User can not control the garbage collection of keys by GC , there is no way to configure the keys garbage collection based some condition like least used keys, oldest keys etc.

Eclipse Plug-in Development:Working with Project Facet

2011-11-13T10:32:00.001-08:00

Every project may have one or more natures. Each nature brings set of properties to the project.For example a Java project has “src” directory and “bin” as build directory or you may want to associate a set of libraries to your custom project.

Faceted Project Framework provides a powerful mechanism for extending the capabilities of the Web Tools Platform. Project facets are typically used as a way of adding functionality to a project. When a facet is added to the project it can perform any necessary setup actions such as copying resources, installing builders, adding natures, etc. Facets can also be used as markers for enabling user interface elements.

This post explains defining a facet and using it.

Prerequisites :

Install WST eclipse plug-in
Add dependencies to MANIFEST.MF

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: Sample

Bundle-SymbolicName: com.facet.sample;singleton:=true

Bundle-Version: 1.0.0.qualifier

Bundle-Activator: com.facet.sample.Activator

Bundle-Vendor: FACET

Require-Bundle: org.eclipse.ui,

 org.eclipse.core.runtime,

 org.eclipse.wst.common.project.facet.core;bundle-version="1.4.100",

 org.eclipse.jst.common.project.facet.ui;bundle-version="1.4.100",

 org.eclipse.core.resources;bundle-version="3.6.0"

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ActivationPolicy: lazy

1. Extend extension-point “org.eclipse.wst.common.project.facet.core.facets”, provide name description, version , etc . Plug-in.xml will look like below

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse version="3.4"?>

<plugin>

   <extension

         point="org.eclipse.wst.common.project.facet.core.facets">

      <category id="com.facet.sample.category1">

         <description> Sample Facet Desciption </description>

      </category>

      <project-facet id="my.facet">

         <label> My Facet </label>

         <description> My Facet Description </description>

      </project-facet>

      <project-facet-version facet="my.facet" version="1.0"/>

   </extension>

</plugin>

After above modification in plug-in.xml , “Project Facets” page in “Facet Project” wizard will shows newly declared facet in available facet list

Here we have just declared facet only, we need to provide action delegate as well as configurator .

<action

           facet="my.facet"

           id="my.facet.action.INSTALL"

           type="install"

           version="1.0">

        <delegate

              class="com.facet.sample.MyFacetInstallDegegate">

        </delegate>

     </action>

Now we have declared “Install” action and corresponding action delegate. MyFacetInstallDelegate has to implement org.eclipse.wst.common.project.facet.core.IDelegate and provide implementation for execute() method. Whenever “MyFacet” is selected to install, MyFacetInstallDelegate.execute() gets call back. I am creating two directories “src” & “bin” under project.

import java.io.File;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.wst.common.project.facet.core.IDelegate;

import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;

public class MyFacetInstallDegegate implements IDelegate {

    @Override

    public void execute(IProject project, IProjectFacetVersion fv,

            Object config, IProgressMonitor monitor) throws CoreException {

        IPath projectPath = project.getLocation();

        //creating src & bin folder structure

        createFolderStructure(projectPath);

    private void createFolderStructure(IPath path){

     //....

In this post, I have explaining creating facet for project and taken appropriate action when the facet is being selected.

StringBuffer vs StringBuilder : Performance improvement figures

2011-11-13T00:15:00.001-08:00

IN previous post StringBuffer vs StringBuilder, I have explained benefits of using StringBuilder over StringBuffer. Here are some performance figure using both for concatenating string.

package com.test;

public class StringConcatenateTest {

    public static void main(String[] args) {

        System.out.println("Using StringBuffer");

        long bufferTime = usingStringBuffer();

        System.out.println("Using String Builder");

        long builderTime = usingStringBuilder();

        double perc = ((double)(bufferTime-builderTime)/bufferTime)* 100;

        System.out.println("Improved in performance = " + perc + "%");

    public static long usingStringBuffer(){

        long startTime = System.currentTimeMillis();

        System.out.println("\tStart time = "+ startTime);

        StringBuffer sb = new StringBuffer();

        for(int i=0;i<1000000;i++){

            sb.append("\tSample test string :: ");

        String resultStr = sb.toString();

        long endTime = System.currentTimeMillis();

        System.out.println("\tEnd time ="+endTime);

        System.out.println("\tTotal time taken = "+ ((endTime - startTime)));

        return endTime-startTime;

    public static long usingStringBuilder(){

        long startTime = System.currentTimeMillis();

        System.out.println("\tStart time = "+ startTime);

        StringBuilder sb = new StringBuilder();

        for(int i=0;i<1000000;i++){

            sb.append("\tSample test string :: ");

        String resultStr = sb.toString();

        long endTime = System.currentTimeMillis();

        System.out.println("\tEnd time ="+endTime);

        System.out.println("\tTotal time taken = "+ ((endTime - startTime)));

        return endTime-startTime;

Here is the output

Using StringBuffer
    Start time = 1321171861338
    End time =1321171861909
    Total time taken = 571
Using String Builder
    Start time = 1321171861910
    End time =1321171862393
    Total time taken = 483
Improved in performance = 15.411558669001751%

Lazy initializing your code

2011-11-12T23:44:00.001-08:00

Many time we have static fields in our Java classes. These fields are get initialized with loading of your classes and all other static fields. But many time its not the urgent to initialize few of the fields while loading the class itself. Here the concept of lazy initialization comes in picture.

Consider the code below

public class LazyInitilaizationTest {

    public static String[] field = getStringContent();

    static {

        System.out.println("Loading Class");

    public static String[] getStringContent(){

        System.out.println("Initializing field");

        return new String[]{};

    public static void main(String[] args) {

        System.out.println("Accessing Field");

        System.out.println(field);

Here the class has private & static field which gets initialized by invoking getStringContent() method. Running above class prints following output

Initializing field
Loading Class
Accessing Field

Above output says that field get initialized with loading the class, regardless when and where it is being used in the program. (“Initializing field” get displayed before “Accessing field”).

If you want to defer the initialization code whenever it will be used , you need wrap the static fields in internal private class for lazy initialization.

public class LazyInitilaizationTest {

    static {

        System.out.println("Loading Class");

    private static class Fields {

        public static String[] field = getStringContent();

        public static String[] getStringContent(){

            System.out.println("Initializing field");

            return new String[]{};

    public static void main(String[] args) {

        System.out.println("Accessing Field");

        System.out.println(Fields.field);

In above class an another wrapper static class is being used. The output of above code is

Loading Class
Accessing Field
Initializing field

Here you can notice initialization happened after the field has been invoked (“Accessing field” get displayed before “Initializing field”).

Characteristics of Object.equals()

2011-10-15T21:53:00.001-07:00

I am come across the characteristics specified for implementation of equals() method in Java Classes. There is nothing like which we don’t know, but here it is well explained. I thought of sharing the same just for recalling old Java learning days

Here are the characteristics that every implementation of Object.equals() should follow

Reflexive. For any non-null reference value x, x.equals(x) should return true
Symmetric. For any non-null reference values x and y. x.equals(y) should return true if and only if y.equals(x) returns true.
Transitive. For any non-null references value x,y and z , it x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
Consistent. For any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x, x.equals(null) should return false.

So next time overriding equals() method, do remember these guidelines .

Eclipse PDE: Everything about Editor Part 5

2011-10-01T21:21:00.001-07:00

Code Completion using Content Assist

This post explains about completion proposal feature of eclipse editor framework. This is part of Everything About Editor series. Content assist provides content assist help to developer while writing code in editor. It helps from static suggestion of language keyword to methods suggestion for dynamic reference on hitting “Ctrl-Space” or entering any of activator character like ‘.’.

Following two interfaces plays key role in implementing code completion for customer editor.

ICompletionProposal – Responsible for providing set of proposals text, associated icons etc.
IContentAssistProcessor – Responsible for calculating the completion proposals at a point in the editor. It also defines character on which it shoud auto-activate.

In this example we are going to see providing content assist then user enters ‘#’. To achieve this we need to implement IComppletionProposal that will return set of proposals as well as tells framework which character activate content assist by overriding getCompletionProposalAutoActivationCharacters() method from same interface.

public class MyContentAssistProcessor implements IContentAssistProcessor {

    @Override

    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,

            int offset) {

        String text = getTobeCompleteText(viewer.getDocument(), offset);

        return new ICompletionProposal[]{

            new MyCompletionProposal("Proposal 1",offset,text.length()),

            new MyCompletionProposal("Proposal 2",offset,text.length())

};

    @Override

    public IContextInformation[] computeContextInformation(ITextViewer viewer,

            int offset) {

        // TODO Auto-generated method stub

        return null;

    @Override

    public char[] getCompletionProposalAutoActivationCharacters() {

        return new char[] {'#'};

    @Override

    public char[] getContextInformationAutoActivationCharacters() {

        // TODO Auto-generated method stub

        return null;

    @Override

    public String getErrorMessage() {

        // TODO Auto-generated method stub

        return null;

    @Override

    public IContextInformationValidator getContextInformationValidator() {

        // TODO Auto-generated method stub

        return null;

    private boolean isWhiteSpace(char c){

        if(c=='\n'||c=='\t'||c==' ')

            return true;

        return false;

    private String getTobeCompleteText(IDocument document, int currentOffset){

        int count = currentOffset;

        String tobeCompleteText="";

        try{

            while(--count>=0){

                char c = ' ';

                c = document.getChar(count);

                if(isWhiteSpace(c)){

                    break;

            tobeCompleteText = document.get(count+1, currentOffset-(count+1));

        }catch (Exception e) {

            e.printStackTrace();

        return tobeCompleteText;

Second task is to implement ICompletionProposal interface that actually handles proposals. It provides text and image to be displayed in proposal window, inserting proposal text to editor.

public class MyCompletionProposal implements ICompletionProposal {

    String text;

    int offset,contextTextLength;

    MyCompletionProposal(String text,int offset,int contextTextLength){

        this.text = text;

        this.offset = offset;

        this.contextTextLength = contextTextLength;

    @Override

    public void apply(IDocument document) {

        try {

            document.replace(offset, 0, text);

        } catch (BadLocationException e) {

            e.printStackTrace();

    @Override

    public Point getSelection(IDocument document) {

        // TODO Auto-generated method stub

        return null;

    @Override

    public String getAdditionalProposalInfo() {

        // TODO Auto-generated method stub

        return null;

    @Override

    public String getDisplayString() {

        return text;

    @Override

    public Image getImage() {

        return null;

    @Override

    public IContextInformation getContextInformation() {

        return null;

And Final task to update SourceViewConfiguration to install the custom content assist proposal

Eclipse PDE: Everything about Editor Part 4

2011-09-10T12:16:00.001-07:00

Auto-Edit Strategy

This post of Everything About Editor series explains about editors auto complete feature. Auto edit feature of any editor helps developer while writing code, for example in java editor of eclipse provides auto complete features for string quotes , open braces etc. When you type open curly braces ‘{‘ , eclipse java editor auto inserts closing curly braces considering line and indentation.

Here I am going to implement auto-edit strategy for open single , double quotes and opening curly braces ‘{‘. To use auto edits, you must implement the org.eclipse.jface.text.IAutoEditStrategy interface, which contains just one method:

void customizeDocumentCommand(IDocument document,DocumentCommand command);

This is called each time you make a change to the document with the
DocumentCommand object containing the information about that change. So, adding
indents or making any change to the text being changed is as simple as modifying
the DocumentCommand object.

1. Implement IAutoEditStrategy

package com.ydtech.eclipse.editor;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.DocumentCommand;

import org.eclipse.jface.text.IAutoEditStrategy;

import org.eclipse.jface.text.IDocument;

public class MyEditStrategy implements IAutoEditStrategy {

    @Override

    public void customizeDocumentCommand(IDocument document,

            DocumentCommand command) {

        try{

        if(command.text.equals("'")){

            command.text="''";

            configureCaret(command);

        } else if(command.text.equals("\"")){

            command.text ="\"\"";

            configureCaret(command);

        } else if(command.text.equals("{")){

            int currentLine = document.getLineOfOffset(command.offset);

            String indent = getIntend(document, currentLine);

            command.text="{"+"\r\n"+indent+"}";

            command.caretOffset = command.offset+1;

            command.shiftsCaret = false;

        }catch (BadLocationException e) {

            e.printStackTrace();

    private void configureCaret(DocumentCommand command){

        command.caretOffset = command.offset + 1;

        command.shiftsCaret = false;

    private String getIntend(IDocument document, int currentLine) throws BadLocationException{

        if(currentLine > -1){

            int start = document.getLineOffset(currentLine);

            int end = document.getLineLength(currentLine)-1 +start;

            int whiteSpaceEnd = getEndOfWhiteSpace(document, start, end);

            return document.get(start, whiteSpaceEnd-start);

        return "";

    private int getEndOfWhiteSpace(IDocument document, int start, int end) throws BadLocationException{

        while(start<end){

            char c = document.getChar(start);

            if(c==' ' || c=='\t'){

                start++;

                continue;

            return start;

        return end;

Above code listen determine when quote or double quote or opening curly brace inserted to editor and insert corresponding pairing character.

2. Configure SourceViewConfiguration , override getAutoEditStrategies method

@Override

    public IAutoEditStrategy[] getAutoEditStrategies(

            ISourceViewer sourceViewer, String contentType) {

        IAutoEditStrategy strategy = IDocument.DEFAULT_CONTENT_TYPE.equals(contentType)?new MyEditStrategy() : new DefaultIndentLineAutoEditStrategy();

        return new IAutoEditStrategy[]{strategy};

Eclipse PDE: Everything about Editor Part 3

2011-09-04T01:57:00.001-07:00

Syntax Highlighting

Part 3 of Eclipse PDE: Everything about Editor series deals with Syntax coloring. In previous post I have explained about all Eclipse Editor relegated concepts and document partition.

I have tried to explains Syntax highlighting in editor in this post. Syntax highlighting helps to provides different color and styles to different part of code. Eclipse provides a presentation reconciler, which divides the document into a set of tokens that define the background and foreground color, along with the font style for a section of text.

The document partitions define the content types within a document, while the presentation reconciler divided those individual content types into tokens for sets of characters that share the same color and font style. The presentation of the document must be maintained while the user continues to modify it. This is done through the use of a damager and a repairer.

A Damager takes the description of how the document was modified and returns a description of regions of the document that must be updated. For example, if a user types /*, all the text in the document up to */ must be repaired

The Repairer takes care of actually repairing the region of the document that the damager output by using the rules for dividing the region into tokens and the color and font information associated with the tokens.

Following steps explains process of defining syntax highlighter for custom editor.

1. Define Color provider

This class is responsible for providing color for specific set of tokens.

public class MyColorProvider {

    public static final RGB MULTI_LINE_COMMENT = new RGB(128, 0, 0);

    public static final RGB SINGLE_LINE_COMMENT = new RGB(128, 128, 0);

    public static final RGB DEFAULT = new RGB(0, 0, 0);

    protected Map fColorTable = new HashMap(10);

    public void dispose() {

        Iterator e = fColorTable.values().iterator();

        while (e.hasNext())

            ((Color) e.next()).dispose();

    public Color getColor(RGB rgb) {

        Color color = (Color) fColorTable.get(rgb);

        if (color == null) {

            color = new Color(Display.getCurrent(), rgb);

            fColorTable.put(rgb, color);

        return color;

2. Create rule for document scanner.

public class MyCodeScanner extends RuleBasedScanner {

    public MyCodeScanner(MyColorProvider provider) {

        IToken singleLineComment=

        new Token(new

        TextAttribute(provider.getColor(MyColorProvider.SINGLE_LINE_COMMENT)));

        IToken multiLineComment=

            new Token(new

            TextAttribute(provider.getColor(MyColorProvider.MULTI_LINE_COMMENT)));

        List rules= new ArrayList();

        // Add rule for single & multi line comments.

        rules.add(new EndOfLineRule("//", singleLineComment));

        rules.add(new MultiLineRule("/*","*/", multiLineComment));

        IRule[] result= new IRule[rules.size()];

        rules.toArray(result);

        setRules(result);

3. Provide PresentationReconciler in SourceViewConfiguration, which defines damager & repairer for each segment of code.

@Override

    public IPresentationReconciler getPresentationReconciler(

            ISourceViewer sourceViewer) {

        PresentationReconciler rc = new PresentationReconciler();

        DefaultDamagerRepairer dr= new DefaultDamagerRepairer(getCodeScanner());

        rc.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);

        rc.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);

        dr= new DefaultDamagerRepairer(getCodeScanner());

        rc.setDamager(dr, MyPartitionScanner.SINGLE_LINE_COMMENT);

        rc.setRepairer(dr, MyPartitionScanner.SINGLE_LINE_COMMENT);

        dr= new DefaultDamagerRepairer(getCodeScanner());

        rc.setDamager(dr, MyPartitionScanner.MULTI_LINE_COMMENT);

        rc.setRepairer(dr, MyPartitionScanner.MULTI_LINE_COMMENT);

        return rc;

    public MyCodeScanner getCodeScanner(){

        if(cScanner == null){

            cScanner = new MyCodeScanner(new MyColorProvider());

        return cScanner;

Run the plug-in as Eclipse Application, create .properties file (As we have defined custom editor in previous post in this series) and try typing single line comment and multi line comment. You will notice , color of this comment will be different than normal code section as shown in figure below.

Eclipse PDE: Everything about Editor Part 2

2011-09-04T00:10:00.001-07:00

Document Partition

In this series of “Eclipse PDE: Everything about Editor”, this post explains how to configure your document to represent different partition. Document partitions helps to manipulate different part of document in different way. For example there is not need to showing content assist in single line comment or multi line comment.

Here I am explaining defining partition for single and multi line comments

1. Define a custom partition scanner

Eclipse framework provides Rule based partition scanner, which allows us to define single or multi line rule for partitioning document content. We need to define Custome partition scanner extending org.eclipse.jface.text.rules.RuleBasedPartitionScanner. Override the constructor and define rules for partition . Below code snippets defines rule for single and multi line comments

public class MyPartitionScanner extends RuleBasedPartitionScanner {

    //Define COnstants for supported partition types

    public static final String SINGLE_LINE_COMMENT = "SINGLE_LINE_COMMENT";

    public static final String MULTI_LINE_COMMENT = "MULTI_LINE_COMMENT";

    public static final String[] PARTITION_TYPES = {SINGLE_LINE_COMMENT, MULTI_LINE_COMMENT};

    public MyPartitionScanner() {

        IToken singleLineToken = new Token(SINGLE_LINE_COMMENT);

        IToken multiLineToken = new Token(MULTI_LINE_COMMENT);

        List rules = new ArrayList();

        rules.add(new EndOfLineRule("//", singleLineToken));

        rules.add(new MultiLineRule("/*","*/",multiLineToken));

        IPredicateRule[] result= new IPredicateRule[rules.size()];

        rules.toArray(result);

        setPredicateRules(result);

2. Connect the above scanner to your DocumentProvider

Document provider connect partition scanner to underline document. This will be done in DocumentProvider’s constructor ( Defined in previous post)

@Override

    protected IDocument createDocument(Object element) throws CoreException {

        IDocument doc = super.createDocument(element);

        if (doc instanceof IDocumentExtension3) {

            IDocumentExtension3 extension3 = (IDocumentExtension3) doc;

            IDocumentPartitioner partitioner = new FastPartitioner(MyPlugin.getDefault().getMyPartitionScanner(),

                    MyPartitionScanner.PARTITION_TYPES);

            extension3.setDocumentPartitioner(MyPlugin.MY_PARTITIONING,

                    partitioner);

            partitioner.connect(doc);

        return doc;

In above code, MyPlugin calss is being used to get instance of document partition class.

public class MyPlugin extends AbstractUIPlugin {

    public final static String MY_PARTITIONING = "___my__partitioning____";

    private MyPartitionScanner fPartitionScanner;

    private static MyPlugin myPlugin =null;

    public MyPartitionScanner getMyPartitionScanner() {

        if (fPartitionScanner == null)

        fPartitionScanner= new MyPartitionScanner();

        return fPartitionScanner;

    public static MyPlugin getDefault(){

        if(myPlugin == null){

            myPlugin = new MyPlugin();

        return myPlugin;

3. Tell SourceViewConfiguration about document partition

@Override

    public String getConfiguredDocumentPartitioning(ISourceViewer sourceViewer) {

        return MyPlugin.MY_PARTITIONING;

    @Override

    public String[] getConfiguredContentTypes(ISourceViewer sourceViewer) {

        return new String[] {IDocument.DEFAULT_CONTENT_TYPE,MyPartitionScanner.MULTI_LINE_COMMENT,MyPartitionScanner.SINGLE_LINE_COMMENT};

Eclipse PDE: Everything about Editor

2011-09-03T08:53:00.001-07:00

Editors are the most important part of eclipse IDE framework. Editor are the primary framework to create and modify resource like files. Every eclipse plug-in or eclipse based products needs to provide custom editor for editing proprietary resources.

I am tried to put important parts of Eclipse Editor Framework in this pos. This is the first post from the series "Everything About Editor"

Eclipse divides the concept of a text editor into two parts: the document and the viewer.
While the document holds the actual content of the editor, the viewer is responsible
for handling the content display. This nice Model-View-Controller (MVC)-style
separation allows you to separate code that manipulates the content of the editor
from the part that manipulates its display.

The Document represents the "model" part of the text editor framework. It contains the actual textual content of the editor. It does not concern itself with the display of
the text in any way. A document allows you to set the actual textual content of an editor and contains methods to manipulate the content. It is defined by the org.eclipse.jface.text.IDocument interface. The document provides abstraction for lines. It does it with help of Position, which are like sticker to portion of text in the document.

The DocumentProvider create Document , it bridges between files on the disk and its representation as a document. DocmentProvider is responsible for loading file from disk and save it. There are many extension interfaces are provided for DocumenProvider , almost one for every release. concrete implementation are available for almost all extensions, you have to implement two methods createDocument and crateEmptyDocument. CreateDocument is responsible for defining partitions in document. It handles many task related files like

loading file from disk
representing it as Document in memory
saving the file to disk after modification
creating file modification notification

The Viewer is responsible or displaying the content of the document and is defined
by the org.eclipse.jface.text.ITextViewer interface. Eclipse provide a special subclass of ITextViwer specially for displaying source code "SourceViewer".

The org.eclipse.ui.editors.text.TextEditor class ties the document and
the viewer together and inserts Eclipse-specific functionality.The TextEditor implements the org.eclipse.ui.IEditorPart class, which -- as the name implies -- denotes to the Eclipse Workbench that it is part of the workbench and is an editor. An editor is associated with an IEditorInput class, which defines the protocol of editor input.

The SourceViewerConfiguration class provides methods to
access most of the UI-related helper objects the Eclipse framework provides and
that would be useful while creating the editor. It is responsible for following set of task

Hyperlink detection
Text Hover
Syntax highlighter
Auto edit
Code completion
Document petitioner
Undo Manager

Gets started with creating Custom Editor skeleton.

1. Create a plug-in project

2. Extend “org.eclipse.ui.editors” extension point

<extension

         point="org.eclipse.ui.editors">

      <editor

            class="com.ydtech.eclipse.editor.CustomEditor"

            default="false"

            extensions="properties"

            id="com.ydtech.eclipse.myeditor.editor1"

            name="Properties Editor">

      </editor>

   </extension>

3. Create class CustomEditor which extends org.eclipse.ui.editors.text.TextEditor.

4. Create MyDocument class extending Document.

5. Create document provider extending FileDocumentProvider and override createDocument & createEmptyDocument. Here createEmptyDocument returns new instance of MyDocument just created in previous steps

public class MyDocumentProvider extends FileDocumentProvider {

    @Override

    protected IDocument createEmptyDocument() {

        return new MyDocument();

    @Override

    protected IDocument createDocument(Object element) throws CoreException {

       // custom code .....

6. As explained previously Editor is responsible for bringing together Document and Viewer, it is only responsible for creating Document Provider. So override constructor of TextEditor and call setDocumentProvider()

public class CustomEditor extends TextEditor {

    public CustomEditor() {

        setDocumentProvider(new MyDocumentProvider());

Here we have skeleton ready for .properties file.

There is much more to come in this series.

Improved Exception handling in Java 7

2011-08-02T05:23:00.001-07:00

Java 7 has improved the exception handling by ease of development, reduced code duplication and intelligent throws clause.

1. More than one exception types in single catch block: Java 7 onwards single catch block can handle multiple exception types. Now Catch block can specify ‘|’ separated exception types instead of only one exception. It prevent code duplication in case when same operation has to perform for all of set of types of exceptions and improve code readability.

Old style :

try{

    //your code here

}catch (IOException ex) {

     log(ex);

     throw ex;

catch (SQLException ex) {

     log(ex);

     throw ex;

New style:

try{

    //your code here

}catch (IOException|SQLException ex) {

     logger.log(ex);

     throw ex;

2. Intelligent throws clause : Method declaration has to include the list of exception its is going to throws using throws clause. These exception types has to be matched with catch block throw statement. Java 7 onwards compiler is more intelligent to analysis the code and allows to declares exception types in method throws declaration based on following condition.

The try block is able to throw it.

There are no other preceding catch blocks that can handle it.

It is a subtype or supertype of one of the catch clause's exception parameters.

For example, consider code below

public void test1()throws Exception {

        try{

            File f = new File("sample");

            f.getAbsolutePath();// throws SecurityException exception

        }catch (Exception exp){//catching super type

            throw exp;//throwing Exception

In above code f.getAbsolutePath()throws SecurityException but catch block parameter is Exception ( Super type). As catch block is throwing exception of type Exception, throws clause in method declaration has mention Exception.

In Java7, same code you can write like below

public void test1()throws SecurityException {

        try{

            File f = new File("sample");

            f.getAbsolutePath();// throws SecurityException exception

        }catch (Exception exp){//catching super type

            throw exp;//throwing Exception

Here test1 method declares SecurityException instead of Exception. Java 7 compiler allows you specify exception type SecurityException in throws clause of method test1 because you can throw a exception that is super type of any of the type declared in the throws .

Here compiler knows exception of type SecurityException is being throw from try block.

Reference :

http://download.oracle.com/javase/7/docs/technotes/guides/language/catch-multiple.html

FileVisitor from NIO.2 File System API in Java 7

2011-07-09T21:09:00.001-07:00

As a part of project Coin ( Language changes ) in Java 7 improved version of file operation APIS has introduced, java.nio.file. There are many new functionalities has been introduced for ease of day to day programming, FileVisitor is one these APIs.

As explained above, new interface java.nio.file.FileVisitor has been introduced for traversing the file system. It has methods like preVisitDirectory(), postVisitDirectory(), visitFile() etc to give control to programmer to do any specific task while traversing/visiting the file system. A concrete implementation java.nio.file.SimpleFileVisitor has been provided those don't want to provide implementation for all of the methods from java.nio.file.FileVisitor.

Here is simple example using these new classes.

package com.test.jdk7;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.Files;
public class TestFileVisitor extends SimpleFileVisitor{
    private int nestedLavels = 0;
   
    public TestFileVisitor() {
        super();
    }
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
            throws IOException {
        System.out.println("");
        for(int i=0;i
            System.out.print(" ");
        System.out.println("- "+dir.getFileName());
        nestedLavels  = nestedLavels + 4 ;
        return super.preVisitDirectory(dir, attrs);
    }
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
            throws IOException {
        System.out.println("");
        for(int i=0;i
            System.out.print(" ");
        System.out.println("- "+file.getFileName());
        return super.visitFile(file, attrs);
    }
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc)
            throws IOException {
        nestedLavels = nestedLavels - 4;
        return super.postVisitDirectory(dir, exc);
    }
   
    public static void main(String[] args) {
        Path startingPoint = Paths.get("/home/yogesh/root");
        try {
            //sarting the taversing
            Files.walkFileTree(startingPoint,new TestFileVisitor());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}