diff --git a/src/main/java/com/avaje/ebean/text/PathProperties.java b/src/main/java/com/avaje/ebean/text/PathProperties.java
index 7ce4bcb25..ad0d96f6a 100644
--- a/src/main/java/com/avaje/ebean/text/PathProperties.java
+++ b/src/main/java/com/avaje/ebean/text/PathProperties.java
@@ -1,251 +1,251 @@
-package com.avaje.ebean.text;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.Map.Entry;
-
-import com.avaje.ebean.Query;
-
-/**
- * This is a Tree like structure of paths and properties that can be used for
- * defining which parts of an object graph to render in JSON or XML, and can
- * also be used to define which parts to select and fetch for an ORM query.
- * <p>
- * It provides a way of parsing a string representation of nested path
- * properties and applying that to both what to fetch (ORM query) and what to
- * render (JAX-RS JSON / XML).
- * </p>
- */
-public class PathProperties {
-
-  private final Map<String, Props> pathMap;
-
-  private final Props rootProps;
-
-  /**
-   * Parse and return a PathProperties from nested string format like
-   * (a,b,c(d,e),f(g)) where "c" is a path containing "d" and "e" and "f" is a
-   * path containing "g" and the root path contains "a","b","c" and "f".
-   */
-  public static PathProperties parse(String source) {
-    return PathPropertiesParser.parse(source);
-  }
-
-  /**
-   * Construct an empty PathProperties.
-   */
-  public PathProperties() {
-    this.rootProps = new Props(this, null, null);
-    this.pathMap = new LinkedHashMap<String, Props>();
-    this.pathMap.put(null, rootProps);
-  }
-
-  /**
-   * Construct for creating copy.
-   */
-  private PathProperties(PathProperties orig) {
-    this.rootProps = orig.rootProps.copy(this);
-    this.pathMap = new LinkedHashMap<String, Props>(orig.pathMap.size());
-    Set<Entry<String, Props>> entrySet = orig.pathMap.entrySet();
-    for (Entry<String, Props> e : entrySet) {
-      pathMap.put(e.getKey(), e.getValue().copy(this));
-    }
-  }
-
-  /**
-   * Create a copy of this instance so that it can be modified.
-   * <p>
-   * For example, you may want to create a copy to add extra properties to a
-   * path so that they are fetching in a ORM query but perhaps not rendered by
-   * default. That is, use a PathProperties for JSON or XML rendering, but
-   * create a copy, add some extra properties and then use that copy to define
-   * an ORM query.
-   * </p>
-   */
-  public PathProperties copy() {
-    return new PathProperties(this);
-  }
-
-  /**
-   * Return true if there are no paths defined.
-   */
-  public boolean isEmpty() {
-    return pathMap.isEmpty();
-  }
-
-  public String toString() {
-    return pathMap.toString();
-  }
-
-  /**
-   * Return true if the path is defined and has properties.
-   */
-  public boolean hasPath(String path) {
-    Props props = pathMap.get(path);
-    return props != null && !props.isEmpty();
-  }
-
-  /**
-   * Get the properties for a given path.
-   */
-  public Set<String> get(String path) {
-    Props props = pathMap.get(path);
-    return props == null ? null : props.getProperties();
-  }
-
-  public void addToPath(String path, String property) {
-    Props props = pathMap.get(path);
-    if (props == null) {
-      props = new Props(this, null, path);
-      pathMap.put(path, props);
-    }
-    props.getProperties().add(property);
-  }
-
-  /**
-   * Set the properties for a given path.
-   */
-  public void put(String path, Set<String> properties) {
-    pathMap.put(path, new Props(this, null, path, properties));
-  }
-
-  /**
-   * Remove a path returning the properties set for that path.
-   */
-  public Set<String> remove(String path) {
-    Props props = pathMap.remove(path);
-    return props == null ? null : props.getProperties();
-  }
-
-  /**
-   * Return a shallow copy of the paths.
-   */
-  public Set<String> getPaths() {
-    return new LinkedHashSet<String>(pathMap.keySet());
-  }
-
-  public Collection<Props> getPathProps() {
-    return pathMap.values();
-  }
-
-  /**
-   * Apply these path properties as fetch paths to the query.
-   */
-  public void apply(Query<?> query) {
-
-    for (Entry<String, Props> entry : pathMap.entrySet()) {
-      String path = entry.getKey();
-      String props = entry.getValue().getPropertiesAsString();
-
-      if (path == null || path.length() == 0) {
-        query.select(props);
-      } else {
-        query.fetch(path, props);
-      }
-    }
-  }
-
-  protected Props getRootProperties() {
-    return rootProps;
-  }
-
-  public static class Props {
-
-    private final PathProperties owner;
-
-    private final String parentPath;
-    private final String path;
-
-    private final Set<String> propSet;
-
-    private Props(PathProperties owner, String parentPath, String path, Set<String> propSet) {
-      this.owner = owner;
-      this.path = path;
-      this.parentPath = parentPath;
-      this.propSet = propSet;
-    }
-
-    private Props(PathProperties owner, String parentPath, String path) {
-      this(owner, parentPath, path, new LinkedHashSet<String>());
-    }
-
-    /**
-     * Create a shallow copy of this Props instance.
-     */
-    public Props copy(PathProperties newOwner) {
-      return new Props(newOwner, parentPath, path, new LinkedHashSet<String>(propSet));
-    }
-
-    public String getPath() {
-      return path;
-    }
-
-    public String toString() {
-      return propSet.toString();
-    }
-
-    public boolean isEmpty() {
-      return propSet.isEmpty();
-    }
-
-    /**
-     * Return the properties for this property set.
-     */
-    public Set<String> getProperties() {
-      return propSet;
-    }
-
-    /**
-     * Return the properties as a comma delimited string.
-     */
-    public String getPropertiesAsString() {
-
-      StringBuilder sb = new StringBuilder();
-
-      Iterator<String> it = propSet.iterator();
-      boolean hasNext = it.hasNext();
-      while (hasNext) {
-        sb.append(it.next());
-        hasNext = it.hasNext();
-        if (hasNext) {
-          sb.append(",");
-        }
-      }
-      return sb.toString();
-    }
-
-    /**
-     * Return the parent path
-     */
-    protected Props getParent() {
-      return owner.pathMap.get(parentPath);
-    }
-
-    /**
-     * Add a child Property set.
-     */
-    protected Props addChild(String subpath) {
-
-      subpath = subpath.trim();
-      addProperty(subpath);
-
-      // build the subpath
-      String p = path == null ? subpath : path + "." + subpath;
-      Props nested = new Props(owner, path, p);
-      owner.pathMap.put(p, nested);
-      return nested;
-    }
-
-    /**
-     * Add a properties to include for this path.
-     */
-    protected void addProperty(String property) {
-      propSet.add(property.trim());
-    }
-  }
-
-}
+package com.avaje.ebean.text;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import com.avaje.ebean.Query;
+
+/**
+ * This is a Tree like structure of paths and properties that can be used for
+ * defining which parts of an object graph to render in JSON or XML, and can
+ * also be used to define which parts to select and fetch for an ORM query.
+ * <p>
+ * It provides a way of parsing a string representation of nested path
+ * properties and applying that to both what to fetch (ORM query) and what to
+ * render (JAX-RS JSON / XML).
+ * </p>
+ */
+public class PathProperties {
+
+  private final Map<String, Props> pathMap;
+
+  private final Props rootProps;
+
+  /**
+   * Parse and return a PathProperties from nested string format like
+   * (a,b,c(d,e),f(g)) where "c" is a path containing "d" and "e" and "f" is a
+   * path containing "g" and the root path contains "a","b","c" and "f".
+   */
+  public static PathProperties parse(String source) {
+    return PathPropertiesParser.parse(source);
+  }
+
+  /**
+   * Construct an empty PathProperties.
+   */
+  public PathProperties() {
+    this.rootProps = new Props(this, null, null);
+    this.pathMap = new LinkedHashMap<String, Props>();
+    this.pathMap.put(null, rootProps);
+  }
+
+  /**
+   * Construct for creating copy.
+   */
+  private PathProperties(PathProperties orig) {
+    this.rootProps = orig.rootProps.copy(this);
+    this.pathMap = new LinkedHashMap<String, Props>(orig.pathMap.size());
+    Set<Entry<String, Props>> entrySet = orig.pathMap.entrySet();
+    for (Entry<String, Props> e : entrySet) {
+      pathMap.put(e.getKey(), e.getValue().copy(this));
+    }
+  }
+
+  /**
+   * Create a copy of this instance so that it can be modified.
+   * <p>
+   * For example, you may want to create a copy to add extra properties to a
+   * path so that they are fetching in a ORM query but perhaps not rendered by
+   * default. That is, use a PathProperties for JSON or XML rendering, but
+   * create a copy, add some extra properties and then use that copy to define
+   * an ORM query.
+   * </p>
+   */
+  public PathProperties copy() {
+    return new PathProperties(this);
+  }
+
+  /**
+   * Return true if there are no paths defined.
+   */
+  public boolean isEmpty() {
+    return pathMap.isEmpty();
+  }
+
+  public String toString() {
+    return pathMap.toString();
+  }
+
+  /**
+   * Return true if the path is defined and has properties.
+   */
+  public boolean hasPath(String path) {
+    Props props = pathMap.get(path);
+    return props != null && !props.isEmpty();
+  }
+
+  /**
+   * Get the properties for a given path.
+   */
+  public Set<String> get(String path) {
+    Props props = pathMap.get(path);
+    return props == null ? null : props.getProperties();
+  }
+
+  public void addToPath(String path, String property) {
+    Props props = pathMap.get(path);
+    if (props == null) {
+      props = new Props(this, null, path);
+      pathMap.put(path, props);
+    }
+    props.getProperties().add(property);
+  }
+
+  /**
+   * Set the properties for a given path.
+   */
+  public void put(String path, Set<String> properties) {
+    pathMap.put(path, new Props(this, null, path, properties));
+  }
+
+  /**
+   * Remove a path returning the properties set for that path.
+   */
+  public Set<String> remove(String path) {
+    Props props = pathMap.remove(path);
+    return props == null ? null : props.getProperties();
+  }
+
+  /**
+   * Return a shallow copy of the paths.
+   */
+  public Set<String> getPaths() {
+    return new LinkedHashSet<String>(pathMap.keySet());
+  }
+
+  public Collection<Props> getPathProps() {
+    return pathMap.values();
+  }
+
+  /**
+   * Apply these path properties as fetch paths to the query.
+   */
+  public void apply(Query<?> query) {
+
+    for (Entry<String, Props> entry : pathMap.entrySet()) {
+      String path = entry.getKey();
+      String props = entry.getValue().getPropertiesAsString();
+
+      if (path == null || path.length() == 0) {
+        query.select(props);
+      } else {
+        query.fetch(path, props);
+      }
+    }
+  }
+
+  protected Props getRootProperties() {
+    return rootProps;
+  }
+
+  public static class Props {
+
+    private final PathProperties owner;
+
+    private final String parentPath;
+    private final String path;
+
+    private final Set<String> propSet;
+
+    private Props(PathProperties owner, String parentPath, String path, Set<String> propSet) {
+      this.owner = owner;
+      this.path = path;
+      this.parentPath = parentPath;
+      this.propSet = propSet;
+    }
+
+    private Props(PathProperties owner, String parentPath, String path) {
+      this(owner, parentPath, path, new LinkedHashSet<String>());
+    }
+
+    /**
+     * Create a shallow copy of this Props instance.
+     */
+    public Props copy(PathProperties newOwner) {
+      return new Props(newOwner, parentPath, path, new LinkedHashSet<String>(propSet));
+    }
+
+    public String getPath() {
+      return path;
+    }
+
+    public String toString() {
+      return propSet.toString();
+    }
+
+    public boolean isEmpty() {
+      return propSet.isEmpty();
+    }
+
+    /**
+     * Return the properties for this property set.
+     */
+    public Set<String> getProperties() {
+      return propSet;
+    }
+
+    /**
+     * Return the properties as a comma delimited string.
+     */
+    public String getPropertiesAsString() {
+
+      StringBuilder sb = new StringBuilder();
+
+      Iterator<String> it = propSet.iterator();
+      boolean hasNext = it.hasNext();
+      while (hasNext) {
+        sb.append(it.next());
+        hasNext = it.hasNext();
+        if (hasNext) {
+          sb.append(",");
+        }
+      }
+      return sb.toString();
+    }
+
+    /**
+     * Return the parent path
+     */
+    protected Props getParent() {
+      return owner.pathMap.get(parentPath);
+    }
+
+    /**
+     * Add a child Property set.
+     */
+    protected Props addChild(String subpath) {
+
+      subpath = subpath.trim();
+      addProperty(subpath);
+
+      // build the subpath
+      String p = path == null ? subpath : path + "." + subpath;
+      Props nested = new Props(owner, path, p);
+      owner.pathMap.put(p, nested);
+      return nested;
+    }
+
+    /**
+     * Add a properties to include for this path.
+     */
+    protected void addProperty(String property) {
+      propSet.add(property.trim());
+    }
+  }
+
+}
diff --git a/src/main/java/com/avaje/ebean/text/PathPropertiesParser.java b/src/main/java/com/avaje/ebean/text/PathPropertiesParser.java
index 926eeaea1..5381f7905 100644
--- a/src/main/java/com/avaje/ebean/text/PathPropertiesParser.java
+++ b/src/main/java/com/avaje/ebean/text/PathPropertiesParser.java
@@ -1,135 +1,135 @@
-package com.avaje.ebean.text;
-
-/**
- * Parses Uri segments like :(id,name,shippingAddress(*),contacts(*)) so that
- * the response can be customised for performance.
- * 
- * @author rbygrave
- */
-class PathPropertiesParser {
-
-  // :(a,b,c(d,e,f))
-
-  private final PathProperties pathProps;
-
-  private final String source;
-
-  private final char[] chars;
-
-  private final int eof;
-
-  private int pos;
-  private int startPos;
-
-  private PathProperties.Props currentPathProps;
-
-  /**
-   * Use {@link PathProperties#parse(String)}.
-   */
-  static PathProperties parse(String source) {
-    return new PathPropertiesParser(source).pathProps;
-  }
-
-  private PathPropertiesParser(String src) {
-
-    if (src.startsWith(":")) {
-      src = src.substring(1);
-    }
-    this.pathProps = new PathProperties();
-    this.source = src;
-    this.chars = src.toCharArray();
-    this.eof = chars.length;
-
-    if (eof > 0) {
-      currentPathProps = pathProps.getRootProperties();
-      parse();
-    }
-  }
-
-  private String getPath() {
-    do {
-      char c1 = chars[pos++];
-      switch (c1) {
-      case '(':
-        return currentWord();
-      default:
-        if (pos == 1) {
-          return "";
-        }
-      }
-    } while (pos < eof);
-    throw new RuntimeException("Hit EOF while reading sectionTitle from " + startPos);
-  }
-
-  private void parse() {
-
-    do {
-      String path = getPath();
-      pushPath(path);
-      parseSection();
-
-    } while (pos < eof);
-  }
-
-  private void parseSection() {
-    do {
-      char c1 = chars[pos++];
-      switch (c1) {
-      case '(':
-        addSubpath();
-        break;
-      case ',':
-        addCurrentProperty();
-        break;
-      case ':':
-        // start new section
-        startPos = pos;
-        return;
-      case ')':
-        // end of section
-        addCurrentProperty();
-        popSubpath();
-        break;
-      default:
-      }
-
-    } while (pos < eof);
-    if (startPos < pos) {
-      String currentWord = source.substring(startPos, pos);
-      currentPathProps.addProperty(currentWord);
-    }
-  }
-
-  private void addSubpath() {
-    pushPath(currentWord());
-  }
-
-  private void addCurrentProperty() {
-    String w = currentWord();
-    if (w.length() > 0) {
-      currentPathProps.addProperty(w);
-    }
-  }
-
-  private String currentWord() {
-    if (startPos == pos) {
-      return "";
-    }
-    String currentWord = source.substring(startPos, pos - 1);
-    startPos = pos;
-    return currentWord;
-  }
-
-  private void pushPath(String title) {
-
-    if (!"".equals(title)) {
-      currentPathProps = currentPathProps.addChild(title);
-    }
-  }
-
-  private void popSubpath() {
-
-    currentPathProps = currentPathProps.getParent();
-  }
-
-}
+package com.avaje.ebean.text;
+
+/**
+ * Parses Uri segments like :(id,name,shippingAddress(*),contacts(*)) so that
+ * the response can be customised for performance.
+ * 
+ * @author rbygrave
+ */
+class PathPropertiesParser {
+
+  // :(a,b,c(d,e,f))
+
+  private final PathProperties pathProps;
+
+  private final String source;
+
+  private final char[] chars;
+
+  private final int eof;
+
+  private int pos;
+  private int startPos;
+
+  private PathProperties.Props currentPathProps;
+
+  /**
+   * Use {@link PathProperties#parse(String)}.
+   */
+  static PathProperties parse(String source) {
+    return new PathPropertiesParser(source).pathProps;
+  }
+
+  private PathPropertiesParser(String src) {
+
+    if (src.startsWith(":")) {
+      src = src.substring(1);
+    }
+    this.pathProps = new PathProperties();
+    this.source = src;
+    this.chars = src.toCharArray();
+    this.eof = chars.length;
+
+    if (eof > 0) {
+      currentPathProps = pathProps.getRootProperties();
+      parse();
+    }
+  }
+
+  private String getPath() {
+    do {
+      char c1 = chars[pos++];
+      switch (c1) {
+      case '(':
+        return currentWord();
+      default:
+        if (pos == 1) {
+          return "";
+        }
+      }
+    } while (pos < eof);
+    throw new RuntimeException("Hit EOF while reading sectionTitle from " + startPos);
+  }
+
+  private void parse() {
+
+    do {
+      String path = getPath();
+      pushPath(path);
+      parseSection();
+
+    } while (pos < eof);
+  }
+
+  private void parseSection() {
+    do {
+      char c1 = chars[pos++];
+      switch (c1) {
+      case '(':
+        addSubpath();
+        break;
+      case ',':
+        addCurrentProperty();
+        break;
+      case ':':
+        // start new section
+        startPos = pos;
+        return;
+      case ')':
+        // end of section
+        addCurrentProperty();
+        popSubpath();
+        break;
+      default:
+      }
+
+    } while (pos < eof);
+    if (startPos < pos) {
+      String currentWord = source.substring(startPos, pos);
+      currentPathProps.addProperty(currentWord);
+    }
+  }
+
+  private void addSubpath() {
+    pushPath(currentWord());
+  }
+
+  private void addCurrentProperty() {
+    String w = currentWord();
+    if (w.length() > 0) {
+      currentPathProps.addProperty(w);
+    }
+  }
+
+  private String currentWord() {
+    if (startPos == pos) {
+      return "";
+    }
+    String currentWord = source.substring(startPos, pos - 1);
+    startPos = pos;
+    return currentWord;
+  }
+
+  private void pushPath(String title) {
+
+    if (!"".equals(title)) {
+      currentPathProps = currentPathProps.addChild(title);
+    }
+  }
+
+  private void popSubpath() {
+
+    currentPathProps = currentPathProps.getParent();
+  }
+
+}
diff --git a/src/main/java/com/avaje/ebean/text/StringFormatter.java b/src/main/java/com/avaje/ebean/text/StringFormatter.java
index 34aee914f..1fd677cb4 100644
--- a/src/main/java/com/avaje/ebean/text/StringFormatter.java
+++ b/src/main/java/com/avaje/ebean/text/StringFormatter.java
@@ -1,17 +1,17 @@
-package com.avaje.ebean.text;
-
-/**
- * Convert an Object value into a String value.
- * <p>
- * Basic interface to support CSV, JSON and XML processing.
- * </p>
- * 
- * @author rbygrave
- */
-public interface StringFormatter {
-
-  /**
-   * Convert an Object value into a String value.
-   */
-  String format(Object value);
-}
+package com.avaje.ebean.text;
+
+/**
+ * Convert an Object value into a String value.
+ * <p>
+ * Basic interface to support CSV, JSON and XML processing.
+ * </p>
+ * 
+ * @author rbygrave
+ */
+public interface StringFormatter {
+
+  /**
+   * Convert an Object value into a String value.
+   */
+  String format(Object value);
+}
diff --git a/src/main/java/com/avaje/ebean/text/StringParser.java b/src/main/java/com/avaje/ebean/text/StringParser.java
index d790736b8..c03371310 100644
--- a/src/main/java/com/avaje/ebean/text/StringParser.java
+++ b/src/main/java/com/avaje/ebean/text/StringParser.java
@@ -1,17 +1,17 @@
-package com.avaje.ebean.text;
-
-/**
- * Convert a String value into an Object value.
- * <p>
- * Basic interface to support CSV, JSON and XML processing.
- * </p>
- * 
- * @author rbygrave
- */
-public interface StringParser {
-
-  /**
-   * Convert a String value into an Object value.
-   */
-  Object parse(String value);
-}
+package com.avaje.ebean.text;
+
+/**
+ * Convert a String value into an Object value.
+ * <p>
+ * Basic interface to support CSV, JSON and XML processing.
+ * </p>
+ * 
+ * @author rbygrave
+ */
+public interface StringParser {
+
+  /**
+   * Convert a String value into an Object value.
+   */
+  Object parse(String value);
+}
diff --git a/src/main/java/com/avaje/ebean/text/TextException.java b/src/main/java/com/avaje/ebean/text/TextException.java
index 68a65649e..ac41a3c07 100644
--- a/src/main/java/com/avaje/ebean/text/TextException.java
+++ b/src/main/java/com/avaje/ebean/text/TextException.java
@@ -1,32 +1,32 @@
-package com.avaje.ebean.text;
-
-/**
- * An exception occurred typically in processing CSV, JSON or XML.
- * 
- * @author rbygrave
- */
-public class TextException extends RuntimeException {
-
-  private static final long serialVersionUID = 1601310159486033148L;
-
-  /**
-   * Construct with an error message.
-   */
-  public TextException(String msg) {
-    super(msg);
-  }
-
-  /**
-   * Construct with a message and cause.
-   */
-  public TextException(String msg, Exception e) {
-    super(msg, e);
-  }
-
-  /**
-   * Construct with a cause.
-   */
-  public TextException(Exception e) {
-    super(e);
-  }
-}
+package com.avaje.ebean.text;
+
+/**
+ * An exception occurred typically in processing CSV, JSON or XML.
+ * 
+ * @author rbygrave
+ */
+public class TextException extends RuntimeException {
+
+  private static final long serialVersionUID = 1601310159486033148L;
+
+  /**
+   * Construct with an error message.
+   */
+  public TextException(String msg) {
+    super(msg);
+  }
+
+  /**
+   * Construct with a message and cause.
+   */
+  public TextException(String msg, Exception e) {
+    super(msg, e);
+  }
+
+  /**
+   * Construct with a cause.
+   */
+  public TextException(Exception e) {
+    super(e);
+  }
+}
diff --git a/src/main/java/com/avaje/ebean/text/TimeStringParser.java b/src/main/java/com/avaje/ebean/text/TimeStringParser.java
index cb212ccaa..349b99575 100644
--- a/src/main/java/com/avaje/ebean/text/TimeStringParser.java
+++ b/src/main/java/com/avaje/ebean/text/TimeStringParser.java
@@ -1,56 +1,56 @@
-package com.avaje.ebean.text;
-
-import java.sql.Time;
-
-/**
- * Parser for TIME types that supports both HH:mm:ss and HH:mm.
- * 
- * @author rbygrave
- */
-public final class TimeStringParser implements StringParser {
-
-  private static final TimeStringParser SHARED = new TimeStringParser();
-
-  /**
-   * Return a shared instance as this is thread safe.
-   */
-  public static TimeStringParser get() {
-    return SHARED;
-  }
-
-  /**
-   * Parse the String supporting both HH:mm:ss and HH:mm formats.
-   */
-  @SuppressWarnings("deprecation")
-  public Object parse(String value) {
-    if (value == null || value.trim().length() == 0) {
-      return null;
-    }
-
-    String s = value.trim();
-    int minute;
-    int second;
-    int firstColon = s.indexOf(':');
-    int secondColon = s.indexOf(':', firstColon + 1);
-
-    if (firstColon == -1) {
-      throw new java.lang.IllegalArgumentException("No ':' in value [" + s + "]");
-    }
-    try {
-      int hour = Integer.parseInt(s.substring(0, firstColon));
-      if (secondColon == -1) {
-        minute = Integer.parseInt(s.substring(firstColon + 1, s.length()));
-        second = 0;
-      } else {
-        minute = Integer.parseInt(s.substring(firstColon + 1, secondColon));
-        second = Integer.parseInt(s.substring(secondColon + 1));
-      }
-
-      return new Time(hour, minute, second);
-
-    } catch (NumberFormatException e) {
-      throw new java.lang.IllegalArgumentException("Number format Error parsing time [" + s + "] "
-          + e.getMessage(), e);
-    }
-  }
+package com.avaje.ebean.text;
+
+import java.sql.Time;
+
+/**
+ * Parser for TIME types that supports both HH:mm:ss and HH:mm.
+ * 
+ * @author rbygrave
+ */
+public final class TimeStringParser implements StringParser {
+
+  private static final TimeStringParser SHARED = new TimeStringParser();
+
+  /**
+   * Return a shared instance as this is thread safe.
+   */
+  public static TimeStringParser get() {
+    return SHARED;
+  }
+
+  /**
+   * Parse the String supporting both HH:mm:ss and HH:mm formats.
+   */
+  @SuppressWarnings("deprecation")
+  public Object parse(String value) {
+    if (value == null || value.trim().length() == 0) {
+      return null;
+    }
+
+    String s = value.trim();
+    int minute;
+    int second;
+    int firstColon = s.indexOf(':');
+    int secondColon = s.indexOf(':', firstColon + 1);
+
+    if (firstColon == -1) {
+      throw new java.lang.IllegalArgumentException("No ':' in value [" + s + "]");
+    }
+    try {
+      int hour = Integer.parseInt(s.substring(0, firstColon));
+      if (secondColon == -1) {
+        minute = Integer.parseInt(s.substring(firstColon + 1, s.length()));
+        second = 0;
+      } else {
+        minute = Integer.parseInt(s.substring(firstColon + 1, secondColon));
+        second = Integer.parseInt(s.substring(secondColon + 1));
+      }
+
+      return new Time(hour, minute, second);
+
+    } catch (NumberFormatException e) {
+      throw new java.lang.IllegalArgumentException("Number format Error parsing time [" + s + "] "
+          + e.getMessage(), e);
+    }
+  }
 }
\ No newline at end of file
diff --git a/src/main/java/com/avaje/ebean/text/csv/CsvCallback.java b/src/main/java/com/avaje/ebean/text/csv/CsvCallback.java
index 09608fe40..b550be252 100644
--- a/src/main/java/com/avaje/ebean/text/csv/CsvCallback.java
+++ b/src/main/java/com/avaje/ebean/text/csv/CsvCallback.java
@@ -1,89 +1,89 @@
-package com.avaje.ebean.text.csv;
-
-import com.avaje.ebean.EbeanServer;
-
-/**
- * Provides callback methods for customisation of CSV processing.
- * <p>
- * You can provide your own CsvCallback implementation to customise the CSV
- * processing. It is expected that the DefaultCsvCallback provides a good base
- * class that you can extend.
- * </p>
- * 
- * @author rbygrave
- * 
- * @param <T>
- */
-public interface CsvCallback<T> {
-
-  /**
-   * The processing is about to begin.
-   * <p>
-   * Typically the callback will create a transaction, set batch mode, batch
-   * size etc.
-   * </p>
-   */
-  void begin(EbeanServer server);
-
-  /**
-   * Read the header row.
-   * <p>
-   * This is only called if {@link CsvReader#setHasHeader(boolean,boolean)} has
-   * been set to true.
-   * </p>
-   * 
-   * @param line
-   *          the header line content.
-   */
-  void readHeader(String[] line);
-
-  /**
-   * Check that the row should be processed - return true to process the row or
-   * false to ignore the row. Gives ability to handle bad data... empty rows etc
-   * and ignore it rather than fail.
-   */
-  boolean processLine(int row, String[] line);
-
-  /**
-   * Called for each bean after it has been loaded from the CSV content.
-   * <p>
-   * This allows you to process the bean however you like.
-   * </p>
-   * <p>
-   * When you use a CsvCallback the CsvReader *WILL NOT* create a transaction
-   * and will not save the bean for you. You have complete control and must do
-   * these things yourself (if that is want you want).
-   * </p>
-   * 
-   * @param row
-   *          the index of the content being processed
-   * @param line
-   *          the content that has been used to load the bean
-   * @param bean
-   *          the entity bean after it has been loaded from the csv content
-   */
-  void processBean(int row, String[] line, T bean);
-
-  /**
-   * The processing has ended successfully.
-   * <p>
-   * Typically the callback will commit the transaction.
-   * </p>
-   */
-  void end(int row);
-
-  /**
-   * The processing has ended due to an error.
-   * <p>
-   * This gives the callback the opportunity to rollback the transaction if one
-   * was created.
-   * </p>
-   * 
-   * @param row
-   *          the row that the error has occured on
-   * @param e
-   *          the error that occured
-   */
-  void endWithError(int row, Exception e);
-
-}
+package com.avaje.ebean.text.csv;
+
+import com.avaje.ebean.EbeanServer;
+
+/**
+ * Provides callback methods for customisation of CSV processing.
+ * <p>
+ * You can provide your own CsvCallback implementation to customise the CSV
+ * processing. It is expected that the DefaultCsvCallback provides a good base
+ * class that you can extend.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ * @param <T>
+ */
+public interface CsvCallback<T> {
+
+  /**
+   * The processing is about to begin.
+   * <p>
+   * Typically the callback will create a transaction, set batch mode, batch
+   * size etc.
+   * </p>
+   */
+  void begin(EbeanServer server);
+
+  /**
+   * Read the header row.
+   * <p>
+   * This is only called if {@link CsvReader#setHasHeader(boolean,boolean)} has
+   * been set to true.
+   * </p>
+   * 
+   * @param line
+   *          the header line content.
+   */
+  void readHeader(String[] line);
+
+  /**
+   * Check that the row should be processed - return true to process the row or
+   * false to ignore the row. Gives ability to handle bad data... empty rows etc
+   * and ignore it rather than fail.
+   */
+  boolean processLine(int row, String[] line);
+
+  /**
+   * Called for each bean after it has been loaded from the CSV content.
+   * <p>
+   * This allows you to process the bean however you like.
+   * </p>
+   * <p>
+   * When you use a CsvCallback the CsvReader *WILL NOT* create a transaction
+   * and will not save the bean for you. You have complete control and must do
+   * these things yourself (if that is want you want).
+   * </p>
+   * 
+   * @param row
+   *          the index of the content being processed
+   * @param line
+   *          the content that has been used to load the bean
+   * @param bean
+   *          the entity bean after it has been loaded from the csv content
+   */
+  void processBean(int row, String[] line, T bean);
+
+  /**
+   * The processing has ended successfully.
+   * <p>
+   * Typically the callback will commit the transaction.
+   * </p>
+   */
+  void end(int row);
+
+  /**
+   * The processing has ended due to an error.
+   * <p>
+   * This gives the callback the opportunity to rollback the transaction if one
+   * was created.
+   * </p>
+   * 
+   * @param row
+   *          the row that the error has occured on
+   * @param e
+   *          the error that occured
+   */
+  void endWithError(int row, Exception e);
+
+}
diff --git a/src/main/java/com/avaje/ebean/text/csv/CsvReader.java b/src/main/java/com/avaje/ebean/text/csv/CsvReader.java
index c8b45011e..76ce0f2ef 100644
--- a/src/main/java/com/avaje/ebean/text/csv/CsvReader.java
+++ b/src/main/java/com/avaje/ebean/text/csv/CsvReader.java
@@ -1,173 +1,173 @@
-package com.avaje.ebean.text.csv;
-
-import java.io.Reader;
-import java.util.Locale;
-
-import com.avaje.ebean.text.StringParser;
-
-/**
- * Reads CSV data turning it into object graphs that you can be saved (inserted)
- * or processed yourself.
- * 
- * <p>
- * This first example doesn't use a {@link CsvCallback} and this means it will
- * automatically create a transaction, save the customers and commit the
- * transaction when successful.
- * </p>
- * 
- * <pre class="code">
- * try {
- *   File f = new File(&quot;src/test/resources/test1.csv&quot;);
- * 
- *   FileReader reader = new FileReader(f);
- * 
- *   CsvReader&lt;Customer&gt; csvReader = Ebean.createCsvReader(Customer.class);
- * 
- *   csvReader.setPersistBatchSize(20);
- * 
- *   csvReader.addProperty(&quot;status&quot;);
- *   // ignore the next property
- *   csvReader.addIgnore();
- *   csvReader.addProperty(&quot;name&quot;);
- *   csvReader.addDateTime(&quot;anniversary&quot;, &quot;dd-MMM-yyyy&quot;);
- *   csvReader.addProperty(&quot;billingAddress.line1&quot;);
- *   csvReader.addProperty(&quot;billingAddress.city&quot;);
- * 
- *   csvReader.process(reader);
- * 
- * } catch (Exception e) {
- *   throw new RuntimeException(e);
- * }
- * </pre>
- * 
- * @param <T>
- *          the entity bean type
- */
-public interface CsvReader<T> {
-
-  /**
-   * Explicitly set the default Locale.
-   */
-  void setDefaultLocale(Locale defaultLocale);
-
-  /**
-   * Set the default format to use for Time types.
-   */
-  void setDefaultTimeFormat(String defaultTimeFormat);
-
-  /**
-   * Set the default format to use for Date types.
-   */
-  void setDefaultDateFormat(String defaultDateFormat);
-
-  /**
-   * Set the default format to use for Timestamp types.
-   */
-  void setDefaultTimestampFormat(String defaultTimestampFormat);
-
-  /**
-   * Set the batch size for using JDBC statement batching.
-   * <p>
-   * By default this is set to 20 and setting this to 1 will disable the use of
-   * JDBC statement batching.
-   * </p>
-   */
-  void setPersistBatchSize(int persistBatchSize);
-
-  /**
-   * Set to true if there is a header row that should be ignored.
-   * <p>
-   * If addPropertiesFromHeader is true then all the properties are added using
-   * the default time,date and timestamp formats.
-   * <p>
-   * If you have a mix of dateTime formats you can not use this method and must
-   * add the properties yourself.
-   * </p>
-   */
-  void setHasHeader(boolean hasHeader, boolean addPropertiesFromHeader);
-
-  /**
-   * Same as setHasHeader(true,true);
-   * <p>
-   * This will use a header to define all the properties to load using the
-   * default formats for time, date and datetime types.
-   * </p>
-   */
-  void setAddPropertiesFromHeader();
-
-  /**
-   * Same as setHasHeader(true, false);
-   * <p>
-   * This indicates that there is a header but that it should be ignored.
-   * </p>
-   */
-  void setIgnoreHeader();
-
-  /**
-   * Set the frequency with which a INFO message will be logged showing the
-   * progress of the processing. You might set this to 1000 or 10000 etc.
-   * <p>
-   * If this is not set then no INFO messages will be logged.
-   * </p>
-   */
-  void setLogInfoFrequency(int logInfoFrequency);
-
-  /**
-   * Ignore the next column of data.
-   */
-  void addIgnore();
-
-  /**
-   * Define the property which will be loaded from the next column of data.
-   * <p>
-   * This takes into account the data type of the property and handles the
-   * String to object conversion automatically.
-   * </p>
-   */
-  void addProperty(String propertyName);
-
-  /**
-   * Define the next property and use a custom StringParser to convert the
-   * string content into the appropriate type for the property.
-   */
-  void addProperty(String propertyName, StringParser parser);
-
-  /**
-   * Add a property with a custom Date/Time/Timestamp format using the default
-   * Locale. This will convert the string into the appropriate java type for the
-   * given property (Date, Calendar, SQL Date, Time, Timestamp, JODA etc).
-   */
-  void addDateTime(String propertyName, String dateTimeFormat);
-
-  /**
-   * Add a property with a custom Date/Time/Timestamp format. This will convert
-   * the string into the appropriate java type for the given property (Date,
-   * Calendar, SQL Date, Time, Timestamp, JODA etc).
-   */
-  void addDateTime(String propertyName, String dateTimeFormat, Locale locale);
-
-  /**
-   * Automatically create a transaction if required to process all the CSV
-   * content from the reader.
-   * <p>
-   * This will check for a current transaction. If there is no current
-   * transaction then one is started and will commit (or rollback) at the end of
-   * processing. This will also set the persistBatchSize on the transaction.
-   * </p>
-   */
-  void process(Reader reader) throws Exception;
-
-  /**
-   * Process the CSV content passing the bean to the CsvCallback after each row.
-   * <p>
-   * This provides you with the ability to modify and process the bean.
-   * </p>
-   * <p>
-   * When using a CsvCallback the reader WILL NOT create a transaction or save
-   * the bean(s) for you. If you want to insert the processed beans you must
-   * create your own transaction and save the bean(s) yourself.
-   * </p>
-   */
-  void process(Reader reader, CsvCallback<T> callback) throws Exception;
-
+package com.avaje.ebean.text.csv;
+
+import java.io.Reader;
+import java.util.Locale;
+
+import com.avaje.ebean.text.StringParser;
+
+/**
+ * Reads CSV data turning it into object graphs that you can be saved (inserted)
+ * or processed yourself.
+ * 
+ * <p>
+ * This first example doesn't use a {@link CsvCallback} and this means it will
+ * automatically create a transaction, save the customers and commit the
+ * transaction when successful.
+ * </p>
+ * 
+ * <pre class="code">
+ * try {
+ *   File f = new File(&quot;src/test/resources/test1.csv&quot;);
+ * 
+ *   FileReader reader = new FileReader(f);
+ * 
+ *   CsvReader&lt;Customer&gt; csvReader = Ebean.createCsvReader(Customer.class);
+ * 
+ *   csvReader.setPersistBatchSize(20);
+ * 
+ *   csvReader.addProperty(&quot;status&quot;);
+ *   // ignore the next property
+ *   csvReader.addIgnore();
+ *   csvReader.addProperty(&quot;name&quot;);
+ *   csvReader.addDateTime(&quot;anniversary&quot;, &quot;dd-MMM-yyyy&quot;);
+ *   csvReader.addProperty(&quot;billingAddress.line1&quot;);
+ *   csvReader.addProperty(&quot;billingAddress.city&quot;);
+ * 
+ *   csvReader.process(reader);
+ * 
+ * } catch (Exception e) {
+ *   throw new RuntimeException(e);
+ * }
+ * </pre>
+ * 
+ * @param <T>
+ *          the entity bean type
+ */
+public interface CsvReader<T> {
+
+  /**
+   * Explicitly set the default Locale.
+   */
+  void setDefaultLocale(Locale defaultLocale);
+
+  /**
+   * Set the default format to use for Time types.
+   */
+  void setDefaultTimeFormat(String defaultTimeFormat);
+
+  /**
+   * Set the default format to use for Date types.
+   */
+  void setDefaultDateFormat(String defaultDateFormat);
+
+  /**
+   * Set the default format to use for Timestamp types.
+   */
+  void setDefaultTimestampFormat(String defaultTimestampFormat);
+
+  /**
+   * Set the batch size for using JDBC statement batching.
+   * <p>
+   * By default this is set to 20 and setting this to 1 will disable the use of
+   * JDBC statement batching.
+   * </p>
+   */
+  void setPersistBatchSize(int persistBatchSize);
+
+  /**
+   * Set to true if there is a header row that should be ignored.
+   * <p>
+   * If addPropertiesFromHeader is true then all the properties are added using
+   * the default time,date and timestamp formats.
+   * <p>
+   * If you have a mix of dateTime formats you can not use this method and must
+   * add the properties yourself.
+   * </p>
+   */
+  void setHasHeader(boolean hasHeader, boolean addPropertiesFromHeader);
+
+  /**
+   * Same as setHasHeader(true,true);
+   * <p>
+   * This will use a header to define all the properties to load using the
+   * default formats for time, date and datetime types.
+   * </p>
+   */
+  void setAddPropertiesFromHeader();
+
+  /**
+   * Same as setHasHeader(true, false);
+   * <p>
+   * This indicates that there is a header but that it should be ignored.
+   * </p>
+   */
+  void setIgnoreHeader();
+
+  /**
+   * Set the frequency with which a INFO message will be logged showing the
+   * progress of the processing. You might set this to 1000 or 10000 etc.
+   * <p>
+   * If this is not set then no INFO messages will be logged.
+   * </p>
+   */
+  void setLogInfoFrequency(int logInfoFrequency);
+
+  /**
+   * Ignore the next column of data.
+   */
+  void addIgnore();
+
+  /**
+   * Define the property which will be loaded from the next column of data.
+   * <p>
+   * This takes into account the data type of the property and handles the
+   * String to object conversion automatically.
+   * </p>
+   */
+  void addProperty(String propertyName);
+
+  /**
+   * Define the next property and use a custom StringParser to convert the
+   * string content into the appropriate type for the property.
+   */
+  void addProperty(String propertyName, StringParser parser);
+
+  /**
+   * Add a property with a custom Date/Time/Timestamp format using the default
+   * Locale. This will convert the string into the appropriate java type for the
+   * given property (Date, Calendar, SQL Date, Time, Timestamp, JODA etc).
+   */
+  void addDateTime(String propertyName, String dateTimeFormat);
+
+  /**
+   * Add a property with a custom Date/Time/Timestamp format. This will convert
+   * the string into the appropriate java type for the given property (Date,
+   * Calendar, SQL Date, Time, Timestamp, JODA etc).
+   */
+  void addDateTime(String propertyName, String dateTimeFormat, Locale locale);
+
+  /**
+   * Automatically create a transaction if required to process all the CSV
+   * content from the reader.
+   * <p>
+   * This will check for a current transaction. If there is no current
+   * transaction then one is started and will commit (or rollback) at the end of
+   * processing. This will also set the persistBatchSize on the transaction.
+   * </p>
+   */
+  void process(Reader reader) throws Exception;
+
+  /**
+   * Process the CSV content passing the bean to the CsvCallback after each row.
+   * <p>
+   * This provides you with the ability to modify and process the bean.
+   * </p>
+   * <p>
+   * When using a CsvCallback the reader WILL NOT create a transaction or save
+   * the bean(s) for you. If you want to insert the processed beans you must
+   * create your own transaction and save the bean(s) yourself.
+   * </p>
+   */
+  void process(Reader reader, CsvCallback<T> callback) throws Exception;
+
 }
\ No newline at end of file
diff --git a/src/main/java/com/avaje/ebean/text/csv/DefaultCsvCallback.java b/src/main/java/com/avaje/ebean/text/csv/DefaultCsvCallback.java
index e0c7c10d0..20c13bc6c 100644
--- a/src/main/java/com/avaje/ebean/text/csv/DefaultCsvCallback.java
+++ b/src/main/java/com/avaje/ebean/text/csv/DefaultCsvCallback.java
@@ -1,204 +1,204 @@
-package com.avaje.ebean.text.csv;
-
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.Transaction;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Provides the default implementation of CsvCallback.
- * <p>
- * This handles transaction creation (if no current transaction existed) and
- * transaction commit or rollback on error.
- * </p>
- * <p>
- * For customising the processing you can extend this object and override the
- * appropriate methods.
- * </p>
- * 
- * @author rob
- * 
- * @param <T>
- */
-public class DefaultCsvCallback<T> implements CsvCallback<T> {
-
-  private static final Logger logger = LoggerFactory.getLogger(DefaultCsvCallback.class);
-
-  /**
-   * The transaction to use (if not using CsvCallback).
-   */
-  protected Transaction transaction;
-
-  /**
-   * Flag set when we created the transaction.
-   */
-  protected boolean createdTransaction;
-
-  /**
-   * The EbeanServer used to save the beans.
-   */
-  protected EbeanServer server;
-
-  /**
-   * Used to log a message to indicate progress through large files.
-   */
-  protected int logInfoFrequency;
-
-  /**
-   * The batch size used when saving the beans.
-   */
-  protected int persistBatchSize;
-
-  /**
-   * The time the process started.
-   */
-  protected long startTime;
-
-  /**
-   * The execution time of the process.
-   */
-  protected long exeTime;
-
-  /**
-   * Construct with a default batch size of 30 and logging info messages every
-   * 1000 rows.
-   */
-  public DefaultCsvCallback() {
-    this(30, 1000);
-  }
-
-  /**
-   * Construct with explicit batch size and logging info frequency.
-   */
-  public DefaultCsvCallback(int persistBatchSize, int logInfoFrequency) {
-
-    this.persistBatchSize = persistBatchSize;
-    this.logInfoFrequency = logInfoFrequency;
-  }
-
-  /**
-   * Create a transaction if required.
-   */
-  public void begin(EbeanServer server) {
-    this.server = server;
-    this.startTime = System.currentTimeMillis();
-
-    initTransactionIfRequired();
-  }
-
-  /**
-   * Override to read the heading line.
-   * <p>
-   * This is only called if {@link CsvReader#setHasHeader(boolean,boolean)} is
-   * set to true.
-   * </p>
-   * <p>
-   * By default this does nothing (effectively ignoring the heading).
-   * </p>
-   */
-  public void readHeader(String[] line) {
-
-  }
-
-  /**
-   * Validate that the content is valid and return false if the row should be
-   * ignored.
-   * <p>
-   * By default this just returns true.
-   * </p>
-   * <p>
-   * Override this to add custom validation logic returning false if you want
-   * the row to be ignored. For example, if all the content is empty return
-   * false to ignore the row (rather than having the processing fail with some
-   * error).
-   * </p>
-   */
-  public boolean processLine(int row, String[] line) {
-    return true;
-  }
-
-  /**
-   * Will save the bean.
-   * <p>
-   * Override this method to customise the bean (set additional properties etc)
-   * or to control the saving of other related beans (when you can't/don't want
-   * to use Cascade.PERSIST etc).
-   * </p>
-   */
-  public void processBean(int row, String[] line, T bean) {
-
-    // assumes single bean or Cascade.PERSIST will save any
-    // related beans (e.g. customer -> customer.billingAddress
-    server.save(bean, transaction);
-
-    if (logInfoFrequency > 0 && (row % logInfoFrequency == 0)) {
-      logger.info("processed " + row + " rows");
-    }
-  }
-
-  /**
-   * Commit the transaction if one was created.
-   */
-  public void end(int row) {
-
-    commitTransactionIfCreated();
-
-    exeTime = System.currentTimeMillis() - startTime;
-    logger.info("Csv finished, rows[" + row + "] exeMillis[" + exeTime + "]");
-  }
-
-  /**
-   * Rollback the transaction if one was created.
-   */
-  public void endWithError(int row, Exception e) {
-    rollbackTransactionIfCreated(e);
-  }
-
-  /**
-   * Create a transaction if one is not already active and set its batch mode
-   * and batch size.
-   */
-  protected void initTransactionIfRequired() {
-
-    transaction = server.currentTransaction();
-    if (transaction == null || !transaction.isActive()) {
-
-      transaction = server.beginTransaction();
-      createdTransaction = true;
-      if (persistBatchSize > 1) {
-        logger.info("Creating transaction, batchSize[" + persistBatchSize + "]");
-        transaction.setBatchMode(true);
-        transaction.setBatchSize(persistBatchSize);
-
-      } else {
-        // explicitly turn off JDBC batching in case
-        // is has been turned on globally
-        transaction.setBatchMode(false);
-        logger.info("Creating transaction with no JDBC batching");
-      }
-    }
-  }
-
-  /**
-   * If we created a transaction commit it. We have successfully processed all
-   * the rows.
-   */
-  protected void commitTransactionIfCreated() {
-    if (createdTransaction) {
-      transaction.commit();
-      logger.info("Committed transaction");
-    }
-  }
-
-  /**
-   * Rollback the transaction if we where not successful in processing all the
-   * rows.
-   */
-  protected void rollbackTransactionIfCreated(Throwable e) {
-    if (createdTransaction) {
-      transaction.rollback(e);
-      logger.info("Rolled back transaction");
-    }
-  }
-
-}
+package com.avaje.ebean.text.csv;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.Transaction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Provides the default implementation of CsvCallback.
+ * <p>
+ * This handles transaction creation (if no current transaction existed) and
+ * transaction commit or rollback on error.
+ * </p>
+ * <p>
+ * For customising the processing you can extend this object and override the
+ * appropriate methods.
+ * </p>
+ * 
+ * @author rob
+ * 
+ * @param <T>
+ */
+public class DefaultCsvCallback<T> implements CsvCallback<T> {
+
+  private static final Logger logger = LoggerFactory.getLogger(DefaultCsvCallback.class);
+
+  /**
+   * The transaction to use (if not using CsvCallback).
+   */
+  protected Transaction transaction;
+
+  /**
+   * Flag set when we created the transaction.
+   */
+  protected boolean createdTransaction;
+
+  /**
+   * The EbeanServer used to save the beans.
+   */
+  protected EbeanServer server;
+
+  /**
+   * Used to log a message to indicate progress through large files.
+   */
+  protected int logInfoFrequency;
+
+  /**
+   * The batch size used when saving the beans.
+   */
+  protected int persistBatchSize;
+
+  /**
+   * The time the process started.
+   */
+  protected long startTime;
+
+  /**
+   * The execution time of the process.
+   */
+  protected long exeTime;
+
+  /**
+   * Construct with a default batch size of 30 and logging info messages every
+   * 1000 rows.
+   */
+  public DefaultCsvCallback() {
+    this(30, 1000);
+  }
+
+  /**
+   * Construct with explicit batch size and logging info frequency.
+   */
+  public DefaultCsvCallback(int persistBatchSize, int logInfoFrequency) {
+
+    this.persistBatchSize = persistBatchSize;
+    this.logInfoFrequency = logInfoFrequency;
+  }
+
+  /**
+   * Create a transaction if required.
+   */
+  public void begin(EbeanServer server) {
+    this.server = server;
+    this.startTime = System.currentTimeMillis();
+
+    initTransactionIfRequired();
+  }
+
+  /**
+   * Override to read the heading line.
+   * <p>
+   * This is only called if {@link CsvReader#setHasHeader(boolean,boolean)} is
+   * set to true.
+   * </p>
+   * <p>
+   * By default this does nothing (effectively ignoring the heading).
+   * </p>
+   */
+  public void readHeader(String[] line) {
+
+  }
+
+  /**
+   * Validate that the content is valid and return false if the row should be
+   * ignored.
+   * <p>
+   * By default this just returns true.
+   * </p>
+   * <p>
+   * Override this to add custom validation logic returning false if you want
+   * the row to be ignored. For example, if all the content is empty return
+   * false to ignore the row (rather than having the processing fail with some
+   * error).
+   * </p>
+   */
+  public boolean processLine(int row, String[] line) {
+    return true;
+  }
+
+  /**
+   * Will save the bean.
+   * <p>
+   * Override this method to customise the bean (set additional properties etc)
+   * or to control the saving of other related beans (when you can't/don't want
+   * to use Cascade.PERSIST etc).
+   * </p>
+   */
+  public void processBean(int row, String[] line, T bean) {
+
+    // assumes single bean or Cascade.PERSIST will save any
+    // related beans (e.g. customer -> customer.billingAddress
+    server.save(bean, transaction);
+
+    if (logInfoFrequency > 0 && (row % logInfoFrequency == 0)) {
+      logger.info("processed " + row + " rows");
+    }
+  }
+
+  /**
+   * Commit the transaction if one was created.
+   */
+  public void end(int row) {
+
+    commitTransactionIfCreated();
+
+    exeTime = System.currentTimeMillis() - startTime;
+    logger.info("Csv finished, rows[" + row + "] exeMillis[" + exeTime + "]");
+  }
+
+  /**
+   * Rollback the transaction if one was created.
+   */
+  public void endWithError(int row, Exception e) {
+    rollbackTransactionIfCreated(e);
+  }
+
+  /**
+   * Create a transaction if one is not already active and set its batch mode
+   * and batch size.
+   */
+  protected void initTransactionIfRequired() {
+
+    transaction = server.currentTransaction();
+    if (transaction == null || !transaction.isActive()) {
+
+      transaction = server.beginTransaction();
+      createdTransaction = true;
+      if (persistBatchSize > 1) {
+        logger.info("Creating transaction, batchSize[" + persistBatchSize + "]");
+        transaction.setBatchMode(true);
+        transaction.setBatchSize(persistBatchSize);
+
+      } else {
+        // explicitly turn off JDBC batching in case
+        // is has been turned on globally
+        transaction.setBatchMode(false);
+        logger.info("Creating transaction with no JDBC batching");
+      }
+    }
+  }
+
+  /**
+   * If we created a transaction commit it. We have successfully processed all
+   * the rows.
+   */
+  protected void commitTransactionIfCreated() {
+    if (createdTransaction) {
+      transaction.commit();
+      logger.info("Committed transaction");
+    }
+  }
+
+  /**
+   * Rollback the transaction if we where not successful in processing all the
+   * rows.
+   */
+  protected void rollbackTransactionIfCreated(Throwable e) {
+    if (createdTransaction) {
+      transaction.rollback(e);
+      logger.info("Rolled back transaction");
+    }
+  }
+
+}
diff --git a/src/main/java/com/avaje/ebean/text/json/JsonContext.java b/src/main/java/com/avaje/ebean/text/json/JsonContext.java
index 8c32a2234..5d42d8949 100644
--- a/src/main/java/com/avaje/ebean/text/json/JsonContext.java
+++ b/src/main/java/com/avaje/ebean/text/json/JsonContext.java
@@ -1,166 +1,166 @@
-package com.avaje.ebean.text.json;
-
-import com.avaje.ebean.text.PathProperties;
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParser;
-
-import java.io.Reader;
-import java.io.Writer;
-import java.lang.reflect.Type;
-import java.util.List;
-
-/**
- * Converts objects to and from JSON format.
- */
-public interface JsonContext {
-
-  /**
-   * Convert json string input into a Bean of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> T toBean(Class<T> rootType, String json) throws JsonIOException;
-
-  /**
-   * Convert json reader input into a Bean of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> T toBean(Class<T> rootType, Reader json) throws JsonIOException;
-
-  /**
-   * Convert json parser input into a Bean of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> T toBean(Class<T> cls, JsonParser parser) throws JsonIOException;
-
-  /**
-   * Convert json string input into a list of beans of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> List<T> toList(Class<T> rootType, String json) throws JsonIOException;
-
-  /**
-   * Convert json reader input into a list of beans of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> List<T> toList(Class<T> rootType, Reader json) throws JsonIOException;
-
-  /**
-   * Convert json parser input into a list of beans of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  <T> List<T> toList(Class<T> cls, JsonParser src) throws JsonIOException;
-
-  /**
-   * Use the genericType to determine if this should be converted into a List or
-   * bean.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  Object toObject(Type genericType, Reader json) throws JsonIOException;
-
-  /**
-   * Use the genericType to determine if this should be converted into a List or
-   * bean.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  Object toObject(Type genericType, String json) throws JsonIOException;
-
-  /**
-   * Use the genericType to determine if this should be converted into a List or
-   * bean.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  Object toObject(Type genericType, JsonParser jsonParser) throws JsonIOException;
-
-  /**
-   * Return the bean or collection as JSON string.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  String toJson(Object value) throws JsonIOException;
-
-  /**
-   * Write the bean or collection in JSON format to the writer.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  void toJson(Object value, Writer writer) throws JsonIOException;
-
-  /**
-   * Write the bean or collection to the JsonGenerator.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  void toJson(Object value, JsonGenerator generator) throws JsonIOException;
-
-  /**
-   * Return the bean or collection as JSON string using PathProperties.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  String toJson(Object value, PathProperties pathProperties) throws JsonIOException;
-
-  /**
-   * Write the bean or collection as json to the writer using the PathProperties.
-   */
-  void toJson(Object value, Writer writer, PathProperties pathProperties) throws JsonIOException;
-
-  /**
-   * Write the bean or collection to the JsonGenerator using the PathProperties.
-   */
-  void toJson(Object value, JsonGenerator generator, PathProperties pathProperties) throws JsonIOException;
-
-  /**
-   * Deprecated in favour of using PathProperties by itself.
-   * Write json to the JsonGenerator using the JsonWriteOptions.
-   *
-   * @deprecated
-   */
-  void toJson(Object value, JsonGenerator generator, JsonWriteOptions options) throws JsonIOException;
-
-  /**
-   * Deprecated in favour of using PathProperties by itself.
-   * With additional options.
-   *
-   * @throws JsonIOException When IOException occurs
-   * @deprecated
-   */
-  void toJson(Object value, Writer writer, JsonWriteOptions options) throws JsonIOException;
-
-  /**
-   * Deprecated in favour of using PathProperties by itself.
-   * Convert a bean or collection to json string.
-   *
-   * @throws JsonIOException When IOException occurs
-   * @deprecated
-   */
-  String toJson(Object value, JsonWriteOptions options) throws JsonIOException;
-
-  /**
-   * Return true if the type is known as an Entity bean or a List Set or
-   * Map of entity beans.
-   */
-  boolean isSupportedType(Type genericType);
-
-  /**
-   * Create and return a new JsonGenerator for the given writer.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  JsonGenerator createGenerator(Writer writer) throws JsonIOException;
-
-  /**
-   * Create and return a new JsonParser for the given reader.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  JsonParser createParser(Reader reader) throws JsonIOException;
+package com.avaje.ebean.text.json;
+
+import com.avaje.ebean.text.PathProperties;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.Type;
+import java.util.List;
+
+/**
+ * Converts objects to and from JSON format.
+ */
+public interface JsonContext {
+
+  /**
+   * Convert json string input into a Bean of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> T toBean(Class<T> rootType, String json) throws JsonIOException;
+
+  /**
+   * Convert json reader input into a Bean of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> T toBean(Class<T> rootType, Reader json) throws JsonIOException;
+
+  /**
+   * Convert json parser input into a Bean of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> T toBean(Class<T> cls, JsonParser parser) throws JsonIOException;
+
+  /**
+   * Convert json string input into a list of beans of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> List<T> toList(Class<T> rootType, String json) throws JsonIOException;
+
+  /**
+   * Convert json reader input into a list of beans of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> List<T> toList(Class<T> rootType, Reader json) throws JsonIOException;
+
+  /**
+   * Convert json parser input into a list of beans of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  <T> List<T> toList(Class<T> cls, JsonParser src) throws JsonIOException;
+
+  /**
+   * Use the genericType to determine if this should be converted into a List or
+   * bean.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  Object toObject(Type genericType, Reader json) throws JsonIOException;
+
+  /**
+   * Use the genericType to determine if this should be converted into a List or
+   * bean.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  Object toObject(Type genericType, String json) throws JsonIOException;
+
+  /**
+   * Use the genericType to determine if this should be converted into a List or
+   * bean.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  Object toObject(Type genericType, JsonParser jsonParser) throws JsonIOException;
+
+  /**
+   * Return the bean or collection as JSON string.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  String toJson(Object value) throws JsonIOException;
+
+  /**
+   * Write the bean or collection in JSON format to the writer.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  void toJson(Object value, Writer writer) throws JsonIOException;
+
+  /**
+   * Write the bean or collection to the JsonGenerator.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  void toJson(Object value, JsonGenerator generator) throws JsonIOException;
+
+  /**
+   * Return the bean or collection as JSON string using PathProperties.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  String toJson(Object value, PathProperties pathProperties) throws JsonIOException;
+
+  /**
+   * Write the bean or collection as json to the writer using the PathProperties.
+   */
+  void toJson(Object value, Writer writer, PathProperties pathProperties) throws JsonIOException;
+
+  /**
+   * Write the bean or collection to the JsonGenerator using the PathProperties.
+   */
+  void toJson(Object value, JsonGenerator generator, PathProperties pathProperties) throws JsonIOException;
+
+  /**
+   * Deprecated in favour of using PathProperties by itself.
+   * Write json to the JsonGenerator using the JsonWriteOptions.
+   *
+   * @deprecated
+   */
+  void toJson(Object value, JsonGenerator generator, JsonWriteOptions options) throws JsonIOException;
+
+  /**
+   * Deprecated in favour of using PathProperties by itself.
+   * With additional options.
+   *
+   * @throws JsonIOException When IOException occurs
+   * @deprecated
+   */
+  void toJson(Object value, Writer writer, JsonWriteOptions options) throws JsonIOException;
+
+  /**
+   * Deprecated in favour of using PathProperties by itself.
+   * Convert a bean or collection to json string.
+   *
+   * @throws JsonIOException When IOException occurs
+   * @deprecated
+   */
+  String toJson(Object value, JsonWriteOptions options) throws JsonIOException;
+
+  /**
+   * Return true if the type is known as an Entity bean or a List Set or
+   * Map of entity beans.
+   */
+  boolean isSupportedType(Type genericType);
+
+  /**
+   * Create and return a new JsonGenerator for the given writer.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  JsonGenerator createGenerator(Writer writer) throws JsonIOException;
+
+  /**
+   * Create and return a new JsonParser for the given reader.
+   *
+   * @throws JsonIOException When IOException occurs
+   */
+  JsonParser createParser(Reader reader) throws JsonIOException;
 }
\ No newline at end of file
diff --git a/src/main/java/com/avaje/ebean/text/json/JsonWriteOptions.java b/src/main/java/com/avaje/ebean/text/json/JsonWriteOptions.java
index 0e1c7fb1d..3929ba9d4 100644
--- a/src/main/java/com/avaje/ebean/text/json/JsonWriteOptions.java
+++ b/src/main/java/com/avaje/ebean/text/json/JsonWriteOptions.java
@@ -1,54 +1,54 @@
-package com.avaje.ebean.text.json;
-
-import com.avaje.ebean.text.PathProperties;
-
-/**
- * Deprecated in favour of just using PathProperties.
- *
- * Provides options for customising the JSON write process.
- * <p>
- * You can explicitly state which properties to include in the JSON output for
- * the root level and each path.
- * </p>
- * @deprecated
- */
-public class JsonWriteOptions {
-
-  protected PathProperties pathProperties;
-
-  /**
-   * Parse and return a PathProperties from nested string format like
-   * (a,b,c(d,e),f(g)) where "c" is a path containing "d" and "e" and "f" is a
-   * path containing "g" and the root path contains "a","b","c" and "f".
-   *
-   * @see com.avaje.ebean.text.PathProperties#parse(String)
-   */
-  public static JsonWriteOptions parsePath(String pathProperties) {
-
-    return pathProperties(PathProperties.parse(pathProperties));
-  }
-
-  /**
-   * Construct JsonWriteOptions with the given pathProperties.
-   */
-  public static JsonWriteOptions pathProperties(PathProperties pathProperties) {
-    JsonWriteOptions o = new JsonWriteOptions();
-    o.setPathProperties(pathProperties);
-    return o;
-  }
-
-  /**
-   * Set the Map of properties to include by path.
-   */
-  public void setPathProperties(PathProperties pathProperties) {
-    this.pathProperties = pathProperties;
-  }
-
-  /**
-   * Return the properties to include by path.
-   */
-  public PathProperties getPathProperties() {
-    return pathProperties;
-  }
-
-}
+package com.avaje.ebean.text.json;
+
+import com.avaje.ebean.text.PathProperties;
+
+/**
+ * Deprecated in favour of just using PathProperties.
+ *
+ * Provides options for customising the JSON write process.
+ * <p>
+ * You can explicitly state which properties to include in the JSON output for
+ * the root level and each path.
+ * </p>
+ * @deprecated
+ */
+public class JsonWriteOptions {
+
+  protected PathProperties pathProperties;
+
+  /**
+   * Parse and return a PathProperties from nested string format like
+   * (a,b,c(d,e),f(g)) where "c" is a path containing "d" and "e" and "f" is a
+   * path containing "g" and the root path contains "a","b","c" and "f".
+   *
+   * @see com.avaje.ebean.text.PathProperties#parse(String)
+   */
+  public static JsonWriteOptions parsePath(String pathProperties) {
+
+    return pathProperties(PathProperties.parse(pathProperties));
+  }
+
+  /**
+   * Construct JsonWriteOptions with the given pathProperties.
+   */
+  public static JsonWriteOptions pathProperties(PathProperties pathProperties) {
+    JsonWriteOptions o = new JsonWriteOptions();
+    o.setPathProperties(pathProperties);
+    return o;
+  }
+
+  /**
+   * Set the Map of properties to include by path.
+   */
+  public void setPathProperties(PathProperties pathProperties) {
+    this.pathProperties = pathProperties;
+  }
+
+  /**
+   * Return the properties to include by path.
+   */
+  public PathProperties getPathProperties() {
+    return pathProperties;
+  }
+
+}
diff --git a/src/main/java/com/avaje/ebean/util/ClassUtil.java b/src/main/java/com/avaje/ebean/util/ClassUtil.java
index 60ce5e08f..13e361e1b 100644
--- a/src/main/java/com/avaje/ebean/util/ClassUtil.java
+++ b/src/main/java/com/avaje/ebean/util/ClassUtil.java
@@ -1,61 +1,61 @@
-package com.avaje.ebean.util;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-
-/**
- * Helper to find classes taking into account the context class loader.
- */
-public class ClassUtil {
-
-  /**
-   * Return a new instance of the class using the default constructor.
-   */
-  public static Object newInstance(String className) {
-    try {
-      Class<?> cls = Class.forName(className);
-      return cls.newInstance();
-    } catch (Exception e) {
-      String msg = "Error constructing " + className;
-      throw new IllegalArgumentException(msg, e);
-    }
-  }
-
-
-  /**
-   * Returns the raw type for the 2nd generic parameter for a subclass.
-   */
-  public static Class<?> getSecondArgumentType(Class<?> subclass) {
-    Type[] typeArguments = getSuperclassTypeParameter(subclass);
-    if (typeArguments.length != 2) {
-      throw new IllegalArgumentException("Expected type with 2 generic argument types but got "
-              + typeArguments.length + " - " + Arrays.toString(typeArguments));
-    }
-
-    return getRawType(typeArguments[1]);
-  }
-
-  static Type[] getSuperclassTypeParameter(Class<?> subclass) {
-    Type superclass = subclass.getGenericSuperclass();
-    if (superclass instanceof Class) {
-      throw new RuntimeException("Missing generics type parameters on subclass " + subclass);
-    }
-    return ((ParameterizedType) superclass).getActualTypeArguments();
-  }
-
-  private static Class<?> getRawType(Type type) {
-
-    if (type instanceof Class<?>) {
-      return (Class<?>) type;
-
-    } else if (type instanceof ParameterizedType) {
-      ParameterizedType parameterizedType = (ParameterizedType) type;
-      Type rawType = parameterizedType.getRawType();
-      if (rawType instanceof Class<?>) {
-        return (Class<?>) rawType;
-      }
-    }
-    throw new RuntimeException("Unable to obtain raw class type from " + type);
-  }
-}
+package com.avaje.ebean.util;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+
+/**
+ * Helper to find classes taking into account the context class loader.
+ */
+public class ClassUtil {
+
+  /**
+   * Return a new instance of the class using the default constructor.
+   */
+  public static Object newInstance(String className) {
+    try {
+      Class<?> cls = Class.forName(className);
+      return cls.newInstance();
+    } catch (Exception e) {
+      String msg = "Error constructing " + className;
+      throw new IllegalArgumentException(msg, e);
+    }
+  }
+
+
+  /**
+   * Returns the raw type for the 2nd generic parameter for a subclass.
+   */
+  public static Class<?> getSecondArgumentType(Class<?> subclass) {
+    Type[] typeArguments = getSuperclassTypeParameter(subclass);
+    if (typeArguments.length != 2) {
+      throw new IllegalArgumentException("Expected type with 2 generic argument types but got "
+              + typeArguments.length + " - " + Arrays.toString(typeArguments));
+    }
+
+    return getRawType(typeArguments[1]);
+  }
+
+  static Type[] getSuperclassTypeParameter(Class<?> subclass) {
+    Type superclass = subclass.getGenericSuperclass();
+    if (superclass instanceof Class) {
+      throw new RuntimeException("Missing generics type parameters on subclass " + subclass);
+    }
+    return ((ParameterizedType) superclass).getActualTypeArguments();
+  }
+
+  private static Class<?> getRawType(Type type) {
+
+    if (type instanceof Class<?>) {
+      return (Class<?>) type;
+
+    } else if (type instanceof ParameterizedType) {
+      ParameterizedType parameterizedType = (ParameterizedType) type;
+      Type rawType = parameterizedType.getRawType();
+      if (rawType instanceof Class<?>) {
+        return (Class<?>) rawType;
+      }
+    }
+    throw new RuntimeException("Unable to obtain raw class type from " + type);
+  }
+}
diff --git a/src/main/java/com/avaje/ebean/util/StringHelper.java b/src/main/java/com/avaje/ebean/util/StringHelper.java
index e7cdf1b97..c8c4e7276 100644
--- a/src/main/java/com/avaje/ebean/util/StringHelper.java
+++ b/src/main/java/com/avaje/ebean/util/StringHelper.java
@@ -1,600 +1,600 @@
-package com.avaje.ebean.util;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Utility String class that supports String manipulation functions.
- */
-public class StringHelper {
-
-  private static final char SINGLE_QUOTE = '\'';
-
-  private static final char DOUBLE_QUOTE = '"';
-
-  /**
-   * parses a String of the form name1='value1' name2='value2'. Note that you
-   * can use either single or double quotes for any particular name value pair
-   * and the end quote must match the begin quote.
-   */
-  public static HashMap<String, String> parseNameQuotedValue(String tag) throws RuntimeException {
-
-    if (tag == null || tag.length() < 1) {
-      return null;
-    }
-
-    // make sure that the quotes are matched...
-    // int remainer = countOccurances(tag, ""+quote) % 2;
-    // if (remainer == 1) {
-    // dp("remainder = "+remainer);
-    // throw new StringParsingException("Unmatched quote in "+tag);
-    // }
-
-    // make sure that th last character is not an equals...
-    // (check now so I don't need to check this every time..)
-    if (tag.charAt(tag.length() - 1) == '=') {
-      throw new RuntimeException("missing quoted value at the end of " + tag);
-    }
-
-    HashMap<String, String> map = new HashMap<String, String>();
-    // recursively parse out the name value pairs...
-    return parseNameQuotedValue(map, tag, 0);
-  }
-
-  /**
-   * recursively parse out name value pairs (where the value is quoted, with
-   * either single or double quotes).
-   */
-  private static HashMap<String, String> parseNameQuotedValue(HashMap<String, String> map,
-      String tag, int pos) throws RuntimeException {
-
-    int equalsPos = tag.indexOf("=", pos);
-    if (equalsPos > -1) {
-      // check for begin quote...
-      char firstQuote = tag.charAt(equalsPos + 1);
-      if (firstQuote != SINGLE_QUOTE && firstQuote != DOUBLE_QUOTE) {
-        throw new RuntimeException("missing begin quote at " + (equalsPos) + "["
-            + tag.charAt(equalsPos + 1) + "] in [" + tag + "]");
-      }
-
-      // check for end quote...
-      int endQuotePos = tag.indexOf(firstQuote, equalsPos + 2);
-      if (endQuotePos == -1) {
-        throw new RuntimeException("missing end quote [" + firstQuote + "] after " + pos
-            + " in [" + tag + "]");
-      }
-
-      // we have a valid name and value...
-      // dp("pos="+pos+" equalsPos="+equalsPos+"
-      // endQuotePos="+endQuotePos);
-      String name = tag.substring(pos, equalsPos);
-      String value = tag.substring(equalsPos + 2, endQuotePos);
-      // dp("name="+name+"; value="+value+";");
-
-      // trim off any whitespace from the front of name...
-      name = trimFront(name, " ");
-      if ((name.indexOf(SINGLE_QUOTE) > -1) || (name.indexOf(DOUBLE_QUOTE) > -1)) {
-        throw new RuntimeException("attribute name contains a quote [" + name + "]");
-      }
-      map.put(name, value);
-
-      return parseNameQuotedValue(map, tag, endQuotePos + 1);
-
-    } else {
-      // no more equals... stop parsing...
-      return map;
-    }
-  }
-
-  /**
-   * Returns the number of times a particular String occurs in another String.
-   * e.g. count the number of single quotes.
-   */
-  public static int countOccurances(String content, String occurs) {
-    return countOccurances(content, occurs, 0, 0);
-  }
-
-  private static int countOccurances(String content, String occurs, int pos, int countSoFar) {
-    int equalsPos = content.indexOf(occurs, pos);
-    if (equalsPos > -1) {
-      countSoFar = countSoFar + 1;
-      pos = equalsPos + occurs.length();
-      // dp("countSoFar="+countSoFar+" pos="+pos);
-      return countOccurances(content, occurs, pos, countSoFar);
-    } else {
-      return countSoFar;
-    }
-  }
-
-  /**
-   * Parses out a list of Name Value pairs that are delimited together. Will
-   * always return a StringMap. If allNameValuePairs is null, or no name values
-   * can be parsed out an empty StringMap is returned.
-   * 
-   * @param allNameValuePairs
-   *          the entire string to be parsed.
-   * @param listDelimiter
-   *          (typically ';') the delimited between the list
-   * @param nameValueSeparator
-   *          (typically '=') the separator between the name and value
-   */
-  public static Map<String, String> delimitedToMap(String allNameValuePairs,
-      String listDelimiter, String nameValueSeparator) {
-
-    HashMap<String, String> params = new HashMap<String, String>();
-    if ((allNameValuePairs == null) || (allNameValuePairs.length() == 0)) {
-      return params;
-    }
-    // trim off any leading listDelimiter...
-    allNameValuePairs = trimFront(allNameValuePairs, listDelimiter);
-    return getKeyValue(params, 0, allNameValuePairs, listDelimiter, nameValueSeparator);
-  }
-
-  /**
-   * Trims off recurring strings from the front of a string.
-   * 
-   * @param source
-   *          the source string
-   * @param trim
-   *          the string to trim off the front
-   */
-  public static String trimFront(String source, String trim) {
-    if (source == null) {
-      return null;
-    }
-    if (source.indexOf(trim) == 0) {
-      // dp("trim ...");
-      return trimFront(source.substring(trim.length()), trim);
-    } else {
-      return source;
-    }
-  }
-
-  /**
-   * Return true if the value is null or an empty string.
-   */
-  public static boolean isNull(String value) {
-    if (value == null || value.trim().length() == 0) {
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Recursively pulls out the key value pairs from a raw string.
-   */
-  private static HashMap<String, String> getKeyValue(HashMap<String, String> map, int pos,
-      String allNameValuePairs, String listDelimiter, String nameValueSeparator) {
-
-    if (pos >= allNameValuePairs.length()) {
-      // dp("end as "+pos+" >= "+allNameValuePairs.length() );
-      return map;
-    }
-
-    int equalsPos = allNameValuePairs.indexOf(nameValueSeparator, pos);
-    int delimPos = allNameValuePairs.indexOf(listDelimiter, pos);
-
-    if (delimPos == -1) {
-      delimPos = allNameValuePairs.length();
-    }
-    if (equalsPos == -1) {
-      // dp("no more equals...");
-      return map;
-    }
-    if (delimPos == (equalsPos + 1)) {
-      // dp("Ignoring as nothing between delim and equals...
-      // delim:"+delimPos+" eq:"+equalsPos);
-      return getKeyValue(map, delimPos + 1, allNameValuePairs, listDelimiter,
-          nameValueSeparator);
-    }
-    if (equalsPos > delimPos) {
-      // there is a key without a value?
-      String key = allNameValuePairs.substring(pos, delimPos);
-      key = key.trim();
-      if (key.length() > 0) {
-        map.put(key, null);
-      }
-      return getKeyValue(map, delimPos + 1, allNameValuePairs, listDelimiter,
-          nameValueSeparator);
-
-    }
-    String key = allNameValuePairs.substring(pos, equalsPos);
-
-    if (delimPos > -1) {
-      String value = allNameValuePairs.substring(equalsPos + 1, delimPos);
-      // dp("cont "+key+","+value+" pos:"+pos+"
-      // len:"+allNameValuePairs.length());
-      key = key.trim();
-
-      map.put(key, value);
-      pos = delimPos + 1;
-
-      // recurse the rest of the values...
-      return getKeyValue(map, pos, allNameValuePairs, listDelimiter, nameValueSeparator);
-    } else {
-      // dp("ERROR: delimPos < 0 ???");
-      return map;
-    }
-  }
-
-  /**
-   * Convert a string that has delimited values (say comma delimited) in a
-   * String[]. You must explicitly choose whether or not to include empty values
-   * (say two commas that a right beside each other.
-   * 
-   * <P>
-   * e.g. "alpha,beta,,theta"<br>
-   * With keepEmpties true, this results in a String[] of size 4 with the third
-   * one having a String of 0 length. With keepEmpties false, this results in a
-   * String[] of size 3.
-   * </P>
-   * <P>
-   * </P>
-   * <P>
-   * e.g. ",alpha,beta,,theta,"<br>
-   * With keepEmpties true, this results in a String[] of size 6 with the
-   * 1st,4th and 6th one having a String of 0 length. With keepEmpties false,
-   * this results in a String[] of size 3.
-   * </P>
-   */
-  public static String[] delimitedToArray(String str, String delimiter, boolean keepEmpties) {
-
-    ArrayList<String> list = new ArrayList<String>();
-    int startPos = 0;
-    delimiter(str, delimiter, keepEmpties, startPos, list);
-    String[] result = new String[list.size()];
-    return (String[]) list.toArray(result);
-  }
-
-  private static void delimiter(String str, String delimiter, boolean keepEmpties, int startPos,
-      ArrayList<String> list) {
-
-    int endPos = str.indexOf(delimiter, startPos);
-    if (endPos == -1) {
-      if (startPos <= str.length()) {
-        String lastValue = str.substring(startPos, str.length());
-        // dp("lastValue="+lastValue);
-        if (!keepEmpties && lastValue.length() == 0) {
-          // dp("not keeping...");
-        } else {
-          list.add(lastValue);
-        }
-      }
-      // we have finished parsing the string...
-      return;
-    } else {
-      // get the delimited value... add it..
-      String value = str.substring(startPos, endPos);
-      // dp(startPos+","+endPos+" value="+value);
-      if (!keepEmpties && value.length() == 0) {
-        // dp("not keeping...");
-      } else {
-        list.add(value);
-      }
-      // recursively search as we are not at the end yet...
-      delimiter(str, delimiter, keepEmpties, endPos + 1, list);
-    }
-  }
-
-  /**
-   * This returns the FIRST string in str that is bounded on the left by
-   * leftBound, and bounded on the right by rightBound. This will return null if
-   * the leftBound is not found within str.
-   * 
-   * <P>
-   * If leftBound can't be found this returns null.
-   * </P>
-   * <P>
-   * This rightBound can't be found then this throws a
-   * StringIndexOutOfBoundsException.
-   * </P>
-   * 
-   * @param str
-   *          the base string that we will search for the bounded string.
-   * @param leftBound
-   *          the left bound of the string.
-   * @param rightBound
-   *          the right bound of the string.
-   */
-  public static String getBoundedString(String str, String leftBound, String rightBound)
-      throws RuntimeException {
-
-    if (str == null) {
-      throw new RuntimeException("string to parse is null?");
-    }
-    int startPos = str.indexOf(leftBound);
-    if (startPos > -1) {
-      startPos = startPos + leftBound.length();
-      int endPos = str.indexOf(rightBound, startPos);
-      // dp(str+" start:"+startPos+" end:"+endPos);
-      if (endPos == -1) {
-        throw new RuntimeException("Can't find rightBound: " + rightBound);
-      }
-      return str.substring(startPos, endPos);
-    } else {
-      // if no leftBound can be found.. return null... could be in a
-      // search n parse type loop?
-      // this keeps "no tag"==null different from "tag not formed
-      // properly"==StringParsingException
-      return null;
-    }
-  }
-
-  /**
-   * Takes the String bounded by leftBound & rightBound, and replaces it with
-   * replaceString. Actually removes the left and right bound strings aswell.
-   */
-  public static String setBoundedString(String str, String leftBound, String rightBound,
-      String replaceString) {
-
-    int startPos = str.indexOf(leftBound);
-    if (startPos > -1) {
-      // startPos = startPos;
-      int endPos = str.indexOf(rightBound, startPos + leftBound.length());
-      if (endPos > -1) {
-        String toReplace = str.substring(startPos, endPos + 1);
-        return replaceString(str, toReplace, replaceString);
-      } else {
-        return str;
-      }
-    } else {
-      return str;
-    }
-  }
-
-  // public static String replaceString(String str, String oldSub, String
-  // newSub) {
-  //
-  // if (str == null) {
-  // return null;
-  // }
-  // StringBuilder newSB = new StringBuilder(str.length()+20);
-  // int iPos = 0;
-  // int iPrevPos = 0;
-  //
-  // while (true) {
-  // iPos = str.indexOf(oldSub, iPrevPos);
-  // if (iPos > -1) {
-  // // found
-  // newSB.append(str.substring(iPrevPos, iPos));
-  // newSB.append(newSub);
-  // iPrevPos = iPos + oldSub.length();
-  // } else {
-  // // not found
-  // newSB.append(str.substring(iPrevPos));
-  // break;
-  // }
-  // }
-  //
-  // return newSB.toString();
-  // }
-
-  /**
-   * This method takes a String and will replace all occurrences of the match
-   * String with that of the replace String.
-   * 
-   * @param source
-   *          the source string
-   * @param match
-   *          the string used to find a match
-   * @param replace
-   *          the string used to replace match with
-   * @return the source string after the search and replace
-   */
-  public static String replaceString(String source, String match, String replace) {
-    if (source == null) {
-      return null;
-    }
-    if (replace == null) {
-      return source;
-    }
-    if (match == null) {
-      throw new NullPointerException("match is null?");
-    }
-    if (match.equals(replace)) {
-      return source;
-    }
-    return replaceString(source, match, replace, 30, 0, source.length());
-  }
-
-  /**
-   * Additionally specify the additionalSize to add to the buffer. This will
-   * make the buffer bigger so that it doesn't have to grow when replacement
-   * occurs.
-   */
-  public static String replaceString(String source, String match, String replace,
-      int additionalSize, int startPos, int endPos) {
-
-    if (source == null) {
-      return source;
-    }
-
-    char match0 = match.charAt(0);
-
-    int matchLength = match.length();
-
-    if (matchLength == 1 && replace.length() == 1) {
-      char replace0 = replace.charAt(0);
-      return source.replace(match0, replace0);
-    }
-    if (matchLength >= replace.length()) {
-      additionalSize = 0;
-    }
-
-    int sourceLength = source.length();
-    int lastMatch = endPos - matchLength;
-
-    StringBuilder sb = new StringBuilder(sourceLength + additionalSize);
-
-    if (startPos > 0) {
-      sb.append(source.substring(0, startPos));
-    }
-
-    char sourceChar;
-    boolean isMatch;
-    int sourceMatchPos;
-
-    for (int i = startPos; i < sourceLength; i++) {
-      sourceChar = source.charAt(i);
-      if (i > lastMatch || sourceChar != match0) {
-        sb.append(sourceChar);
-
-      } else {
-        // check to see if this is a match
-        isMatch = true;
-        sourceMatchPos = i;
-
-        // check each following character...
-        for (int j = 1; j < matchLength; j++) {
-          sourceMatchPos++;
-          if (source.charAt(sourceMatchPos) != match.charAt(j)) {
-            isMatch = false;
-            break;
-          }
-        }
-        if (isMatch) {
-          i = i + matchLength - 1;
-          sb.append(replace);
-        } else {
-          // was not a match
-          sb.append(sourceChar);
-        }
-      }
-    }
-
-    return sb.toString();
-  }
-
-  /**
-   * A search and replace with multiple matching strings.
-   * <p>
-   * Useful when converting CRNL CR and NL all to a BR tag for example.
-   * </p>
-   * 
-   * <pre>
-   * <code>
-   * String[] multi = { &quot;\r\n&quot;, &quot;\r&quot;, &quot;\n&quot; };
-   * content = StringHelper.replaceStringMulti(content, multi, &quot;&lt;br/&gt;&quot;);
-   * </code>
-   * </pre>
-   */
-  public static String replaceStringMulti(String source, String[] match, String replace) {
-    return replaceStringMulti(source, match, replace, 30, 0, source.length());
-  }
-
-  /**
-   * Additionally specify an additional size estimate for the buffer plus start
-   * and end positions.
-   * <p>
-   * The start and end positions can limit the search and replace. Otherwise
-   * these default to startPos = 0 and endPos = source.length().
-   * </p>
-   */
-  public static String replaceStringMulti(String source, String[] match, String replace,
-      int additionalSize, int startPos, int endPos) {
-
-    int shortestMatch = match[0].length();
-
-    char[] match0 = new char[match.length];
-    for (int i = 0; i < match0.length; i++) {
-      match0[i] = match[i].charAt(0);
-      if (match[i].length() < shortestMatch) {
-        shortestMatch = match[i].length();
-      }
-    }
-
-    StringBuilder sb = new StringBuilder(source.length() + additionalSize);
-
-    char sourceChar;
-
-    int len = source.length();
-    int lastMatch = endPos - shortestMatch;
-
-    if (startPos > 0) {
-      sb.append(source.substring(0, startPos));
-    }
-
-    int matchCount = 0;
-
-    for (int i = startPos; i < len; i++) {
-      sourceChar = source.charAt(i);
-      if (i > lastMatch) {
-        sb.append(sourceChar);
-      } else {
-        matchCount = 0;
-        for (int k = 0; k < match0.length; k++) {
-          if (matchCount == 0 && sourceChar == match0[k]) {
-            if (match[k].length() + i <= len) {
-
-              ++matchCount;
-              int j = 1;
-              for (; j < match[k].length(); j++) {
-                if (source.charAt(i + j) != match[k].charAt(j)) {
-                  --matchCount;
-                  break;
-                }
-              }
-              if (matchCount > 0) {
-                i = i + j - 1;
-                sb.append(replace);
-                break;
-              }
-            }
-          }
-        }
-        if (matchCount == 0) {
-          sb.append(sourceChar);
-        }
-      }
-    }
-
-    return sb.toString();
-  }
-
-  /**
-   * This method takes a String as an argument and removes all occurrences of
-   * the supplied Char. It returns the resulting String.
-   */
-  public static String removeChar(String s, char chr) {
-
-    StringBuilder sb = new StringBuilder(s.length());
-
-    for (int i = 0; i < s.length(); i++) {
-      char c = s.charAt(i);
-      if (c != chr) {
-        sb.append(c);
-      }
-    }
-
-    return sb.toString();
-  }
-
-  /**
-   * This method takes a String as an argument and removes all occurrences of
-   * the supplied Chars. It returns the resulting String.
-   */
-  public static String removeChars(String s, char[] chr) {
-
-    StringBuilder sb = new StringBuilder(s.length());
-
-    for (int i = 0; i < s.length(); i++) {
-      char c = s.charAt(i);
-      if (!charMatch(c, chr)) {
-        sb.append(c);
-      }
-    }
-
-    return sb.toString();
-  }
-
-  private static boolean charMatch(int iChr, char[] chr) {
-    for (int i = 0; i < chr.length; i++) {
-      if (iChr == chr[i]) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-}
+package com.avaje.ebean.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Utility String class that supports String manipulation functions.
+ */
+public class StringHelper {
+
+  private static final char SINGLE_QUOTE = '\'';
+
+  private static final char DOUBLE_QUOTE = '"';
+
+  /**
+   * parses a String of the form name1='value1' name2='value2'. Note that you
+   * can use either single or double quotes for any particular name value pair
+   * and the end quote must match the begin quote.
+   */
+  public static HashMap<String, String> parseNameQuotedValue(String tag) throws RuntimeException {
+
+    if (tag == null || tag.length() < 1) {
+      return null;
+    }
+
+    // make sure that the quotes are matched...
+    // int remainer = countOccurances(tag, ""+quote) % 2;
+    // if (remainer == 1) {
+    // dp("remainder = "+remainer);
+    // throw new StringParsingException("Unmatched quote in "+tag);
+    // }
+
+    // make sure that th last character is not an equals...
+    // (check now so I don't need to check this every time..)
+    if (tag.charAt(tag.length() - 1) == '=') {
+      throw new RuntimeException("missing quoted value at the end of " + tag);
+    }
+
+    HashMap<String, String> map = new HashMap<String, String>();
+    // recursively parse out the name value pairs...
+    return parseNameQuotedValue(map, tag, 0);
+  }
+
+  /**
+   * recursively parse out name value pairs (where the value is quoted, with
+   * either single or double quotes).
+   */
+  private static HashMap<String, String> parseNameQuotedValue(HashMap<String, String> map,
+      String tag, int pos) throws RuntimeException {
+
+    int equalsPos = tag.indexOf("=", pos);
+    if (equalsPos > -1) {
+      // check for begin quote...
+      char firstQuote = tag.charAt(equalsPos + 1);
+      if (firstQuote != SINGLE_QUOTE && firstQuote != DOUBLE_QUOTE) {
+        throw new RuntimeException("missing begin quote at " + (equalsPos) + "["
+            + tag.charAt(equalsPos + 1) + "] in [" + tag + "]");
+      }
+
+      // check for end quote...
+      int endQuotePos = tag.indexOf(firstQuote, equalsPos + 2);
+      if (endQuotePos == -1) {
+        throw new RuntimeException("missing end quote [" + firstQuote + "] after " + pos
+            + " in [" + tag + "]");
+      }
+
+      // we have a valid name and value...
+      // dp("pos="+pos+" equalsPos="+equalsPos+"
+      // endQuotePos="+endQuotePos);
+      String name = tag.substring(pos, equalsPos);
+      String value = tag.substring(equalsPos + 2, endQuotePos);
+      // dp("name="+name+"; value="+value+";");
+
+      // trim off any whitespace from the front of name...
+      name = trimFront(name, " ");
+      if ((name.indexOf(SINGLE_QUOTE) > -1) || (name.indexOf(DOUBLE_QUOTE) > -1)) {
+        throw new RuntimeException("attribute name contains a quote [" + name + "]");
+      }
+      map.put(name, value);
+
+      return parseNameQuotedValue(map, tag, endQuotePos + 1);
+
+    } else {
+      // no more equals... stop parsing...
+      return map;
+    }
+  }
+
+  /**
+   * Returns the number of times a particular String occurs in another String.
+   * e.g. count the number of single quotes.
+   */
+  public static int countOccurances(String content, String occurs) {
+    return countOccurances(content, occurs, 0, 0);
+  }
+
+  private static int countOccurances(String content, String occurs, int pos, int countSoFar) {
+    int equalsPos = content.indexOf(occurs, pos);
+    if (equalsPos > -1) {
+      countSoFar = countSoFar + 1;
+      pos = equalsPos + occurs.length();
+      // dp("countSoFar="+countSoFar+" pos="+pos);
+      return countOccurances(content, occurs, pos, countSoFar);
+    } else {
+      return countSoFar;
+    }
+  }
+
+  /**
+   * Parses out a list of Name Value pairs that are delimited together. Will
+   * always return a StringMap. If allNameValuePairs is null, or no name values
+   * can be parsed out an empty StringMap is returned.
+   * 
+   * @param allNameValuePairs
+   *          the entire string to be parsed.
+   * @param listDelimiter
+   *          (typically ';') the delimited between the list
+   * @param nameValueSeparator
+   *          (typically '=') the separator between the name and value
+   */
+  public static Map<String, String> delimitedToMap(String allNameValuePairs,
+      String listDelimiter, String nameValueSeparator) {
+
+    HashMap<String, String> params = new HashMap<String, String>();
+    if ((allNameValuePairs == null) || (allNameValuePairs.length() == 0)) {
+      return params;
+    }
+    // trim off any leading listDelimiter...
+    allNameValuePairs = trimFront(allNameValuePairs, listDelimiter);
+    return getKeyValue(params, 0, allNameValuePairs, listDelimiter, nameValueSeparator);
+  }
+
+  /**
+   * Trims off recurring strings from the front of a string.
+   * 
+   * @param source
+   *          the source string
+   * @param trim
+   *          the string to trim off the front
+   */
+  public static String trimFront(String source, String trim) {
+    if (source == null) {
+      return null;
+    }
+    if (source.indexOf(trim) == 0) {
+      // dp("trim ...");
+      return trimFront(source.substring(trim.length()), trim);
+    } else {
+      return source;
+    }
+  }
+
+  /**
+   * Return true if the value is null or an empty string.
+   */
+  public static boolean isNull(String value) {
+    if (value == null || value.trim().length() == 0) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Recursively pulls out the key value pairs from a raw string.
+   */
+  private static HashMap<String, String> getKeyValue(HashMap<String, String> map, int pos,
+      String allNameValuePairs, String listDelimiter, String nameValueSeparator) {
+
+    if (pos >= allNameValuePairs.length()) {
+      // dp("end as "+pos+" >= "+allNameValuePairs.length() );
+      return map;
+    }
+
+    int equalsPos = allNameValuePairs.indexOf(nameValueSeparator, pos);
+    int delimPos = allNameValuePairs.indexOf(listDelimiter, pos);
+
+    if (delimPos == -1) {
+      delimPos = allNameValuePairs.length();
+    }
+    if (equalsPos == -1) {
+      // dp("no more equals...");
+      return map;
+    }
+    if (delimPos == (equalsPos + 1)) {
+      // dp("Ignoring as nothing between delim and equals...
+      // delim:"+delimPos+" eq:"+equalsPos);
+      return getKeyValue(map, delimPos + 1, allNameValuePairs, listDelimiter,
+          nameValueSeparator);
+    }
+    if (equalsPos > delimPos) {
+      // there is a key without a value?
+      String key = allNameValuePairs.substring(pos, delimPos);
+      key = key.trim();
+      if (key.length() > 0) {
+        map.put(key, null);
+      }
+      return getKeyValue(map, delimPos + 1, allNameValuePairs, listDelimiter,
+          nameValueSeparator);
+
+    }
+    String key = allNameValuePairs.substring(pos, equalsPos);
+
+    if (delimPos > -1) {
+      String value = allNameValuePairs.substring(equalsPos + 1, delimPos);
+      // dp("cont "+key+","+value+" pos:"+pos+"
+      // len:"+allNameValuePairs.length());
+      key = key.trim();
+
+      map.put(key, value);
+      pos = delimPos + 1;
+
+      // recurse the rest of the values...
+      return getKeyValue(map, pos, allNameValuePairs, listDelimiter, nameValueSeparator);
+    } else {
+      // dp("ERROR: delimPos < 0 ???");
+      return map;
+    }
+  }
+
+  /**
+   * Convert a string that has delimited values (say comma delimited) in a
+   * String[]. You must explicitly choose whether or not to include empty values
+   * (say two commas that a right beside each other.
+   * 
+   * <P>
+   * e.g. "alpha,beta,,theta"<br>
+   * With keepEmpties true, this results in a String[] of size 4 with the third
+   * one having a String of 0 length. With keepEmpties false, this results in a
+   * String[] of size 3.
+   * </P>
+   * <P>
+   * </P>
+   * <P>
+   * e.g. ",alpha,beta,,theta,"<br>
+   * With keepEmpties true, this results in a String[] of size 6 with the
+   * 1st,4th and 6th one having a String of 0 length. With keepEmpties false,
+   * this results in a String[] of size 3.
+   * </P>
+   */
+  public static String[] delimitedToArray(String str, String delimiter, boolean keepEmpties) {
+
+    ArrayList<String> list = new ArrayList<String>();
+    int startPos = 0;
+    delimiter(str, delimiter, keepEmpties, startPos, list);
+    String[] result = new String[list.size()];
+    return (String[]) list.toArray(result);
+  }
+
+  private static void delimiter(String str, String delimiter, boolean keepEmpties, int startPos,
+      ArrayList<String> list) {
+
+    int endPos = str.indexOf(delimiter, startPos);
+    if (endPos == -1) {
+      if (startPos <= str.length()) {
+        String lastValue = str.substring(startPos, str.length());
+        // dp("lastValue="+lastValue);
+        if (!keepEmpties && lastValue.length() == 0) {
+          // dp("not keeping...");
+        } else {
+          list.add(lastValue);
+        }
+      }
+      // we have finished parsing the string...
+      return;
+    } else {
+      // get the delimited value... add it..
+      String value = str.substring(startPos, endPos);
+      // dp(startPos+","+endPos+" value="+value);
+      if (!keepEmpties && value.length() == 0) {
+        // dp("not keeping...");
+      } else {
+        list.add(value);
+      }
+      // recursively search as we are not at the end yet...
+      delimiter(str, delimiter, keepEmpties, endPos + 1, list);
+    }
+  }
+
+  /**
+   * This returns the FIRST string in str that is bounded on the left by
+   * leftBound, and bounded on the right by rightBound. This will return null if
+   * the leftBound is not found within str.
+   * 
+   * <P>
+   * If leftBound can't be found this returns null.
+   * </P>
+   * <P>
+   * This rightBound can't be found then this throws a
+   * StringIndexOutOfBoundsException.
+   * </P>
+   * 
+   * @param str
+   *          the base string that we will search for the bounded string.
+   * @param leftBound
+   *          the left bound of the string.
+   * @param rightBound
+   *          the right bound of the string.
+   */
+  public static String getBoundedString(String str, String leftBound, String rightBound)
+      throws RuntimeException {
+
+    if (str == null) {
+      throw new RuntimeException("string to parse is null?");
+    }
+    int startPos = str.indexOf(leftBound);
+    if (startPos > -1) {
+      startPos = startPos + leftBound.length();
+      int endPos = str.indexOf(rightBound, startPos);
+      // dp(str+" start:"+startPos+" end:"+endPos);
+      if (endPos == -1) {
+        throw new RuntimeException("Can't find rightBound: " + rightBound);
+      }
+      return str.substring(startPos, endPos);
+    } else {
+      // if no leftBound can be found.. return null... could be in a
+      // search n parse type loop?
+      // this keeps "no tag"==null different from "tag not formed
+      // properly"==StringParsingException
+      return null;
+    }
+  }
+
+  /**
+   * Takes the String bounded by leftBound & rightBound, and replaces it with
+   * replaceString. Actually removes the left and right bound strings aswell.
+   */
+  public static String setBoundedString(String str, String leftBound, String rightBound,
+      String replaceString) {
+
+    int startPos = str.indexOf(leftBound);
+    if (startPos > -1) {
+      // startPos = startPos;
+      int endPos = str.indexOf(rightBound, startPos + leftBound.length());
+      if (endPos > -1) {
+        String toReplace = str.substring(startPos, endPos + 1);
+        return replaceString(str, toReplace, replaceString);
+      } else {
+        return str;
+      }
+    } else {
+      return str;
+    }
+  }
+
+  // public static String replaceString(String str, String oldSub, String
+  // newSub) {
+  //
+  // if (str == null) {
+  // return null;
+  // }
+  // StringBuilder newSB = new StringBuilder(str.length()+20);
+  // int iPos = 0;
+  // int iPrevPos = 0;
+  //
+  // while (true) {
+  // iPos = str.indexOf(oldSub, iPrevPos);
+  // if (iPos > -1) {
+  // // found
+  // newSB.append(str.substring(iPrevPos, iPos));
+  // newSB.append(newSub);
+  // iPrevPos = iPos + oldSub.length();
+  // } else {
+  // // not found
+  // newSB.append(str.substring(iPrevPos));
+  // break;
+  // }
+  // }
+  //
+  // return newSB.toString();
+  // }
+
+  /**
+   * This method takes a String and will replace all occurrences of the match
+   * String with that of the replace String.
+   * 
+   * @param source
+   *          the source string
+   * @param match
+   *          the string used to find a match
+   * @param replace
+   *          the string used to replace match with
+   * @return the source string after the search and replace
+   */
+  public static String replaceString(String source, String match, String replace) {
+    if (source == null) {
+      return null;
+    }
+    if (replace == null) {
+      return source;
+    }
+    if (match == null) {
+      throw new NullPointerException("match is null?");
+    }
+    if (match.equals(replace)) {
+      return source;
+    }
+    return replaceString(source, match, replace, 30, 0, source.length());
+  }
+
+  /**
+   * Additionally specify the additionalSize to add to the buffer. This will
+   * make the buffer bigger so that it doesn't have to grow when replacement
+   * occurs.
+   */
+  public static String replaceString(String source, String match, String replace,
+      int additionalSize, int startPos, int endPos) {
+
+    if (source == null) {
+      return source;
+    }
+
+    char match0 = match.charAt(0);
+
+    int matchLength = match.length();
+
+    if (matchLength == 1 && replace.length() == 1) {
+      char replace0 = replace.charAt(0);
+      return source.replace(match0, replace0);
+    }
+    if (matchLength >= replace.length()) {
+      additionalSize = 0;
+    }
+
+    int sourceLength = source.length();
+    int lastMatch = endPos - matchLength;
+
+    StringBuilder sb = new StringBuilder(sourceLength + additionalSize);
+
+    if (startPos > 0) {
+      sb.append(source.substring(0, startPos));
+    }
+
+    char sourceChar;
+    boolean isMatch;
+    int sourceMatchPos;
+
+    for (int i = startPos; i < sourceLength; i++) {
+      sourceChar = source.charAt(i);
+      if (i > lastMatch || sourceChar != match0) {
+        sb.append(sourceChar);
+
+      } else {
+        // check to see if this is a match
+        isMatch = true;
+        sourceMatchPos = i;
+
+        // check each following character...
+        for (int j = 1; j < matchLength; j++) {
+          sourceMatchPos++;
+          if (source.charAt(sourceMatchPos) != match.charAt(j)) {
+            isMatch = false;
+            break;
+          }
+        }
+        if (isMatch) {
+          i = i + matchLength - 1;
+          sb.append(replace);
+        } else {
+          // was not a match
+          sb.append(sourceChar);
+        }
+      }
+    }
+
+    return sb.toString();
+  }
+
+  /**
+   * A search and replace with multiple matching strings.
+   * <p>
+   * Useful when converting CRNL CR and NL all to a BR tag for example.
+   * </p>
+   * 
+   * <pre>
+   * <code>
+   * String[] multi = { &quot;\r\n&quot;, &quot;\r&quot;, &quot;\n&quot; };
+   * content = StringHelper.replaceStringMulti(content, multi, &quot;&lt;br/&gt;&quot;);
+   * </code>
+   * </pre>
+   */
+  public static String replaceStringMulti(String source, String[] match, String replace) {
+    return replaceStringMulti(source, match, replace, 30, 0, source.length());
+  }
+
+  /**
+   * Additionally specify an additional size estimate for the buffer plus start
+   * and end positions.
+   * <p>
+   * The start and end positions can limit the search and replace. Otherwise
+   * these default to startPos = 0 and endPos = source.length().
+   * </p>
+   */
+  public static String replaceStringMulti(String source, String[] match, String replace,
+      int additionalSize, int startPos, int endPos) {
+
+    int shortestMatch = match[0].length();
+
+    char[] match0 = new char[match.length];
+    for (int i = 0; i < match0.length; i++) {
+      match0[i] = match[i].charAt(0);
+      if (match[i].length() < shortestMatch) {
+        shortestMatch = match[i].length();
+      }
+    }
+
+    StringBuilder sb = new StringBuilder(source.length() + additionalSize);
+
+    char sourceChar;
+
+    int len = source.length();
+    int lastMatch = endPos - shortestMatch;
+
+    if (startPos > 0) {
+      sb.append(source.substring(0, startPos));
+    }
+
+    int matchCount = 0;
+
+    for (int i = startPos; i < len; i++) {
+      sourceChar = source.charAt(i);
+      if (i > lastMatch) {
+        sb.append(sourceChar);
+      } else {
+        matchCount = 0;
+        for (int k = 0; k < match0.length; k++) {
+          if (matchCount == 0 && sourceChar == match0[k]) {
+            if (match[k].length() + i <= len) {
+
+              ++matchCount;
+              int j = 1;
+              for (; j < match[k].length(); j++) {
+                if (source.charAt(i + j) != match[k].charAt(j)) {
+                  --matchCount;
+                  break;
+                }
+              }
+              if (matchCount > 0) {
+                i = i + j - 1;
+                sb.append(replace);
+                break;
+              }
+            }
+          }
+        }
+        if (matchCount == 0) {
+          sb.append(sourceChar);
+        }
+      }
+    }
+
+    return sb.toString();
+  }
+
+  /**
+   * This method takes a String as an argument and removes all occurrences of
+   * the supplied Char. It returns the resulting String.
+   */
+  public static String removeChar(String s, char chr) {
+
+    StringBuilder sb = new StringBuilder(s.length());
+
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (c != chr) {
+        sb.append(c);
+      }
+    }
+
+    return sb.toString();
+  }
+
+  /**
+   * This method takes a String as an argument and removes all occurrences of
+   * the supplied Chars. It returns the resulting String.
+   */
+  public static String removeChars(String s, char[] chr) {
+
+    StringBuilder sb = new StringBuilder(s.length());
+
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (!charMatch(c, chr)) {
+        sb.append(c);
+      }
+    }
+
+    return sb.toString();
+  }
+
+  private static boolean charMatch(int iChr, char[] chr) {
+    for (int i = 0; i < chr.length; i++) {
+      if (iChr == chr[i]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+}