javaSyb

Headline

SYB-style generic programming with reflection in Java

When implementing operations for totaling or cutting salaries in a regular object-oriented fashion (such as in the case of Contribution:javaComposition), it occurs that the implementations are unnecessarily concerned with the detailed object model. In contrast, some XML-based implementations (such as in the case of Contribution:javaDom) are much more concise because they can leverage extra query facilities, in fact, axes, such as the descendants axis of XPath. The SYB style of generic programming also provides such conciseness on the grounds of functional programming idioms. In particular, queries and transformations are supported by customizable traversal schemes. Conceptually, these are higher-order functions that are to be parametrized by essential, problem-specific first-order functions. The present implementation applies SYB to Java. The implementation includes a simple SYB-style library for object traversals. The library relies on reflection, in fact, introspection--as provided by Java's reflection approach.

Illustration

The data model is implemented with object composition. For example Companies:

/**
 * A company has a name and consists of (possibly nested) departments.
 */
public class Company implements Serializable {

    private static final long serialVersionUID = -200889592677165250L;
    
    private String name;
    private List<Department> depts = new LinkedList<Department>();

    public String getName() {
        return name;
    }

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

    public List<Department> getDepts() {
        return depts;
    }

}

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, Feature:Cut and Feature:Depth are implemented using functions. For example Total:

public class Total {

    public static Double total(Company c) {
        return everything(orDefault(getSalary(), 0.0), add, 0.0).apply(c);
    }

    public static Function<Employee,Double> getSalary() {
        return new Function<Employee, Double>() {
            public Double apply(Employee x) {
                return x.getSalary();
            }
        };
    }

    public static BinaryOperator<Double> add =
        new BinaryOperator<Double>() {
            public Double apply(Double x1, Double x2) {
                return x1+x2;
            }
        };
}

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:
- javaf.prelude for function patterns.
- javaf.syb for query patterns.
- org.softlang.company.features for implementations of Functional requirements.
- 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.