javaVisitor

Headline

Modular programming with visitors in Java

The present implementation can be viewed as a variation on Contribution:javaInheritance. The Visitor pattern is applied to implement operations modularly. To this end, two visitor interfaces are defined: one for void visitors (that do not return any values), another one for returning visitors (with a designated type parameter for the result type). Indeed, Feature:Total calls for a returning visitor whereas Feature:Cut can be expressed as a void visitor - if an impure computation is assumed.

Illustration

The data model is implemented with class inheritance. For example Departments:

/**
 * A department has a name, a manager, employees, and subdepartments.
 */
public class Department extends Subunit implements Serializable {

	private static final long serialVersionUID = -2008895922177165250L;

	private String name;
	private Employee manager;
	private List<Subunit> subunits = new LinkedList<Subunit>();

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Employee getManager() {
		return manager;
	}

	public void setManager(Employee manager) {
		this.manager = manager;
	}

	public List<Subunit> getSubunits() {
		return subunits;
	}

	/**
	 * Accept a void visitor
	 */
	public void accept(VoidVisitor v) { v.visit(this); }

	/**
	 * Accept a returning visitor
	 */
	public <R> R accept(ReturningVisitor<R> v) { return v.visit(this); }

}

Feature:Closed serialization is implemented using Language:Java Technology:Object Streams:

    /*
     * Read (say, deserialize) a company.
     */
    public static Company deserializeCompany(String filename) {

        Object o = null;

        try {
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream in = new ObjectInputStream(fis);
            o = in.readObject();
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (Company) o;
    }

    /*
     * Write (say, serialize) a company.
     */
    public static boolean serializeCompany(Company c, String filename) {

        FileOutputStream fos = null;
        ObjectOutputStream out = null;

        try {
            fos = new FileOutputStream(filename);
            out = new ObjectOutputStream(fos);
            out.writeObject(c);
            out.close();
            return true;
        } catch (IOException ex) {
            ex.printStackTrace();
            return false;
        }
    }

Feature:Total is implemented as a returning visitor:

public class Total implements ReturningVisitor<Double> {

    public Double visit(Company o) {
        double total = 0;
        for (Department d : o.getDepts())
            total += d.accept(this);
        return total;
    }

    public Double visit(Department o) {
        double total = 0;
        total += o.getManager().accept(this);
        for (Subunit s : o.getSubunits())
            total += s.accept(this);
        return total;
    }

    public Double visit(Employee o) {
        return o.getSalary();
    }

}

Feature:Cut is implemented as a void visitor:

public class Cut implements VoidVisitor {

    public void visit(Company o) {
        for (Department d : o.getDepts())
            d.accept(this);
    }

    public void visit(Department o) {
        o.getManager().accept(this);
        for (Subunit s : o.getSubunits())
            s.accept(this);
    }

    public void visit(Employee o) {
        o.setSalary(o.getSalary() / 2.0d);
    }

}

Test cases are implemented for all Namespace:Features.

Relationships

For basic OO without inheritance see Contribution:javaComposition.

For basic OO with inheritance see Contribution:javaInheritance.

For modular OO programming with static methods see Contribution:javaStatic.

For use of Java reflection see Contribution:javaReflection (data processing) and Contribution:javaSyb (SYB-style generic programming).

For design patterns see Contribution:javaTemplate (template design pattern), Contribution:javaVisitor (visitor design pattern) and Contribution:javaExorcism (excessive illustration of design patterns).

Architecture

The contribution follows a standardized structure:

inputs contains input files for tests
src/main/java contains the following packages:
- org.softlang.company.features for implementations of Functional requirements.
- org.softlang.company.features.visitor for visitor patterns.
- org.softlang.company.model for implementations of Feature:Company.
src/test/java contains the following packages:
- org.softlang.company.tests for Technology:JUnit test cases for Namespace:Features.