andreww1011/jens

Java library for defining and using subsets. Simulate enum with common constants.

jens

Java library for defining and using subsets. Simulate enum with common constants.

Usage

1. Define each element of a set in its own interface annotated with @EnumeratedItem, parameterized with <E extends Enumerable<E>>, and that has a member that returns the type Item<E>.

@EnumeratedItem(description="translation in x")
interface Dx<E extends Enumerable<E>> {
    Item<E> dx();
}

@EnumeratedItem(description="translation in y")
interface Dy<E extends Enumerable<E>> {
    Item<E> dy();
}

@EnumeratedItem(description="translation in z")
interface Dz<E extends Enumerable<E>> {
    Item<E> dz();
}

2. Define a set in its own interface that extends Enumerable and each element of the set.

interface Cartesian3d extends 
        Enumerable<Cartesian3d>,
        Dx<Cartesian3d>,
        Dy<Cartesian3d>,
        Dz<Cartesian3d> { }

interface Cartesian2d extends
        Enumerable<Cartesian2d>,
        Dx<Cartesian2d>,
        Dy<Cartesian2d> { }

3. Access the enumerable using Enumerables.getEnumerable(). A concrete implementation is generated dynamically at runtime.

Cartesian3d c3 = Enumerables.getEnumerable(Cartesian3d.class);
Cartesian2d c2 = Enumerables.getEnumerable(Cartesian2d.class);

4. The elements of the set are ordered by the implementation. Reference each element by name.

//3d position vector (x,y,z) = (1.5,-2.0,1.7)
double[] arr3d = new double[c3.size()];
arr3d[c3.dx().ordinal()] =  1.5;
arr3d[c3.dy().ordinal()] = -2.0;
arr3d[c3.dz().ordinal()] =  1.7;

//2d position vector (x,y) = (-1.0,4.3)
double[] arr2d = new double[c2.size()];
arr2d[c2.dx().ordinal()] = -1.0;
arr2d[c2.dy().ordinal()] =  4.3;

double[] res2d = new double[c2.size()];
addXY(c3,arr3d,c2,arr2d,c2,res2d); //res2d = [0.5,2.3]

<E1 extends Enumerable<E1> & Dx<E1> & Dy<E1>,
 E2 extends Enumerable<E2> & Dx<E2> & Dy<E2>,
 E3 extends Enumerable<E3> & Dx<E3> & Dy<E3>> 
void addXY(E1 e1, double[] a1, E2 e2, double[] a2, E3 e3, double[] a3) {
    a3[e3.dx().ordinal()] = a1[e1.dx().ordinal()] + a2[e2.dx().ordinal()];
    a3[e3.dy().ordinal()] = a1[e1.dy().ordinal()] + a2[e2.dy().ordinal()];
}

Features

• Type-safe comparison across different subsets.
• Internal ordering is managed by runtime. Access elements using meaningful method names, not indicies.