destColumns, ResultSetMetaData srcColumns) throws SQLException, IOException {
return destColumns;
}
diff --git a/src/main/java/io/github/spannm/jackcess/util/StringUtil.java b/src/main/java/io/github/spannm/jackcess/util/StringUtil.java
new file mode 100644
index 0000000..14f8e34
--- /dev/null
+++ b/src/main/java/io/github/spannm/jackcess/util/StringUtil.java
@@ -0,0 +1,141 @@
+package io.github.spannm.jackcess.util;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.nio.CharBuffer;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.IntStream;
+
+/**
+ * Static utility methods for null-safe {@link String} operations.
+ *
+ * The class prefers interface {@link CharSequence} for inputs over {@code String} whenever possible, so that all implementations (e.g. {@link StringBuffer}, {@link StringBuilder}, {@link CharBuffer})
+ * can benefit.
+ *
+ * @author Markus Spann
+ */
+public final class StringUtil {
+
+ private StringUtil() {
+ }
+
+ /**
+ * Gets the given char sequence's length or {@code 0} if it is {@code null}.
+ *
+ * @param cs string
+ * @return length of string
+ */
+ public static int length(CharSequence cs) {
+ return cs == null ? 0 : cs.length();
+ }
+
+ /**
+ * Checks if the given char sequence is either null or empty.
+ *
+ * @param cs char sequence to test
+ * @return true if char sequence is empty or null, false otherwise
+ */
+ public static boolean isEmpty(CharSequence cs) {
+ return length(cs) == 0;
+ }
+
+ /**
+ * Returns {@code true} if the given char sequence is {@code null} or all blank space, {@code false} otherwise.
+ */
+ public static boolean isBlank(CharSequence cs) {
+ int len = length(cs);
+ return len == 0 || IntStream.range(0, len).allMatch(i -> Character.isWhitespace(cs.charAt(i)));
+ }
+
+ /**
+ * Returns the given char sequence trimmed or {@code null} if the string is {@code null} or empty.
+ */
+ public static String trimToNull(CharSequence cs) {
+ String str = cs == null ? null : cs.toString().trim();
+ return isEmpty(str) ? null : str;
+ }
+
+ /**
+ * Capitalizes a string changing its first character to title case as per {@link Character#toTitleCase(int)}.
+ */
+ public static String capitalize(String str) {
+ if (isEmpty(str)) {
+ return str;
+ }
+
+ int cp = str.codePointAt(0);
+ int newCp = Character.toTitleCase(cp);
+ return cp == newCp ? str : new String(Character.toString((char) newCp)) + str.substring(1);
+ }
+
+ public static String replace(String text, CharSequence searchString, CharSequence replacement) {
+ return isEmpty(text) || isEmpty(searchString) ? text : text.replace(searchString, replacement);
+ }
+
+ /**
+ * Removes all occurrences of character sequence {@code remove} from string {@code cs}.
+ *
+ * @param cs the character sequence to remove from
+ * @param remove the character sequence to remove
+ * @return modified input
+ */
+ public static String remove(CharSequence cs, CharSequence remove) {
+ if (cs == null) {
+ return null;
+ }
+ int len = cs.length();
+ if (len == 0) {
+ return "";
+ } else if (isEmpty(remove) || remove.length() > len) {
+ return cs.toString();
+ }
+ return cs.toString().replace(remove, "");
+ }
+
+ /**
+ * Generates a string representation of {@code obj} using reflection on its non-static declared fields.
+ *
+ * @param obj object to generate string from
+ * @param longClassName use full class name if {@code true} or simple name if {@code false}
+ * @param hashCode include the object's hash code if {@code true}
+ * @return string representation
+ */
+ public static String reflectionToString(Object obj, boolean longClassName, boolean hashCode) {
+ if (obj == null) {
+ return "null";
+ }
+ StringBuilder sb = new StringBuilder(longClassName ? obj.getClass().getName() : obj.getClass().getSimpleName());
+ if (hashCode) {
+ sb.append('@').append(Integer.toHexString(System.identityHashCode(obj)));
+ }
+ sb.append('[');
+ AtomicBoolean firstField = new AtomicBoolean(true);
+ Arrays.stream(obj.getClass().getDeclaredFields()).filter(f -> !Modifier.isStatic(f.getModifiers())).sorted(Comparator.comparing(Field::getName)).forEach(f -> {
+ if (!firstField.compareAndSet(true, false)) {
+ sb.append(',');
+ }
+ sb.append(f.getName()).append('=');
+ try {
+ f.setAccessible(true);
+ Object val = f.get(obj);
+ sb.append(val == null ? "" : val);
+ } catch (Exception _ex) {
+ sb.append('<').append(_ex).append('>');
+ }
+ });
+ return sb.append(']').toString();
+ }
+
+ /**
+ * Generates a string representation of {@code obj} using reflection on its non-static declared fields using the object's full class name and including the object's hash code.
+ *
+ * @param obj object to generate string from
+ * @return string representation
+ */
+ public static String reflectionToString(Object obj) {
+ return reflectionToString(obj, true, true);
+ }
+
+}
diff --git a/src/main/java/io/github/spannm/jackcess/util/ToStringBuilder.java b/src/main/java/io/github/spannm/jackcess/util/ToStringBuilder.java
new file mode 100644
index 0000000..36ca148
--- /dev/null
+++ b/src/main/java/io/github/spannm/jackcess/util/ToStringBuilder.java
@@ -0,0 +1,170 @@
+package io.github.spannm.jackcess.util;
+
+import io.github.spannm.jackcess.impl.ByteUtil;
+import io.github.spannm.jackcess.impl.PageChannel;
+
+import java.lang.reflect.Array;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.WeakHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Builder for {@link Object#toString()} methods.
+ *
+ * @author Markus Spann
+ */
+public class ToStringBuilder {
+ /** Object registry for avoidance of cycles. */
+ private static final Map OBJ_REGISTRY = new WeakHashMap<>();
+
+ private final StringBuilder buffer;
+ private final Object object;
+
+ private final String fieldSeparator;
+ private final boolean fieldSeparatorAtStart;
+ private final String fieldNameValueSeparator;
+ private final String contentStart;
+ private final String contentEnd;
+ private final String nullText;
+ private final String implSuffix;
+ private boolean useIdentityHashCode = true;
+ private final int maxByteDetailLen = 20;
+
+ ToStringBuilder(Object _object, String _fieldSeparator, boolean _fieldSeparatorAtStart, String _fieldNameValueSeparator, String _contentEnd, boolean _useIdentityHashCode) {
+ buffer = new StringBuilder(512);
+ object = _object;
+ fieldSeparator = Optional.ofNullable(_fieldSeparator).orElse(",");
+ fieldSeparatorAtStart = _fieldSeparatorAtStart;
+ fieldNameValueSeparator = Optional.ofNullable(_fieldNameValueSeparator).orElse("=");
+ contentStart = "[";
+ contentEnd = Optional.ofNullable(_contentEnd).orElse("]");
+ nullText = "";
+ implSuffix = "Impl";
+ useIdentityHashCode = _useIdentityHashCode;
+
+ if (object != null) {
+ buffer.append(_object instanceof String ? _object : getShortClassName(_object.getClass(), implSuffix));
+ if (useIdentityHashCode) {
+ buffer.append('@').append(Integer.toHexString(System.identityHashCode(object)));
+ }
+
+ buffer.append(contentStart);
+ if (fieldSeparatorAtStart) {
+ buffer.append(fieldSeparator);
+ }
+ }
+ }
+
+ public static ToStringBuilder valueBuilder(Object obj) {
+ return new ToStringBuilder(obj, null, false, null, null, false);
+ }
+
+ public static ToStringBuilder builder(Object obj) {
+ return new ToStringBuilder(obj, System.lineSeparator() + " ", true, ": ", System.lineSeparator() + "]", true);
+ }
+
+ public ToStringBuilder append(String fieldName, Object value) {
+ if (fieldName != null) {
+ buffer.append(fieldName).append(fieldNameValueSeparator);
+ }
+
+ if (value == null) {
+ buffer.append(nullText);
+ } else {
+ appendInternal(buffer, fieldName, value);
+ }
+
+ buffer.append(fieldSeparator);
+ return this;
+ }
+
+ public ToStringBuilder appendIgnoreNull(String fieldName, Object value) {
+ return append(fieldName, value == null ? "" : value);
+ }
+
+ @Override
+ public String toString() {
+ if (object == null) {
+ buffer.append(nullText);
+ } else {
+ removeLastFieldSeparator(buffer, fieldSeparator);
+ buffer.append(contentEnd);
+ }
+ return buffer.toString();
+ }
+
+ void appendInternal(StringBuilder _buffer, String _fieldName, Object _value) {
+ boolean primitiveWrapper = _value instanceof Number || _value instanceof Boolean || _value instanceof Character;
+ if (OBJ_REGISTRY.containsKey(_value) && !primitiveWrapper) {
+ _buffer.append(_value.getClass().getName() + '@' + Integer.toHexString(System.identityHashCode(_value)));
+ return;
+ }
+
+ OBJ_REGISTRY.put(_value, null); // register object
+
+ try {
+ if (_value instanceof byte[]) {
+ ByteBuffer bb = PageChannel.wrap((byte[]) _value);
+ int len = bb.remaining();
+ _buffer.append("(").append(len).append(") ").append(ByteUtil.toHexString(bb, bb.position(), Math.min(len, maxByteDetailLen)));
+ if (len > maxByteDetailLen) {
+ _buffer.append("...");
+ }
+ } else if (_value.getClass().isArray()) {
+ Object arr = _value;
+ _buffer.append('{');
+ for (int i = 0; i < Array.getLength(arr); i++) {
+ Object item = Array.get(arr, i);
+ if (i > 0) {
+ _buffer.append(fieldSeparator);
+ }
+ if (item == null) {
+ _buffer.append(nullText);
+ } else {
+ appendInternal(_buffer, _fieldName, item); // recursive call
+ }
+ }
+ _buffer.append('}');
+ } else if (_value instanceof Collection) {
+ String str = ((Collection) _value).stream().map(v -> v == null ? nullText : v.toString()).collect(Collectors.joining(","));
+ _buffer.append('[').append(str).append(']');
+ } else if (_value instanceof Map) {
+ String str = ((Map) _value).entrySet().stream().map(e -> e.getKey() + "=" + (e.getValue() == null ? nullText : e.getValue())).collect(Collectors.joining(","));
+ _buffer.append('{').append(str).append('}');
+ } else {
+ _buffer.append(_value);
+ }
+ } finally {
+ OBJ_REGISTRY.remove(_value); // unregister object
+ }
+ }
+
+ static String getShortClassName(Class clazz, String _implSuffix) {
+ String nm = clazz.getSimpleName();
+ if (nm.endsWith(_implSuffix)) {
+ nm = nm.substring(0, nm.length() - _implSuffix.length());
+ }
+ int idx = nm.lastIndexOf('.');
+ return idx >= 0 ? nm.substring(idx + 1) : nm;
+ }
+
+ static void removeLastFieldSeparator(StringBuilder _buffer, String _fieldSeparator) {
+ int len = _buffer.length();
+ int sepLen = _fieldSeparator.length();
+ if (len > 0 && sepLen > 0 && len >= sepLen) {
+ boolean match = true;
+ for (int i = 0; i < sepLen; i++) {
+ if (_buffer.charAt(len - 1 - i) != _fieldSeparator.charAt(sepLen - 1 - i)) {
+ return;
+ }
+ }
+ if (match) {
+ _buffer.setLength(len - sepLen);
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/io/github/spannm/jackcess/DatabaseTest.java b/src/test/java/io/github/spannm/jackcess/DatabaseTest.java
index 1559bea..397cf87 100644
--- a/src/test/java/io/github/spannm/jackcess/DatabaseTest.java
+++ b/src/test/java/io/github/spannm/jackcess/DatabaseTest.java
@@ -131,10 +131,7 @@ public void testGetColumns() throws Exception {
}
}
- private static void checkColumn(
- List columns, int columnNumber, String name,
- DataType dataType)
- throws Exception {
+ private static void checkColumn(List columns, int columnNumber, String name, DataType dataType) throws Exception {
Column column = columns.get(columnNumber);
assertEquals(name, column.getName());
assertEquals(dataType, column.getType());
@@ -976,8 +973,7 @@ public void testBrokenIndex() throws Exception {
}
}
- private static void verifyFinderType(Database db, String clazzName)
- throws Exception {
+ private static void verifyFinderType(Database db, String clazzName) throws Exception {
java.lang.reflect.Field f = db.getClass().getDeclaredField("_tableFinder");
f.setAccessible(true);
Object finder = f.get(db);
diff --git a/src/test/java/io/github/spannm/jackcess/TestUtil.java b/src/test/java/io/github/spannm/jackcess/TestUtil.java
index 1321e33..75e902a 100644
--- a/src/test/java/io/github/spannm/jackcess/TestUtil.java
+++ b/src/test/java/io/github/spannm/jackcess/TestUtil.java
@@ -153,10 +153,7 @@ public static Database openCopy(FileFormat fileFormat, File file,
return openDB(fileFormat, tmp, false, null, false);
}
- private static Database openDB(
- FileFormat fileFormat, File file, boolean inMem, Charset charset,
- boolean readOnly)
- throws Exception {
+ private static Database openDB(FileFormat fileFormat, File file, boolean inMem, Charset charset, boolean readOnly) throws Exception {
FileChannel channel = inMem ? MemFileChannel.newChannel(
file, MemFileChannel.RW_CHANNEL_MODE)
: null;
diff --git a/src/test/java/io/github/spannm/jackcess/impl/ExtendedDateTest.java b/src/test/java/io/github/spannm/jackcess/impl/ExtendedDateTest.java
index 347b0f8..f741004 100644
--- a/src/test/java/io/github/spannm/jackcess/impl/ExtendedDateTest.java
+++ b/src/test/java/io/github/spannm/jackcess/impl/ExtendedDateTest.java
@@ -29,11 +29,9 @@
import java.time.LocalDate;
import java.time.LocalDateTime;
+import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
/**
*
@@ -47,12 +45,14 @@ public ExtendedDateTest(String name) throws Exception {
public void testReadExtendedDate() throws Exception {
- DateTimeFormatter dtfNoTime = DateTimeFormatter.ofPattern("M/d/yyy");
- DateTimeFormatter dtfFull = DateTimeFormatter.ofPattern("M/d/yyy h:mm:ss.SSSSSSS a");
+ ZoneId zoneId = ZoneId.of("America/New_York");
+ DateTimeFormatter dtfNoTime = DateTimeFormatter.ofPattern("M/d/yyy", Locale.US);
+ DateTimeFormatter dtfFull = DateTimeFormatter.ofPattern("M/d/yyy h:mm:ss.SSSSSSS a", Locale.US);
- for (final TestDB testDB : TestDB.getSupportedForBasename(Basename.EXT_DATE)) {
+ for (TestDB testDB : TestDB.getSupportedForBasename(Basename.EXT_DATE)) {
Database db = openMem(testDB);
+ db.setZoneId(zoneId);
Table t = db.getTable("Table1");
for (Row r : t) {
diff --git a/src/test/java/io/github/spannm/jackcess/query/QueryTest.java b/src/test/java/io/github/spannm/jackcess/query/QueryTest.java
index 84bac78..b3b4d44 100644
--- a/src/test/java/io/github/spannm/jackcess/query/QueryTest.java
+++ b/src/test/java/io/github/spannm/jackcess/query/QueryTest.java
@@ -26,7 +26,6 @@
import io.github.spannm.jackcess.impl.query.QueryImpl;
import io.github.spannm.jackcess.impl.query.QueryImpl.Row;
import junit.framework.TestCase;
-import org.apache.commons.lang3.StringUtils;
import java.util.*;
@@ -605,7 +604,7 @@ private static void removeLastRows(Query query, int num) {
}
private static String multiline(String... strs) {
- return StringUtils.join(strs, System.lineSeparator());
+ return String.join(System.lineSeparator(), strs);
}
}
diff --git a/src/test/java/io/github/spannm/jackcess/util/StringUtilTest.java b/src/test/java/io/github/spannm/jackcess/util/StringUtilTest.java
new file mode 100644
index 0000000..ac7c416
--- /dev/null
+++ b/src/test/java/io/github/spannm/jackcess/util/StringUtilTest.java
@@ -0,0 +1,84 @@
+package io.github.spannm.jackcess.util;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class StringUtilTest {
+
+ @Test
+ public void testLength() {
+ assertEquals(0, StringUtil.length(null));
+ assertEquals(0, StringUtil.length(""));
+ assertEquals(1, StringUtil.length("A"));
+ assertEquals(1, StringUtil.length(" "));
+ assertEquals(4, StringUtil.length("sman"));
+ }
+
+ @Test
+ public void testIsEmpty() {
+ assertTrue(StringUtil.isEmpty(null));
+ assertTrue(StringUtil.isEmpty(""));
+ assertFalse(StringUtil.isEmpty(" "));
+ assertFalse(StringUtil.isEmpty("not Empty"));
+ }
+
+ @Test
+ public void testIsBlank() {
+ assertTrue(StringUtil.isBlank(null));
+ assertTrue(StringUtil.isBlank(""));
+ assertTrue(StringUtil.isBlank(" "));
+ assertTrue(StringUtil.isBlank(System.lineSeparator()));
+ }
+
+ @Test
+ public void testTrimToNull() {
+ assertNull(StringUtil.trimToNull(null));
+ assertNull(StringUtil.trimToNull(""));
+ assertNull(StringUtil.trimToNull(" "));
+ assertEquals("sman", StringUtil.trimToNull("sman"));
+ assertEquals("81", StringUtil.trimToNull(" 81 "));
+ }
+
+ @Test
+ public void testCapitalize() {
+ assertNull(StringUtil.capitalize(null));
+ assertEquals("", StringUtil.capitalize(""));
+ assertEquals("Hello", StringUtil.capitalize("hello"));
+ assertEquals("Foo bar", StringUtil.capitalize("foo bar"));
+ assertEquals("Boo far", StringUtil.capitalize("Boo far"));
+ }
+
+ @Test
+ public void testReplace() {
+ assertNull(null, StringUtil.replace(null, null, null));
+ assertEquals(" ", StringUtil.replace(" ", " ", " "));
+ assertEquals("text", StringUtil.replace("text", "", "newText"));
+ assertEquals(" txt txt ", StringUtil.replace(" text text ", "text", "txt"));
+ }
+
+ @Test
+ public void testRemove() {
+ assertNull(StringUtil.remove(null, null));
+ assertNull(StringUtil.remove(null, ""));
+ assertNull(StringUtil.remove(null, "remove"));
+ assertEquals("", StringUtil.remove("", "remove"));
+ assertEquals("input", StringUtil.remove("input", "remove"));
+ assertEquals("Removed", StringUtil.remove("Removed", "remove"));
+ assertEquals("", StringUtil.remove("remove", "remove"));
+ assertEquals("long", StringUtil.remove("long", "longer"));
+ }
+
+ @Test
+ public void testReflectionToString() {
+ assertEquals("null", StringUtil.reflectionToString(null));
+ String str = StringUtil.reflectionToString(new TestObj());
+ assertTrue(str.matches("^io\\.github\\.spannm\\.jackcess\\.util\\.StringUtilTest\\$TestObj@[0-9a-f]+\\[strVal=testing\\]$"));
+ assertEquals("Integer[value=47]", StringUtil.reflectionToString(Integer.valueOf(47), false, false));
+ }
+
+ static class TestObj {
+ final String strVal = "testing";
+ }
+
+}