下面列出了org.eclipse.jface.viewers.CheckboxCellEditor#org.apache.uima.cas.FloatArrayFS 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Convenience constructor which only needs the callback for encountered feature structures.
*
* @param featureStructureEncounteredCallback callback for encountered feature structures
*/
FsCopiers(UnaryOperator<FeatureStructure> featureStructureEncounteredCallback,
FeatureCopiers featureCopiers) {
this.featureCopiers = featureCopiers;
this.featureStructureEncounteredCallback = featureStructureEncounteredCallback;
fsCopiers = new HashMap<>();
fsCopiers.put(CAS.TYPE_NAME_BOOLEAN_ARRAY, copyArray(BooleanArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_BYTE_ARRAY, copyArray(ByteArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_DOUBLE_ARRAY, copyArray(DoubleArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_FLOAT_ARRAY, copyArray(FloatArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_FS_ARRAY, this::copyFsArray);
fsCopiers.put(CAS.TYPE_NAME_LONG_ARRAY, copyArray(LongArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_INTEGER_ARRAY, copyArray(IntArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_SHORT_ARRAY, copyArray(ShortArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_STRING_ARRAY, copyArray(StringArrayFS.class));
}
/**
* Convenience constructor which only needs the callback for encountered feature structures.
*
* @param featureStructureEncounteredCallback callback for encountered feature structures
*/
FsCopiers(UnaryOperator<FeatureStructure> featureStructureEncounteredCallback) {
this.featureCopiers = new FeatureCopiers(featureStructureEncounteredCallback);
this.featureStructureEncounteredCallback = featureStructureEncounteredCallback;
fsCopiers = new HashMap<>();
fsCopiers.put(CAS.TYPE_NAME_BOOLEAN_ARRAY, copyArray(BooleanArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_BYTE_ARRAY, copyArray(ByteArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_DOUBLE_ARRAY, copyArray(DoubleArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_FLOAT_ARRAY, copyArray(FloatArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_FS_ARRAY, this::copyFsArray);
fsCopiers.put(CAS.TYPE_NAME_LONG_ARRAY, copyArray(LongArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_INTEGER_ARRAY, copyArray(IntArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_SHORT_ARRAY, copyArray(ShortArrayFS.class));
fsCopiers.put(CAS.TYPE_NAME_STRING_ARRAY, copyArray(StringArrayFS.class));
}
public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, Iterable<Float> aValues) {
int i = 0;
for (Float fs : aValues) {
aArrayFs.set(i, fs);
i++;
}
return aArrayFs;
}
public String toString() {
Object v = getValue();
String className = v.getClass().getSimpleName();
if (v instanceof StringArrayFS)
v = className + "[" + ((StringArrayFS) v).size() + "]";
else if (v instanceof FloatArrayFS)
v = className + "[" + ((FloatArrayFS) v).size() + "]";
else if (v instanceof IntArrayFS)
v = className + "[" + ((IntArrayFS) v).size() + "]";
else if (v instanceof ArrayFS)
v = className + "[" + ((ArrayFS) v).size() + "]";
return getName() + ": " + v;
}
private void createFloatA(FeatureStructure fs, float x) {
FloatArrayFS fafs = createFloatArrayFS(cas, 6);
fafs.set(0, Float.MAX_VALUE - x);
// fafs.set(1, Float.MIN_NORMAL + x);
fafs.set(2, Float.MIN_VALUE + x);
fafs.set(3, Float.NaN);
fafs.set(4, Float.NEGATIVE_INFINITY);
fafs.set(5, Float.POSITIVE_INFINITY);
fs.setFeatureValue(akofAfloat, fafs);
}
private FloatArrayFS randomFloatA(Random r) {
int length = r.nextInt(2) + 1;
FloatArrayFS fs = createFloatArrayFS(cas, length);
for (int i = 0; i < length; i++) {
fs.set(i, floatValues[r.nextInt(floatValues.length)]);
}
return fs;
}
private void createFloatA(CASImpl cas, TTypeSystem m, FeatureStructure fs, float x) {
FloatArrayFS fafs = cas.createFloatArrayFS(6);
fafs.set(0, Float.MAX_VALUE - x);
// fafs.set(1, Float.MIN_NORMAL + x);
fafs.set(2, Float.MIN_VALUE + x);
fafs.set(3, Float.NaN);
fafs.set(4, Float.NEGATIVE_INFINITY);
fafs.set(5, Float.POSITIVE_INFINITY);
maybeSetFeatureKind(fs, m, "Afloat", fafs);
}
private FloatArrayFS randomFloatA(CASImpl cas) {
int length = random.nextInt(2) + 1;
FloatArrayFS fs = cas.createFloatArrayFS(length);
for (int i = 0; i < length; i++) {
fs.set(i, floatValues[random.nextInt(floatValues.length)]);
}
return fs;
}
public void testToArray() {
// From CAS array to Java array.
FloatArrayFS array = this.cas.createFloatArrayFS(3);
float[] fsArray = array.toArray();
for (int i = 0; i < 3; i++) {
assertTrue(fsArray[i] == 0f);
}
array.set(0, 1f);
array.set(1, 2f);
array.set(2, 3f);
fsArray = array.toArray();
assertTrue(fsArray.length == 3);
assertTrue(fsArray[0] == 1f);
assertTrue(fsArray[1] == 2f);
assertTrue(fsArray[2] == 3f);
// From Java array to CAS array.
array = this.cas.createFloatArrayFS(3);
assertTrue(array.get(0) == 0f);
assertTrue(array.get(1) == 0f);
assertTrue(array.get(2) == 0f);
for (int i = 0; i < 3; i++) {
array.set(i, fsArray[i]);
}
assertTrue(array.get(0) == 1f);
assertTrue(array.get(1) == 2f);
assertTrue(array.get(2) == 3f);
array.set(0, 0f);
assertTrue(array.get(0) == 0f);
}
private ARRAY_TYPE getArrayType(CommonArrayFS c) {
if (c instanceof ArrayFS) return ARRAY_TYPE.FS;
if (c instanceof StringArrayFS) return ARRAY_TYPE.STRING;
if (c instanceof BooleanArrayFS) return ARRAY_TYPE.BOOLEAN;
if (c instanceof ByteArrayFS) return ARRAY_TYPE.BYTE;
if (c instanceof ShortArrayFS) return ARRAY_TYPE.SHORT;
if (c instanceof IntArrayFS) return ARRAY_TYPE.INT;
if (c instanceof LongArrayFS) return ARRAY_TYPE.LONG;
if (c instanceof FloatArrayFS) return ARRAY_TYPE.FLOAT;
if (c instanceof DoubleArrayFS) return ARRAY_TYPE.DOUBLE;
return null;
}
public static FloatArrayFS createFloatArrayFS(CAS aCas, Collection<Float> aCollection) {
return fillArrayFS(aCas.createFloatArrayFS(aCollection.size()), aCollection);
}
public static FloatArrayFS createFloatArrayFS(CAS aCas, float... aArray) {
return fillArrayFS(aCas.createFloatArrayFS(aArray.length), aArray);
}
public static FloatArrayFS fillArrayFS(FloatArrayFS aArrayFs, float... aValues) {
aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
return aArrayFs;
}
private void createExampleFS(CAS cas) throws Exception {
// Set the document text
cas.setDocumentText("this beer is good");
// create an FS of exampleType and index it
AnnotationFS fs = cas.createAnnotation(exampleType, 1, 5);
cas.getIndexRepository().addFS(fs);
// create Array FSs
StringArrayFS strArrayFS = cas.createStringArrayFS(5);
strArrayFS.set(0, "zzzzzz");
strArrayFS.set(1, "yyyyyy");
strArrayFS.set(2, "xxxxxx");
strArrayFS.set(3, "wwwwww");
strArrayFS.set(4, "vvvvvv");
IntArrayFS intArrayFS = cas.createIntArrayFS(5);
intArrayFS.set(0, Integer.MAX_VALUE);
intArrayFS.set(1, Integer.MAX_VALUE - 1);
intArrayFS.set(2, 42);
intArrayFS.set(3, Integer.MIN_VALUE + 1);
intArrayFS.set(4, Integer.MIN_VALUE);
FloatArrayFS floatArrayFS = cas.createFloatArrayFS(5);
floatArrayFS.set(0, Float.MAX_VALUE);
floatArrayFS.set(1, (float) (Float.MAX_VALUE / 1000.0));
floatArrayFS.set(2, (float) 42);
floatArrayFS.set(3, (float) (Float.MIN_VALUE * 1000.0));
floatArrayFS.set(4, Float.MIN_VALUE);
ByteArrayFS byteArrayFS = cas.createByteArrayFS(5);
byteArrayFS.set(0, (byte) 8);
byteArrayFS.set(1, (byte) 16);
byteArrayFS.set(2, (byte) 64);
byteArrayFS.set(3, (byte) 128);
byteArrayFS.set(4, (byte) 255);
BooleanArrayFS boolArrayFS = cas.createBooleanArrayFS(8);
boolean val = false;
for (int i = 0; i < 8; i++) {
boolArrayFS.set(i, val = !val);
}
ShortArrayFS shortArrayFS = cas.createShortArrayFS(5);
shortArrayFS.set(0, Short.MAX_VALUE);
shortArrayFS.set(1, (short) (Short.MAX_VALUE - 1));
shortArrayFS.set(2, (short) (Short.MAX_VALUE - 2));
shortArrayFS.set(3, (short) (Short.MAX_VALUE - 3));
shortArrayFS.set(4, (short) (Short.MAX_VALUE - 4));
LongArrayFS longArrayFS = cas.createLongArrayFS(5);
longArrayFS.set(0, Long.MAX_VALUE);
longArrayFS.set(1, Long.MAX_VALUE - 1);
longArrayFS.set(2, Long.MAX_VALUE - 2);
longArrayFS.set(3, Long.MAX_VALUE - 3);
longArrayFS.set(4, Long.MAX_VALUE - 4);
DoubleArrayFS doubleArrayFS = cas.createDoubleArrayFS(5);
doubleArrayFS.set(0, Double.MAX_VALUE);
doubleArrayFS.set(1, Double.MIN_VALUE);
doubleArrayFS.set(2, Double.parseDouble("1.5555"));
doubleArrayFS.set(3, Double.parseDouble("99.000000005"));
doubleArrayFS.set(4, Double.parseDouble("4.44444444444444444"));
// set features of fs
fs.setStringValue(stringFeature, "aaaaaaa");
fs.setFloatValue(floatFeature, (float) 99.99);
fs.setFeatureValue(intArrayFeature, intArrayFS);
fs.setFeatureValue(floatArrayFeature, floatArrayFS);
fs.setFeatureValue(stringArrayFeature, strArrayFS);
// fs.setByteValue(byteFeature, Byte.MAX_VALUE);
fs.setByteValue(byteFeature, (byte) 'z');
fs.setFeatureValue(byteArrayFeature, byteArrayFS);
fs.setBooleanValue(booleanFeature, true);
fs.setFeatureValue(booleanArrayFeature, boolArrayFS);
fs.setShortValue(shortFeature, Short.MIN_VALUE);
fs.setFeatureValue(shortArrayFeature, shortArrayFS);
fs.setLongValue(longFeature, Long.MIN_VALUE);
fs.setFeatureValue(longArrayFeature, longArrayFS);
fs.setDoubleValue(doubleFeature, Double.MAX_VALUE);
fs.setFeatureValue(doubleArrayFeature, doubleArrayFS);
cas.getIndexRepository().addFS(fs);
}
@Override
public FloatArrayFS createFloatArrayFS(int length) {
checkArrayPreconditions(length);
return new FloatArray(getTypeSystemImpl().floatArrayType, this, length);
}
public static Object getDebugLogicalStructure_FeatureStructure(FeatureStructure fs) {
if (fs instanceof StringArrayFS) {
return ((StringArrayFS) fs).toArray();
}
if (fs instanceof FloatArrayFS) {
return ((FloatArrayFS) fs).toArray();
}
if (fs instanceof IntArrayFS) {
return ((IntArrayFS) fs).toArray();
}
if (fs instanceof ArrayFS) {
return ((ArrayFS) fs).toArray();
}
CASImpl cas = (CASImpl) fs.getCAS();
TypeSystem ts = cas.getTypeSystem();
Type fsType = fs.getType();
if (ts.subsumes(ts.getType("uima.cas.FloatList"), fsType)) {
return (floatListToArray(fs));
}
if (ts.subsumes(ts.getType("uima.cas.IntegerList"), fsType)) {
return (integerListToArray(fs));
}
if (ts.subsumes(ts.getType("uima.cas.StringList"), fsType)) {
return (stringListToArray(fs));
}
if (ts.subsumes(ts.getType("uima.cas.FSList"), fsType)) {
return (fsListToArray(fs));
}
DebugNameValuePair[] result;
String typeName = fsType.getName();
List<Feature> features = fsType.getFeatures();
int nbrFeats = features.size();
boolean isAnnotation = false;
boolean isJCasClass = false;
if (fs.getClass().getName().equals(typeName)) { // true for JCas cover classes
isJCasClass = true;
}
if (ts.subsumes(cas.getAnnotationType(), fsType)) {
isAnnotation = true;
}
result = new DebugNameValuePair[(isJCasClass ? 0 : 1) // slot for type name if not JCas
+ (isAnnotation ? 3 : nbrFeats) // annotations have 4 slot display
];
int i = 0;
if (!isJCasClass) {
result[i++] = new DebugNameValuePair("CasType", typeName);
}
if (isAnnotation) {
DebugNameValuePair[] featResults = new DebugNameValuePair[nbrFeats];
fillFeatures(featResults, 0, fs, features);
result[i++] = new DebugNameValuePair("Features", featResults);
result[i++] = new DebugNameValuePair("Covered Text", ((AnnotationFS) fs).getCoveredText());
result[i++] = new DebugNameValuePair("SubAnnotations", new UnexpandedFeatureStructures(
(AnnotationFS) fs));
} else {
fillFeatures(result, isJCasClass ? 0 : 1, fs, features);
}
return result;
}
private FloatArrayFS createFloatArrayFS(CAS c, int length) {
return (FloatArrayFS) createArray(c, ((CASImpl)c).getTypeSystemImpl().floatArrayType, length);
}
private FeatureStructure createExampleFS(CAS parmCas) throws Exception {
// Create a view
CAS englishView = parmCas.createView("EnglishDocument");
// Set the document text
englishView.setDocumentText("this beer is good");
// create an FS of exampleType and index it
AnnotationFS fs = englishView.createAnnotation(exampleType, 1, 5);
// create Array FSs
StringArrayFS strArrayFS = parmCas.createStringArrayFS(5);
strArrayFS.set(0, "zzzzzz");
strArrayFS.set(1, "yyyyyy");
strArrayFS.set(2, "xxxxxx");
strArrayFS.set(3, "wwwwww");
strArrayFS.set(4, "vvvvvv");
IntArrayFS intArrayFS = parmCas.createIntArrayFS(5);
intArrayFS.set(0, Integer.MAX_VALUE);
intArrayFS.set(1, Integer.MAX_VALUE - 1);
intArrayFS.set(2, 42);
intArrayFS.set(3, Integer.MIN_VALUE + 1);
intArrayFS.set(4, Integer.MIN_VALUE);
FloatArrayFS floatArrayFS = parmCas.createFloatArrayFS(5);
floatArrayFS.set(0, Float.MAX_VALUE);
floatArrayFS.set(1, (float) (Float.MAX_VALUE / 1000.0));
floatArrayFS.set(2, 42);
floatArrayFS.set(3, (float) (Float.MIN_VALUE * 1000.0));
floatArrayFS.set(4, Float.MIN_VALUE);
ByteArrayFS byteArrayFS = parmCas.createByteArrayFS(5);
byteArrayFS.set(0, (byte) 8);
byteArrayFS.set(1, (byte) 16);
byteArrayFS.set(2, (byte) 64);
byteArrayFS.set(3, (byte) 128);
byteArrayFS.set(4, (byte) 255);
BooleanArrayFS boolArrayFS = parmCas.createBooleanArrayFS(20);
boolean val = false;
for (int i = 0; i < 20; i++) {
boolArrayFS.set(i, val = !val);
}
ShortArrayFS shortArrayFS = parmCas.createShortArrayFS(5);
shortArrayFS.set(0, Short.MAX_VALUE);
shortArrayFS.set(1, (short) (Short.MAX_VALUE - 1));
shortArrayFS.set(2, (short) (Short.MAX_VALUE - 2));
shortArrayFS.set(3, (short) (Short.MAX_VALUE - 3));
shortArrayFS.set(4, (short) (Short.MAX_VALUE - 4));
LongArrayFS longArrayFS = parmCas.createLongArrayFS(5);
longArrayFS.set(0, Long.MAX_VALUE);
longArrayFS.set(1, Long.MAX_VALUE - 1);
longArrayFS.set(2, Long.MAX_VALUE - 2);
longArrayFS.set(3, Long.MAX_VALUE - 3);
longArrayFS.set(4, Long.MAX_VALUE - 4);
DoubleArrayFS doubleArrayFS = parmCas.createDoubleArrayFS(5);
doubleArrayFS.set(0, Double.MAX_VALUE);
doubleArrayFS.set(1, Double.MIN_VALUE);
doubleArrayFS.set(2, Double.parseDouble("1.5555"));
doubleArrayFS.set(3, Double.parseDouble("99.000000005"));
doubleArrayFS.set(4, Double.parseDouble("4.44444444444444444"));
// set features of fs
fs.setStringValue(stringFeature, "aaaaaaa");
fs.setFloatValue(floatFeature, (float) 99.99);
fs.setFeatureValue(intArrayFeature, intArrayFS);
fs.setFeatureValue(floatArrayFeature, floatArrayFS);
fs.setFeatureValue(stringArrayFeature, strArrayFS);
// fs.setByteValue(byteFeature, Byte.MAX_VALUE);
fs.setByteValue(byteFeature, (byte) 'z');
fs.setFeatureValue(byteArrayFeature, byteArrayFS);
fs.setBooleanValue(booleanFeature, true);
fs.setFeatureValue(booleanArrayFeature, boolArrayFS);
fs.setShortValue(shortFeature, Short.MIN_VALUE);
fs.setFeatureValue(shortArrayFeature, shortArrayFS);
fs.setLongValue(longFeature, Long.MIN_VALUE);
fs.setFeatureValue(longArrayFeature, longArrayFS);
fs.setDoubleValue(doubleFeature, Double.MAX_VALUE);
fs.setFeatureValue(doubleArrayFeature, doubleArrayFS);
englishView.getIndexRepository().addFS(fs);
return fs;
}
private int compareArrayFSs(TOP arrayFS1fs, Feature feat1, TOP arrayFS2fs, Feature feat2, Set<TOP> visited) {
CommonArrayFS arrayFS1 = (CommonArrayFS)arrayFS1fs.getFeatureValue(feat1);
CommonArrayFS arrayFS2 = (CommonArrayFS)arrayFS2fs.getFeatureValue(feat2);
if (null == arrayFS1 && null == arrayFS2)return 0; // are equal
if (null == arrayFS1) return chkEqual(-1, "Array FS1 is null, but Array FS2 is not");
if (null == arrayFS2) return chkEqual(-1, "Array FS2 is null, but Array FS1 is not");
int r, len;
if (0 != (r = Integer.compare(len = arrayFS1.size(), arrayFS2.size()))) {
return chkEqual(r, "ArrayFSs are different sizes, fs1 size is %d, fs2 size is %d", arrayFS1.size(), arrayFS2.size());
}
// are same size
r = validateSameType(arrayFS1, arrayFS2);
if (0 != r) return r;
switch(getArrayType(arrayFS1)) {
case FS:
for (int j = 0; j < len; j++) {
if (0 != (r = compare1((TOP)((FSArray)arrayFS1).get(j), (TOP)((FSArray)arrayFS2).get(j), visited))) return r;
}
break;
case BOOLEAN:
for (int j = 0; j < len; j++) {
if (0 != (r = compBoolean(((BooleanArrayFS)arrayFS1).get(j), ((BooleanArrayFS)arrayFS2).get(j)))) return r;
}
break;
case BYTE:
for (int j = 0; j < len; j++) {
if (0 != (r = compLong(((ByteArrayFS)arrayFS1).get(j), ((ByteArrayFS)arrayFS2).get(j)))) return r;
}
break;
case SHORT:
for (int j = 0; j < len; j++) {
if (0 != (r = compLong(((ShortArrayFS)arrayFS1).get(j), ((ShortArrayFS)arrayFS2).get(j)))) return r;
}
break;
case INT:
for (int j = 0; j < len; j++) {
if (0 != (r = compLong(((IntArrayFS)arrayFS1).get(j), ((IntArrayFS)arrayFS2).get(j)))) return r;
}
break;
case LONG:
for (int j = 0; j < len; j++) {
if (0 != (r = compLong(((LongArrayFS)arrayFS1).get(j), ((LongArrayFS)arrayFS2).get(j)))) return r;
}
break;
case FLOAT:
for (int j = 0; j < len; j++) {
if (0 != (r = compDouble(((FloatArrayFS)arrayFS1).get(j), ((FloatArrayFS)arrayFS2).get(j)))) return r;
}
break;
case DOUBLE:
for (int j = 0; j < len; j++) {
if (0 != (r = compDouble(((DoubleArrayFS)arrayFS1).get(j), ((DoubleArrayFS)arrayFS2).get(j)))) return r;
}
break;
case STRING:
for (int j = 0; j < len; j++) {
if (0 != (r = compStr(((StringArrayFS)arrayFS1).get(j), ((StringArrayFS)arrayFS2).get(j)))) {
return chkEqual(r, "String miscompare, s1 = %s, s2 = %s", ((StringArrayFS)arrayFS1).get(j), ((StringArrayFS)arrayFS2).get(j));
}
}
break;
}
return 0; // all were equal
}
public FloatArrayFS createFloatArrayFS(int length) throws CASRuntimeException {
return originalCAS.createFloatArrayFS(length);
}