Configuration-level Optimistic Locking with Longevity

Longevity - a persistence framework for Scala and NoSQL - has been built from day one to isolate persistence concerns behind a clear, consistent, and easy to use API. The power of this design principle is demonstrated by how easy it is for you to bring optimistic locking to your application. All you have to do is set a configuration flag.

Longevity is growing to full maturity, and most features you would expect from a persistence framework are in place. Our 0.10.0 release brings many incremental improvements - including support for controlled vocabularies. But the central feature of this release is configuration-level optimistic locking.

Scala Enums: Real Life Example

I wanted to follow up my previous post on Scala Enums with a real-life example. The beauty of this example is my ability to use advanced typing techniques such as type parameters, mixin traits, even a composite pattern, in what basically amounts to a simple enumeration type. This code is quite easy to read, and perfectly conveys my intentions. I don't even want to imagine what I would have done in Java for something like this.

Scala Enums

A post to the scala-users mailing list was asking about how to do enums. While Java enums are relatively lame, they allow me to do simple things such as attach properties to enumerated values, e.g.:

public enum ColumnHeader {
 
  FirstName("First Name", true),
  LastName("Last Name", true),
  Age("Age", false);
 
  private final String headerText;
  private final boolean visibleByDefault;
 
  private ColumnHeader(headerText, visibleByDefault) {
    this.headerText = headerText;
    this.visibleByDefault = visibleByDefault;
  }
 
  public String getHeaderText() {
    return headerText;
  }
 
  public boolean isVisibleByDefault() {
    return visibleByDefault;
  }
}
 
Java provides a static method values() in your enum class that returns an array of your enum values, in the order you defined them. This is nice. Now you can do things like this:
 
public enum ColumnHeader {
  //...
  public static ColumnHeader[] getVisibleByDefaultColumnHeaders() {
    final List<ColumnHeader> visibleColumnHeaders =
      new ArrayList<ColumnHeader>();
    for (ColumnHeader header: values()) {
      if (header.isVisibleByDefault()) {
        visibleColumnHeaders.add(header);
      }
    }
    return visibleColumnHeaders.toArray(
      new ColumnHeader[visibleColumnHeaders.size());
  }
}

People switching from Java to Scala may want to do something like this, and may well find themselves expecting something similar from the scala.Enumeration class. But it's pretty hard to figure out how to extend scala.Enumeration and add properties to the extended class as well. I've tried a couple times, and I haven't figured it out. Instead, I've taken to using case objects to solve the kinds of problems that I solved with enums in Java.