You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@uima.apache.org by re...@apache.org on 2018/05/29 22:40:26 UTC
[uima-uimafit] 01/01: [UIMA-3325]
FSCollectionFactory.createStringArray returns StringArrayFS
This is an automated email from the ASF dual-hosted git repository.
rec pushed a commit to branch feature/3325-fscollectionfactory-createstringarray-returns-stringarrayfs
in repository https://gitbox.apache.org/repos/asf/uima-uimafit.git
commit f5f73c59792cfd3266ab760559cdd60867557b7b
Author: Richard Eckart de Castilho <re...@apache.org>
AuthorDate: Wed May 30 00:35:58 2018 +0200
[UIMA-3325] FSCollectionFactory.createStringArray returns StringArrayFS
- Introduced non-FS variants of the fillArray calls
- Replaced array arguments with variadic arguments where possible
- (Hopefully) better use of generics at method level
- Removed unused generic type at class level
- Distinguish between CAS and JCas methods by adding "FS" in the method name (fillArray only)
- Changed return type of the JCas-based createXXX methods from the CAS to the JCas multi-value type
---
.../apache/uima/fit/util/FSCollectionFactory.java | 296 +++++++++++++--------
.../main/java/org/apache/uima/fit/util/FSUtil.java | 53 ++--
.../uima/fit/util/FSCollectionFactoryTest.java | 74 ++++--
.../uima/fit/util/FSCollectionFactoryTest.java | 74 +++---
4 files changed, 295 insertions(+), 202 deletions(-)
diff --git a/uimafit-core/src/main/java/org/apache/uima/fit/util/FSCollectionFactory.java b/uimafit-core/src/main/java/org/apache/uima/fit/util/FSCollectionFactory.java
index 1ff9750..3e18658 100644
--- a/uimafit-core/src/main/java/org/apache/uima/fit/util/FSCollectionFactory.java
+++ b/uimafit-core/src/main/java/org/apache/uima/fit/util/FSCollectionFactory.java
@@ -70,11 +70,8 @@ import org.apache.uima.jcas.cas.TOP;
/**
* Bridge between Java {@link Collection Collections} from different representations of collections
* of UIMA {@link FeatureStructure FeatureStructures}.
- *
- * @param <T>
- * data type.
*/
-public abstract class FSCollectionFactory<T extends FeatureStructure> {
+public abstract class FSCollectionFactory {
private FSCollectionFactory() {
// No instances.
@@ -141,7 +138,7 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
* @return a new collection containing the same feature structures as the provided array.
* @see <a href="package-summary.html#SortOrder">Order of selected feature structures</a>
*/
- public static Collection<FeatureStructure> create(ArrayFS aArray) {
+ public static <T extends FeatureStructure> Collection<T> create(ArrayFS<T> aArray) {
return create(aArray, (Type) null);
}
@@ -170,7 +167,7 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
* the CAS type.
* @return a new collection of all feature structures of the given type.
*/
- public static Collection<FeatureStructure> create(ArrayFS aArray, Type aType) {
+ public static <T extends FeatureStructure> Collection<T> create(ArrayFS<T> aArray, Type aType) {
TypeSystem ts = aArray.getCAS().getTypeSystem();
List<FeatureStructure> data = new ArrayList<FeatureStructure>(aArray.size());
for (int i = 0; i < aArray.size(); i++) {
@@ -179,282 +176,359 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
data.add(value);
}
}
- return asList(data.toArray(new FeatureStructure[data.size()]));
+ return (Collection<T>) asList(data.toArray(new FeatureStructure[data.size()]));
}
- public static ArrayFS createArrayFS(CAS aCas, Collection<? extends FeatureStructure> aCollection) {
+ public static <T extends FeatureStructure> ArrayFS<T> createArrayFS(CAS aCas,
+ Collection<T> aCollection) {
return fillArrayFS(aCas.createArrayFS(aCollection.size()), aCollection);
}
- public static ArrayFS createArrayFS(CAS aCas, FeatureStructure[] aArray) {
+ public static <T extends FeatureStructure> ArrayFS<T> createArrayFS(CAS aCas, T... aArray) {
return fillArrayFS(aCas.createArrayFS(aArray.length), asList(aArray));
}
- public static FSArray createFSArray(JCas aJCas, Collection<? extends FeatureStructure> aCollection) {
- return fillArrayFS(new FSArray(aJCas, aCollection.size()), aCollection);
+ public static <T extends FeatureStructure> FSArray<T> createFSArray(JCas aJCas,
+ Collection<T> aCollection) {
+ return fillArray(new FSArray<T>(aJCas, aCollection.size()), aCollection);
}
- public static FSArray createFSArray(JCas aJCas, FeatureStructure[] aArray) {
- return fillArrayFS(new FSArray(aJCas, aArray.length), asList(aArray));
+ public static <T extends FeatureStructure> FSArray<T> createFSArray(JCas aJCas, T... aArray) {
+ return fillArray(new FSArray<T>(aJCas, aArray.length), asList(aArray));
}
- public static BooleanArrayFS createBooleanArray(CAS aCas, Collection<Boolean> aCollection) {
+ public static BooleanArrayFS createBooleanArrayFS(CAS aCas, Collection<Boolean> aCollection) {
return fillArrayFS(aCas.createBooleanArrayFS(aCollection.size()), aCollection);
}
- public static BooleanArrayFS createBooleanArray(CAS aCas, boolean[] aArray) {
+ public static BooleanArrayFS createBooleanArrayFS(CAS aCas, boolean... aArray) {
return fillArrayFS(aCas.createBooleanArrayFS(aArray.length), aArray);
}
- public static BooleanArrayFS createBooleanArray(JCas aJCas, Collection<Boolean> aCollection) {
- return fillArrayFS(new BooleanArray(aJCas, aCollection.size()), aCollection);
+ public static BooleanArray createBooleanArray(JCas aJCas, Collection<Boolean> aCollection) {
+ return fillArray(new BooleanArray(aJCas, aCollection.size()), aCollection);
}
- public static BooleanArrayFS createBooleanArray(JCas aJCas, boolean[] aArray) {
- return fillArrayFS(new BooleanArray(aJCas, aArray.length), aArray);
+ public static BooleanArray createBooleanArray(JCas aJCas, boolean... aArray) {
+ return fillArray(new BooleanArray(aJCas, aArray.length), aArray);
}
- public static ByteArrayFS createByteArray(CAS aCas, Collection<Byte> aCollection) {
+ public static ByteArrayFS createByteArrayFS(CAS aCas, Collection<Byte> aCollection) {
return fillArrayFS(aCas.createByteArrayFS(aCollection.size()), aCollection);
}
- public static ByteArrayFS createByteArray(CAS aCas, byte[] aArray) {
+ public static ByteArrayFS createByteArrayFS(CAS aCas, byte... aArray) {
return fillArrayFS(aCas.createByteArrayFS(aArray.length), aArray);
}
- public static ByteArrayFS createByteArray(JCas aJCas, Collection<Byte> aCollection) {
- return fillArrayFS(new ByteArray(aJCas, aCollection.size()), aCollection);
+ public static ByteArray createByteArray(JCas aJCas, Collection<Byte> aCollection) {
+ return fillArray(new ByteArray(aJCas, aCollection.size()), aCollection);
}
- public static ByteArrayFS createByteArray(JCas aJCas, byte[] aArray) {
- return fillArrayFS(new ByteArray(aJCas, aArray.length), aArray);
+ public static ByteArray createByteArray(JCas aJCas, byte... aArray) {
+ return fillArray(new ByteArray(aJCas, aArray.length), aArray);
}
- public static DoubleArrayFS createDoubleArray(CAS aCas, Collection<Double> aCollection) {
+ public static DoubleArrayFS createDoubleArrayFS(CAS aCas, Collection<Double> aCollection) {
return fillArrayFS(aCas.createDoubleArrayFS(aCollection.size()), aCollection);
}
- public static DoubleArrayFS createDoubleArray(CAS aCas, double[] aArray) {
+ public static DoubleArrayFS createDoubleArrayFS(CAS aCas, double... aArray) {
return fillArrayFS(aCas.createDoubleArrayFS(aArray.length), aArray);
}
- public static DoubleArrayFS createDoubleArray(JCas aJCas, Collection<Double> aCollection) {
- return fillArrayFS(new DoubleArray(aJCas, aCollection.size()), aCollection);
+ public static DoubleArray createDoubleArray(JCas aJCas, Collection<Double> aCollection) {
+ return fillArray(new DoubleArray(aJCas, aCollection.size()), aCollection);
}
- public static DoubleArrayFS createDoubleArray(JCas aJCas, double[] aArray) {
- return fillArrayFS(new DoubleArray(aJCas, aArray.length), aArray);
+ public static DoubleArray createDoubleArray(JCas aJCas, double... aArray) {
+ return fillArray(new DoubleArray(aJCas, aArray.length), aArray);
}
- public static FloatArrayFS createFloatArray(CAS aCas, Collection<Float> aCollection) {
+ public static FloatArrayFS createFloatArrayFS(CAS aCas, Collection<Float> aCollection) {
return fillArrayFS(aCas.createFloatArrayFS(aCollection.size()), aCollection);
}
- public static FloatArrayFS createFloatArray(CAS aCas, float[] aArray) {
+ public static FloatArrayFS createFloatArrayFS(CAS aCas, float... aArray) {
return fillArrayFS(aCas.createFloatArrayFS(aArray.length), aArray);
}
- public static FloatArrayFS createFloatArray(JCas aJCas, Collection<Float> aCollection) {
- return fillArrayFS(new FloatArray(aJCas, aCollection.size()), aCollection);
+ public static FloatArray createFloatArray(JCas aJCas, Collection<Float> aCollection) {
+ return fillArray(new FloatArray(aJCas, aCollection.size()), aCollection);
}
- public static FloatArrayFS createFloatArray(JCas aJCas, float[] aArray) {
- return fillArrayFS(new FloatArray(aJCas, aArray.length), aArray);
+ public static FloatArray createFloatArray(JCas aJCas, float... aArray) {
+ return fillArray(new FloatArray(aJCas, aArray.length), aArray);
}
- public static IntArrayFS createIntArray(CAS aCas, Collection<Integer> aCollection) {
+ public static IntArrayFS createIntArrayFS(CAS aCas, Collection<Integer> aCollection) {
return fillArrayFS(aCas.createIntArrayFS(aCollection.size()), aCollection);
}
- public static IntArrayFS createIntArray(CAS aCas, int[] aArray) {
+ public static IntArrayFS createIntArrayFS(CAS aCas, int... aArray) {
return fillArrayFS(aCas.createIntArrayFS(aArray.length), aArray);
}
- public static IntArrayFS createIntArray(JCas aJCas, Collection<Integer> aCollection) {
- return fillArrayFS(new IntegerArray(aJCas, aCollection.size()), aCollection);
+ public static IntegerArray createIntArray(JCas aJCas, Collection<Integer> aCollection) {
+ return fillArray(new IntegerArray(aJCas, aCollection.size()), aCollection);
}
- public static IntArrayFS createIntArray(JCas aJCas, int[] aArray) {
- return fillArrayFS(new IntegerArray(aJCas, aArray.length), aArray);
+ public static IntegerArray createIntArray(JCas aJCas, int... aArray) {
+ return fillArray(new IntegerArray(aJCas, aArray.length), aArray);
}
- public static LongArrayFS createLongArray(CAS aCas, Collection<Long> aCollection) {
+ public static LongArrayFS createLongArrayFS(CAS aCas, Collection<Long> aCollection) {
return fillArrayFS(aCas.createLongArrayFS(aCollection.size()), aCollection);
}
- public static LongArrayFS createLongArray(CAS aCas, long[] aArray) {
+ public static LongArrayFS createLongArrayFS(CAS aCas, long... aArray) {
return fillArrayFS(aCas.createLongArrayFS(aArray.length), aArray);
}
- public static LongArrayFS createLongArray(JCas aJCas, Collection<Long> aCollection) {
- return fillArrayFS(new LongArray(aJCas, aCollection.size()), aCollection);
+ public static LongArray createLongArray(JCas aJCas, Collection<Long> aCollection) {
+ return fillArray(new LongArray(aJCas, aCollection.size()), aCollection);
}
- public static LongArrayFS createLongArray(JCas aJCas, long[] aArray) {
- return fillArrayFS(new LongArray(aJCas, aArray.length), aArray);
+ public static LongArray createLongArray(JCas aJCas, long... aArray) {
+ return fillArray(new LongArray(aJCas, aArray.length), aArray);
}
- public static ShortArrayFS createShortArray(CAS aCas, Collection<Short> aCollection) {
+ public static ShortArrayFS createShortArrayFS(CAS aCas, Collection<Short> aCollection) {
return fillArrayFS(aCas.createShortArrayFS(aCollection.size()), aCollection);
}
- public static ShortArrayFS createShortArray(CAS aCas, short[] aArray) {
+ public static ShortArrayFS createShortArrayFS(CAS aCas, short... aArray) {
return fillArrayFS(aCas.createShortArrayFS(aArray.length), aArray);
}
- public static ShortArrayFS createShortArray(JCas aJCas, Collection<Short> aCollection) {
- return fillArrayFS(new ShortArray(aJCas, aCollection.size()), aCollection);
+ public static ShortArray createShortArray(JCas aJCas, Collection<Short> aCollection) {
+ return fillArray(new ShortArray(aJCas, aCollection.size()), aCollection);
}
- public static ShortArrayFS createShortArray(JCas aJCas, short[] aArray) {
- return fillArrayFS(new ShortArray(aJCas, aArray.length), aArray);
+ public static ShortArray createShortArray(JCas aJCas, short... aArray) {
+ return fillArray(new ShortArray(aJCas, aArray.length), aArray);
}
- public static StringArrayFS createStringArray(CAS aCas, Collection<String> aCollection) {
+ public static StringArrayFS createStringArrayFS(CAS aCas, Collection<String> aCollection) {
return fillArrayFS(aCas.createStringArrayFS(aCollection.size()), aCollection);
}
- public static StringArrayFS createStringArray(CAS aCas, String[] aArray) {
+ public static StringArrayFS createStringArrayFS(CAS aCas, String... aArray) {
return fillArrayFS(aCas.createStringArrayFS(aArray.length), aArray);
}
- public static StringArrayFS createStringArray(JCas aJCas, Collection<String> aCollection) {
- return fillArrayFS(new StringArray(aJCas, aCollection.size()), aCollection);
+ public static StringArray createStringArray(JCas aJCas, Collection<String> aCollection) {
+ return fillArray(new StringArray(aJCas, aCollection.size()), aCollection);
+ }
+
+ public static StringArray createStringArray(JCas aJCas, String... aArray) {
+ return fillArray(new StringArray(aJCas, aArray.length), aArray);
}
- public static StringArrayFS createStringArray(JCas aJCas, String[] aArray) {
- return fillArrayFS(new StringArray(aJCas, aArray.length), aArray);
+ public static <T extends FeatureStructure> FSArray<T> fillArray(FSArray<T> aArray,
+ Iterable<? extends T> aValues) {
+ return (FSArray<T>) fillArrayFS(aArray, aValues);
}
- public static <T extends ArrayFS> T fillArrayFS(T aArrayFs,
- Iterable<? extends FeatureStructure> aCollection) {
+ public static <T extends FeatureStructure> FSArray<T> fillArray(FSArray<T> aArray,
+ FeatureStructure... aValues) {
+ return (FSArray<T>) fillArrayFS(aArray, aValues);
+ }
+
+ public static <T extends FeatureStructure> ArrayFS<T> fillArrayFS(ArrayFS<T> aArrayFs,
+ Iterable<? extends T> aCollection) {
int i = 0;
- for (FeatureStructure fs : aCollection) {
+ for (T fs : aCollection) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static ArrayFS fillArrayFS(ArrayFS aArrayFs, FeatureStructure[] aArray) {
+ public static <T extends FeatureStructure> ArrayFS<T> fillArrayFS(ArrayFS<T> aArrayFs,
+ FeatureStructure... aArray) {
aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static BooleanArrayFS fillArrayFS(BooleanArrayFS aArrayFs, Iterable<Boolean> aCollection) {
+ public static BooleanArray fillArray(BooleanArray aArray, Iterable<Boolean> aValues) {
+ return (BooleanArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static BooleanArray fillArray(BooleanArray aArray, boolean... aValues) {
+ return (BooleanArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static BooleanArrayFS fillArrayFS(BooleanArrayFS aArrayFs, Iterable<Boolean> aValues) {
int i = 0;
- for (Boolean fs : aCollection) {
+ for (Boolean fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static BooleanArrayFS fillArrayFS(BooleanArrayFS aArrayFs, boolean[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static BooleanArrayFS fillArrayFS(BooleanArrayFS aArrayFs, boolean... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static ByteArrayFS fillArrayFS(ByteArrayFS aArrayFs, Iterable<Byte> aCollection) {
+ public static ByteArray fillArray(ByteArray aArray, Iterable<Byte> aValues) {
+ return (ByteArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static ByteArray fillArray(ByteArray aArray, byte... aValues) {
+ return (ByteArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static ByteArrayFS fillArrayFS(ByteArrayFS aArrayFs, Iterable<Byte> aValues) {
int i = 0;
- for (Byte fs : aCollection) {
+ for (Byte fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static ByteArrayFS fillArrayFS(ByteArrayFS aArrayFs, byte[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static ByteArrayFS fillArrayFS(ByteArrayFS aArrayFs, byte... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, Iterable<Double> aCollection) {
+ public static DoubleArray fillArray(DoubleArray aArray, Iterable<Double> aValues) {
+ return (DoubleArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static DoubleArray fillArray(DoubleArray aArray, double... aValues) {
+ return (DoubleArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, Iterable<Double> aValues) {
int i = 0;
- for (Double fs : aCollection) {
+ for (Double fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, double[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, double... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, Iterable<Float> aCollection) {
+ public static FloatArray fillArray(FloatArray aArray, Iterable<Float> aValues) {
+ return (FloatArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static FloatArray fillArray(FloatArray aArray, float... aValues) {
+ return (FloatArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, Iterable<Float> aValues) {
int i = 0;
- for (Float fs : aCollection) {
+ for (Float fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, float[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, float... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static IntArrayFS fillArrayFS(IntArrayFS aArrayFs, Iterable<Integer> aCollection) {
+ public static IntegerArray fillArray(IntegerArray aArray, Iterable<Integer> aValues) {
+ return (IntegerArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static IntegerArray fillArray(IntegerArray aArray, int... aValues) {
+ return (IntegerArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static IntArrayFS fillArrayFS(IntArrayFS aArrayFs, Iterable<Integer> aValues) {
int i = 0;
- for (Integer fs : aCollection) {
+ for (Integer fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static IntArrayFS fillArrayFS(IntArrayFS aArrayFs, int[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static IntArrayFS fillArrayFS(IntArrayFS aArrayFs, int... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static LongArrayFS fillArrayFS(LongArrayFS aArrayFs, Iterable<Long> aCollection) {
+ public static LongArray fillArray(LongArray aArray, Iterable<Long> aValues) {
+ return (LongArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static LongArray fillArray(LongArray aArray, long... aValues) {
+ return (LongArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static LongArrayFS fillArrayFS(LongArrayFS aArrayFs, Iterable<Long> aValues) {
int i = 0;
- for (Long fs : aCollection) {
+ for (Long fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static LongArrayFS fillArrayFS(LongArrayFS aArrayFs, long[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static LongArrayFS fillArrayFS(LongArrayFS aArrayFs, long... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static ShortArrayFS fillArrayFS(ShortArrayFS aArrayFs, Iterable<Short> aCollection) {
+ public static ShortArray fillArray(ShortArray aArray, Iterable<Short> aValues) {
+ return (ShortArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static ShortArray fillArray(ShortArray aArray, short... aValues) {
+ return (ShortArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static ShortArrayFS fillArrayFS(ShortArrayFS aArrayFs, Iterable<Short> aValues) {
int i = 0;
- for (Short fs : aCollection) {
+ for (Short fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static ShortArrayFS fillArrayFS(ShortArrayFS aArrayFs, short[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static ShortArrayFS fillArrayFS(ShortArrayFS aArrayFs, short... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
- public static StringArrayFS fillArrayFS(StringArrayFS aArrayFs, Iterable<String> aCollection) {
+ public static StringArray fillArray(StringArray aArray, Iterable<String> aValues) {
+ return (StringArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static StringArray fillArray(StringArray aArray, String... aValues) {
+ return (StringArray) fillArrayFS(aArray, aValues);
+ }
+
+ public static StringArrayFS fillArrayFS(StringArrayFS aArrayFs, Iterable<String> aValues) {
int i = 0;
- for (String fs : aCollection) {
+ for (String fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
- public static StringArrayFS fillArrayFS(StringArrayFS aArrayFs, String[] aArray) {
- aArrayFs.copyFromArray(aArray, 0, 0, aArrayFs.size());
+ public static StringArrayFS fillArrayFS(StringArrayFS aArrayFs, String... aValues) {
+ aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
// Using TOP here because FSList is only available in the JCas.
- public static Collection<TOP> create(FSList aList) {
+ public static <T extends TOP> Collection<T> create(FSList<T> aList) {
return create(aList, (Type) null);
}
@@ -469,18 +543,17 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
* the JCas wrapper class.
* @return a new collection of all feature structures of the given type.
*/
- @SuppressWarnings("unchecked")
- public static <T extends TOP> Collection<T> create(FSList aList, Class<T> aType) {
+ public static <T extends TOP> Collection<T> create(FSList<T> aList, Class<? extends T> aType) {
return (Collection<T>) create(aList, CasUtil.getType(aList.getCAS(), aType));
}
// Using TOP here because FSList is only available in the JCas.
- public static Collection<TOP> create(FSList aList, Type type) {
+ public static <T extends TOP> Collection<T> create(FSList<T> aList, Type type) {
TypeSystem ts = aList.getCAS().getTypeSystem();
List<FeatureStructure> data = new ArrayList<FeatureStructure>();
- FSList i = aList;
+ FSList<T> i = aList;
while (i instanceof NonEmptyFSList) {
- NonEmptyFSList l = (NonEmptyFSList) i;
+ NonEmptyFSList<T> l = (NonEmptyFSList<T>) i;
TOP value = l.getHead();
if (value != null && (type == null || ts.subsumes(type, value.getType()))) {
data.add(l.getHead());
@@ -488,7 +561,7 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
i = l.getTail();
}
- return asList(data.toArray(new TOP[data.size()]));
+ return (Collection<T>) asList(data.toArray(new TOP[data.size()]));
}
public static Collection<String> create(StringList aList) {
@@ -527,26 +600,23 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
return asList(data.toArray(new Float[data.size()]));
}
- public static FSList createFSList(JCas aJCas, Collection<? extends TOP> aCollection) {
+ public static <T extends TOP> FSList<T> createFSList(JCas aJCas, Collection<T> aCollection) {
return createFSList(aJCas.getCas(), aCollection);
}
- public static <T extends FeatureStructure> T createFSList(CAS aCas, FeatureStructure... aValues) {
+ public static <T extends TOP> FSList<T> createFSList(CAS aCas, T... aValues) {
return createFSList(aCas, asList(aValues));
}
- public static <T extends FeatureStructure> T createFSList(CAS aCas,
- Collection<? extends FeatureStructure> aValues) {
+ public static <T extends TOP> FSList<T> createFSList(CAS aCas, Collection<T> aValues) {
if (aValues == null) {
return null;
}
TypeSystem ts = aCas.getTypeSystem();
- Type emptyType = ts.getType(CAS.TYPE_NAME_EMPTY_FS_LIST);
-
if (aValues.size() == 0) {
- return aCas.createFS(emptyType);
+ return aCas.emptyFSList();
}
Type nonEmptyType = ts.getType(CAS.TYPE_NAME_NON_EMPTY_FS_LIST);
@@ -563,11 +633,11 @@ public abstract class FSCollectionFactory<T extends FeatureStructure> {
head.setFeatureValue(tailFeature, tail);
head = tail;
} else {
- head.setFeatureValue(tailFeature, aCas.createFS(emptyType));
+ head.setFeatureValue(tailFeature, aCas.emptyFSList());
}
}
- return (T) list;
+ return (FSList<T>) list;
}
diff --git a/uimafit-core/src/main/java/org/apache/uima/fit/util/FSUtil.java b/uimafit-core/src/main/java/org/apache/uima/fit/util/FSUtil.java
index 971a571..db04bce 100644
--- a/uimafit-core/src/main/java/org/apache/uima/fit/util/FSUtil.java
+++ b/uimafit-core/src/main/java/org/apache/uima/fit/util/FSUtil.java
@@ -20,17 +20,17 @@ package org.apache.uima.fit.util;
import static java.util.Arrays.asList;
import static org.apache.uima.fit.util.FSCollectionFactory.createArrayFS;
-import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createByteArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createByteArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFSList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFloatList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createIntArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createIntArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createIntegerList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createLongArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createShortArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createStringArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createLongArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createShortArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createStringArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createStringList;
import java.lang.reflect.Array;
@@ -55,6 +55,7 @@ import org.apache.uima.cas.ShortArrayFS;
import org.apache.uima.cas.StringArrayFS;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.TypeSystem;
+import org.apache.uima.jcas.cas.TOP;
public class FSUtil {
private static Feature getMandatoryFeature(FeatureStructure aFS, String aFeature)
@@ -114,7 +115,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else {
- aFS.setFeatureValue(feat, createBooleanArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createBooleanArrayFS(aFS.getCAS(), aValue));
}
}
@@ -128,7 +129,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else {
- aFS.setFeatureValue(feat, createByteArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createByteArrayFS(aFS.getCAS(), aValue));
}
}
@@ -142,7 +143,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else {
- aFS.setFeatureValue(feat, createDoubleArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createDoubleArrayFS(aFS.getCAS(), aValue));
}
}
@@ -156,7 +157,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else if (feat.getRange().isArray()) {
- aFS.setFeatureValue(feat, createFloatArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createFloatArrayFS(aFS.getCAS(), aValue));
}
else {
aFS.setFeatureValue(feat, createFloatList(aFS.getCAS(), aValue));
@@ -173,7 +174,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else if (feat.getRange().isArray()) {
- aFS.setFeatureValue(feat, createIntArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createIntArrayFS(aFS.getCAS(), aValue));
}
else {
aFS.setFeatureValue(feat, createIntegerList(aFS.getCAS(), aValue));
@@ -190,7 +191,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else {
- aFS.setFeatureValue(feat, createLongArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createLongArrayFS(aFS.getCAS(), aValue));
}
}
@@ -204,7 +205,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else {
- aFS.setFeatureValue(feat, createShortArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createShortArrayFS(aFS.getCAS(), aValue));
}
}
@@ -218,7 +219,7 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else if (feat.getRange().isArray()) {
- aFS.setFeatureValue(feat, createStringArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createStringArrayFS(aFS.getCAS(), aValue));
}
else {
aFS.setFeatureValue(feat, createStringList(aFS.getCAS(), aValue));
@@ -234,7 +235,9 @@ public class FSUtil {
aFS.setFeatureValue(feat, null);
}
else if (isListType(aFS.getCAS().getTypeSystem(), feat.getRange())) {
- aFS.setFeatureValue(feat, createFSList(aFS.getCAS(), aValue));
+ TOP[] values = new TOP[aValue.length];
+ System.arraycopy(aValue, 0, values, 0, aValue.length);
+ aFS.setFeatureValue(feat, createFSList(aFS.getCAS(), values));
}
else {
requireSingleValue(feat, aValue);
@@ -251,28 +254,28 @@ public class FSUtil {
else if (feat.getRange().isArray()) {
switch (feat.getRange().getName()) {
case CAS.TYPE_NAME_BOOLEAN_ARRAY:
- aFS.setFeatureValue(feat, createBooleanArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createBooleanArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_BYTE_ARRAY:
- aFS.setFeatureValue(feat, createByteArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createByteArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_DOUBLE_ARRAY:
- aFS.setFeatureValue(feat, createDoubleArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createDoubleArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_FLOAT_ARRAY:
- aFS.setFeatureValue(feat, createFloatArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createFloatArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_INTEGER_ARRAY:
- aFS.setFeatureValue(feat, createIntArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createIntArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_LONG_ARRAY:
- aFS.setFeatureValue(feat, createLongArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createLongArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_SHORT_ARRAY:
- aFS.setFeatureValue(feat, createShortArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createShortArrayFS(aFS.getCAS(), aValue));
break;
case CAS.TYPE_NAME_STRING_ARRAY:
- aFS.setFeatureValue(feat, createStringArray(aFS.getCAS(), aValue));
+ aFS.setFeatureValue(feat, createStringArrayFS(aFS.getCAS(), aValue));
break;
default:
aFS.setFeatureValue(feat, createArrayFS(aFS.getCAS(), aValue));
diff --git a/uimafit-core/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java b/uimafit-core/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
index 8028ef1..5cd367d 100644
--- a/uimafit-core/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
+++ b/uimafit-core/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
@@ -24,20 +24,21 @@ package org.apache.uima.fit.util;
import static java.util.Arrays.asList;
import static org.apache.commons.lang.ArrayUtils.toObject;
import static org.apache.uima.fit.util.FSCollectionFactory.create;
-import static org.apache.uima.fit.util.FSCollectionFactory.createArrayFS;
-import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createByteArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.*;
+import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createByteArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFSArray;
import static org.apache.uima.fit.util.FSCollectionFactory.createFSList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFloatList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createIntArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createIntArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createIntegerList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createLongArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createShortArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createStringArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createLongArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createShortArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createStringArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createStringList;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
@@ -47,6 +48,8 @@ import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.fit.factory.JCasFactory;
import org.apache.uima.fit.type.Token;
import org.apache.uima.jcas.JCas;
+import org.apache.uima.jcas.cas.IntegerArray;
+import org.apache.uima.jcas.cas.StringArray;
import org.apache.uima.jcas.tcas.Annotation;
import org.junit.Before;
import org.junit.Test;
@@ -103,9 +106,9 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateBooleanArray() {
assertEquals(asList(true, false),
- asList(toObject(createBooleanArray(jcas.getCas(), asList(true, false)).toArray())));
+ asList(toObject(createBooleanArrayFS(jcas.getCas(), asList(true, false)).toArray())));
assertEquals(asList(true, false),
- asList(toObject(createBooleanArray(jcas.getCas(), new boolean[] { true, false })
+ asList(toObject(createBooleanArrayFS(jcas.getCas(), new boolean[] { true, false })
.toArray())));
assertEquals(asList(true, false), asList(toObject(createBooleanArray(jcas, asList(true, false))
.toArray())));
@@ -116,9 +119,9 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateByteArray() {
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas.getCas(), asList((byte) 0, (byte) 1)).toArray())));
+ asList(toObject(createByteArrayFS(jcas.getCas(), asList((byte) 0, (byte) 1)).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas.getCas(), new byte[] { 0, 1 }).toArray())));
+ asList(toObject(createByteArrayFS(jcas.getCas(), new byte[] { 0, 1 }).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
asList(toObject(createByteArray(jcas, asList((byte) 0, (byte) 1)).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
@@ -128,9 +131,9 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateDoubleArray() {
assertEquals(asList(0.0, 1.0),
- asList(toObject(createDoubleArray(jcas.getCas(), asList(0.0, 1.0)).toArray())));
+ asList(toObject(createDoubleArrayFS(jcas.getCas(), asList(0.0, 1.0)).toArray())));
assertEquals(asList(0.0, 1.0),
- asList(toObject(createDoubleArray(jcas.getCas(), new double[] { 0.0, 1.0 }).toArray())));
+ asList(toObject(createDoubleArrayFS(jcas.getCas(), new double[] { 0.0, 1.0 }).toArray())));
assertEquals(asList(0.0, 1.0), asList(toObject(createDoubleArray(jcas, asList(0.0, 1.0))
.toArray())));
assertEquals(asList(0.0, 1.0),
@@ -140,9 +143,9 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateFloatArray() {
assertEquals(asList(0.0f, 1.0f),
- asList(toObject(createFloatArray(jcas.getCas(), asList(0.0f, 1.0f)).toArray())));
+ asList(toObject(createFloatArrayFS(jcas.getCas(), asList(0.0f, 1.0f)).toArray())));
assertEquals(asList(0.0f, 1.0f),
- asList(toObject(createFloatArray(jcas.getCas(), new float[] { 0.0f, 1.0f }).toArray())));
+ asList(toObject(createFloatArrayFS(jcas.getCas(), new float[] { 0.0f, 1.0f }).toArray())));
assertEquals(asList(0.0f, 1.0f), asList(toObject(createFloatArray(jcas, asList(0.0f, 1.0f))
.toArray())));
assertEquals(asList(0.0f, 1.0f),
@@ -156,25 +159,33 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateIntArray() {
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas.getCas(), asList(0, 1))
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas.getCas(), asList(0, 1))
.toArray())));
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas.getCas(), new int[] { 0, 1 })
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas.getCas(), new int[] { 0, 1 })
.toArray())));
assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas, asList(0, 1)).toArray())));
assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas, new int[] { 0, 1 }).toArray())));
}
@Test
+ public void testFillIntegerArray() {
+ assertArrayEquals(new int[] {0, 1}, fillArray(new IntegerArray(jcas, 2), asList(0, 1)).toArray());
+ assertArrayEquals(new int[] {0, 1}, fillArray(new IntegerArray(jcas, 2), 0, 1).toArray());
+ assertArrayEquals(new int[] {0, 1}, fillArray(new IntegerArray(jcas, 2), asList(0, 1)).toArray());
+ assertArrayEquals(new int[] {0, 1}, fillArray(new IntegerArray(jcas, 2), 0, 1).toArray());
+ }
+
+ @Test
public void testCreateIntegerList() {
assertEquals(asList(0, 1), create(createIntegerList(jcas, asList(0, 1))));
}
@Test
public void testCreateLongArray() {
- assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas.getCas(), asList(0l, 1l))
+ assertEquals(asList(0l, 1l), asList(toObject(createLongArrayFS(jcas.getCas(), asList(0l, 1l))
.toArray())));
assertEquals(asList(0l, 1l),
- asList(toObject(createLongArray(jcas.getCas(), new long[] { 0l, 1l }).toArray())));
+ asList(toObject(createLongArrayFS(jcas.getCas(), new long[] { 0l, 1l }).toArray())));
assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas, asList(0l, 1l)).toArray())));
assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas, new long[] { 0l, 1l })
.toArray())));
@@ -184,9 +195,9 @@ public class FSCollectionFactoryTest {
public void testCreateShortArray() {
assertEquals(
asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas.getCas(), asList((short) 0, (short) 1)).toArray())));
+ asList(toObject(createShortArrayFS(jcas.getCas(), asList((short) 0, (short) 1)).toArray())));
assertEquals(asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas.getCas(), new short[] { 0, 1 }).toArray())));
+ asList(toObject(createShortArrayFS(jcas.getCas(), new short[] { 0, 1 }).toArray())));
assertEquals(asList((short) 0, (short) 1),
asList(toObject(createShortArray(jcas, asList((short) 0, (short) 1)).toArray())));
assertEquals(asList((short) 0, (short) 1),
@@ -195,13 +206,22 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateStringArray() {
- assertEquals(asList("0", "1"), asList(createStringArray(jcas.getCas(), asList("0", "1"))
+ assertEquals(asList("0", "1"), asList(createStringArrayFS(jcas.getCas(), asList("0", "1"))
.toArray()));
assertEquals(asList("0", "1"),
- asList(createStringArray(jcas.getCas(), new String[] { "0", "1" }).toArray()));
+ asList(createStringArrayFS(jcas.getCas(), new String[] { "0", "1" }).toArray()));
assertEquals(asList("0", "1"), asList(createStringArray(jcas, asList("0", "1")).toArray()));
- assertEquals(asList("0", "1"), asList(createStringArray(jcas, new String[] { "0", "1" })
- .toArray()));
+ assertEquals(asList("0", "1"), asList(createStringArray(jcas, "0", "1").toArray()));
+ }
+
+ @Test
+ public void testFillStringArray() {
+ assertEquals(asList("0", "1"),
+ asList(fillArray(new StringArray(jcas, 2), asList("0", "1")).toArray()));
+ assertEquals(asList("0", "1"), asList(fillArray(new StringArray(jcas, 2), "0", "1").toArray()));
+ assertEquals(asList("0", "1"),
+ asList(fillArray(new StringArray(jcas, 2), asList("0", "1")).toArray()));
+ assertEquals(asList("0", "1"), asList(fillArray(new StringArray(jcas, 2), "0", "1").toArray()));
}
@Test
diff --git a/uimafit-legacy-support/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java b/uimafit-legacy-support/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
index 8028ef1..298349c 100644
--- a/uimafit-legacy-support/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
+++ b/uimafit-legacy-support/src/test/java/org/apache/uima/fit/util/FSCollectionFactoryTest.java
@@ -25,18 +25,18 @@ import static java.util.Arrays.asList;
import static org.apache.commons.lang.ArrayUtils.toObject;
import static org.apache.uima.fit.util.FSCollectionFactory.create;
import static org.apache.uima.fit.util.FSCollectionFactory.createArrayFS;
-import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createByteArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createBooleanArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createByteArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createDoubleArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFSArray;
import static org.apache.uima.fit.util.FSCollectionFactory.createFSList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createFloatArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createFloatList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createIntArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createIntArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createIntegerList;
-import static org.apache.uima.fit.util.FSCollectionFactory.createLongArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createShortArray;
-import static org.apache.uima.fit.util.FSCollectionFactory.createStringArray;
+import static org.apache.uima.fit.util.FSCollectionFactory.createLongArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createShortArrayFS;
+import static org.apache.uima.fit.util.FSCollectionFactory.createStringArrayFS;
import static org.apache.uima.fit.util.FSCollectionFactory.createStringList;
import static org.junit.Assert.assertEquals;
@@ -103,7 +103,7 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateBooleanArray() {
assertEquals(asList(true, false),
- asList(toObject(createBooleanArray(jcas.getCas(), asList(true, false)).toArray())));
+ asList(toObject(createBooleanArrayFS(jcas.getCas(), asList(true, false)).toArray())));
assertEquals(asList(true, false),
asList(toObject(createBooleanArray(jcas.getCas(), new boolean[] { true, false })
.toArray())));
@@ -116,37 +116,37 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateByteArray() {
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas.getCas(), asList((byte) 0, (byte) 1)).toArray())));
+ asList(toObject(createByteArrayFS(jcas.getCas(), asList((byte) 0, (byte) 1)).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas.getCas(), new byte[] { 0, 1 }).toArray())));
+ asList(toObject(createByteArrayFS(jcas.getCas(), new byte[] { 0, 1 }).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas, asList((byte) 0, (byte) 1)).toArray())));
+ asList(toObject(createByteArrayFS(jcas, asList((byte) 0, (byte) 1)).toArray())));
assertEquals(asList((byte) 0, (byte) 1),
- asList(toObject(createByteArray(jcas, new byte[] { 0, 1 }).toArray())));
+ asList(toObject(createByteArrayFS(jcas, new byte[] { 0, 1 }).toArray())));
}
@Test
public void testCreateDoubleArray() {
assertEquals(asList(0.0, 1.0),
- asList(toObject(createDoubleArray(jcas.getCas(), asList(0.0, 1.0)).toArray())));
+ asList(toObject(createDoubleArrayFS(jcas.getCas(), asList(0.0, 1.0)).toArray())));
assertEquals(asList(0.0, 1.0),
- asList(toObject(createDoubleArray(jcas.getCas(), new double[] { 0.0, 1.0 }).toArray())));
- assertEquals(asList(0.0, 1.0), asList(toObject(createDoubleArray(jcas, asList(0.0, 1.0))
+ asList(toObject(createDoubleArrayFS(jcas.getCas(), new double[] { 0.0, 1.0 }).toArray())));
+ assertEquals(asList(0.0, 1.0), asList(toObject(createDoubleArrayFS(jcas, asList(0.0, 1.0))
.toArray())));
assertEquals(asList(0.0, 1.0),
- asList(toObject(createDoubleArray(jcas, new double[] { 0.0, 1.0 }).toArray())));
+ asList(toObject(createDoubleArrayFS(jcas, new double[] { 0.0, 1.0 }).toArray())));
}
@Test
public void testCreateFloatArray() {
assertEquals(asList(0.0f, 1.0f),
- asList(toObject(createFloatArray(jcas.getCas(), asList(0.0f, 1.0f)).toArray())));
+ asList(toObject(createFloatArrayFS(jcas.getCas(), asList(0.0f, 1.0f)).toArray())));
assertEquals(asList(0.0f, 1.0f),
- asList(toObject(createFloatArray(jcas.getCas(), new float[] { 0.0f, 1.0f }).toArray())));
- assertEquals(asList(0.0f, 1.0f), asList(toObject(createFloatArray(jcas, asList(0.0f, 1.0f))
+ asList(toObject(createFloatArrayFS(jcas.getCas(), new float[] { 0.0f, 1.0f }).toArray())));
+ assertEquals(asList(0.0f, 1.0f), asList(toObject(createFloatArrayFS(jcas, asList(0.0f, 1.0f))
.toArray())));
assertEquals(asList(0.0f, 1.0f),
- asList(toObject(createFloatArray(jcas, new float[] { 0.0f, 1.0f }).toArray())));
+ asList(toObject(createFloatArrayFS(jcas, new float[] { 0.0f, 1.0f }).toArray())));
}
@Test
@@ -156,12 +156,12 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateIntArray() {
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas.getCas(), asList(0, 1))
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas.getCas(), asList(0, 1))
.toArray())));
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas.getCas(), new int[] { 0, 1 })
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas.getCas(), new int[] { 0, 1 })
.toArray())));
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas, asList(0, 1)).toArray())));
- assertEquals(asList(0, 1), asList(toObject(createIntArray(jcas, new int[] { 0, 1 }).toArray())));
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas, asList(0, 1)).toArray())));
+ assertEquals(asList(0, 1), asList(toObject(createIntArrayFS(jcas, new int[] { 0, 1 }).toArray())));
}
@Test
@@ -171,12 +171,12 @@ public class FSCollectionFactoryTest {
@Test
public void testCreateLongArray() {
- assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas.getCas(), asList(0l, 1l))
+ assertEquals(asList(0l, 1l), asList(toObject(createLongArrayFS(jcas.getCas(), asList(0l, 1l))
.toArray())));
assertEquals(asList(0l, 1l),
- asList(toObject(createLongArray(jcas.getCas(), new long[] { 0l, 1l }).toArray())));
- assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas, asList(0l, 1l)).toArray())));
- assertEquals(asList(0l, 1l), asList(toObject(createLongArray(jcas, new long[] { 0l, 1l })
+ asList(toObject(createLongArrayFS(jcas.getCas(), new long[] { 0l, 1l }).toArray())));
+ assertEquals(asList(0l, 1l), asList(toObject(createLongArrayFS(jcas, asList(0l, 1l)).toArray())));
+ assertEquals(asList(0l, 1l), asList(toObject(createLongArrayFS(jcas, new long[] { 0l, 1l })
.toArray())));
}
@@ -184,23 +184,23 @@ public class FSCollectionFactoryTest {
public void testCreateShortArray() {
assertEquals(
asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas.getCas(), asList((short) 0, (short) 1)).toArray())));
+ asList(toObject(createShortArrayFS(jcas.getCas(), asList((short) 0, (short) 1)).toArray())));
assertEquals(asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas.getCas(), new short[] { 0, 1 }).toArray())));
+ asList(toObject(createShortArrayFS(jcas.getCas(), new short[] { 0, 1 }).toArray())));
assertEquals(asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas, asList((short) 0, (short) 1)).toArray())));
+ asList(toObject(createShortArrayFS(jcas, asList((short) 0, (short) 1)).toArray())));
assertEquals(asList((short) 0, (short) 1),
- asList(toObject(createShortArray(jcas, new short[] { 0, 1 }).toArray())));
+ asList(toObject(createShortArrayFS(jcas, new short[] { 0, 1 }).toArray())));
}
@Test
public void testCreateStringArray() {
- assertEquals(asList("0", "1"), asList(createStringArray(jcas.getCas(), asList("0", "1"))
+ assertEquals(asList("0", "1"), asList(createStringArrayFS(jcas.getCas(), asList("0", "1"))
.toArray()));
assertEquals(asList("0", "1"),
- asList(createStringArray(jcas.getCas(), new String[] { "0", "1" }).toArray()));
- assertEquals(asList("0", "1"), asList(createStringArray(jcas, asList("0", "1")).toArray()));
- assertEquals(asList("0", "1"), asList(createStringArray(jcas, new String[] { "0", "1" })
+ asList(createStringArrayFS(jcas.getCas(), new String[] { "0", "1" }).toArray()));
+ assertEquals(asList("0", "1"), asList(createStringArrayFS(jcas, asList("0", "1")).toArray()));
+ assertEquals(asList("0", "1"), asList(createStringArrayFS(jcas, new String[] { "0", "1" })
.toArray()));
}
--
To stop receiving notification emails like this one, please contact
rec@apache.org.