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:25 UTC
[uima-uimafit] branch
feature/3325-fscollectionfactory-createstringarray-returns-stringarrayfs
created (now f5f73c5)
This is an automated email from the ASF dual-hosted git repository.
rec pushed a change to branch feature/3325-fscollectionfactory-createstringarray-returns-stringarrayfs
in repository https://gitbox.apache.org/repos/asf/uima-uimafit.git.
at f5f73c5 [UIMA-3325] FSCollectionFactory.createStringArray returns StringArrayFS
This branch includes the following new commits:
new f5f73c5 [UIMA-3325] FSCollectionFactory.createStringArray returns StringArrayFS
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
--
To stop receiving notification emails like this one, please contact
rec@apache.org.
[uima-uimafit] 01/01: [UIMA-3325]
FSCollectionFactory.createStringArray returns StringArrayFS
Posted by re...@apache.org.
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.