Java Code Examples for org.apache.uima.cas.FeatureStructure#setByteValue()

public static void setFeature(FeatureStructure aFS, String aFeature, byte... aValue) {
  Feature feat = getMandatoryFeature(aFS, aFeature);
  if (feat.getRange().isPrimitive()) {
    requireSingleValue(feat, aValue);
    aFS.setByteValue(feat, aValue[0]);
  }
  else if (aValue == null) {
    aFS.setFeatureValue(feat, null);
  }
  else {
    aFS.setFeatureValue(feat, createByteArrayFS(aFS.getCAS(), aValue));
  }
}
 

private FeatureStructure makeAkof(Random r) {
  FeatureStructure fs = createFS(cas, akof);
  if (includeUid) fs.setIntValue(akofUid, aint.getAndAdd(1));
  fs.setBooleanValue(akofBoolean, r.nextBoolean());
  fs.setByteValue(akofByte, (byte) r.nextInt());
  fs.setShortValue(akofShort, (short) r.nextInt());
  fs.setIntValue(akofInt, r.nextInt());
  fs.setFloatValue(akofFloat, r.nextFloat());
  fs.setLongValue(akofLong, r.nextLong());
  fs.setDoubleValue(akofDouble, r.nextDouble());
  fs.setStringValue(akofString, randomString(r));
  fs.setFeatureValue(akofFs, fs);

  fs.setFeatureValue(akofAint, randomIntA(r));
  fs.setFeatureValue(akofAfs, createArrayFS(cas, 1));
  fs.setFeatureValue(akofAfloat, randomFloatA(r));
  fs.setFeatureValue(akofAdouble, randomDoubleA(r));
  fs.setFeatureValue(akofAlong, randomLongA(r));
  fs.setFeatureValue(akofAshort, randomShortA(r));
  fs.setFeatureValue(akofAbyte, randomByteA(r));
  fs.setFeatureValue(akofAboolean, createBooleanArrayFS(cas, 2));
  fs.setFeatureValue(akofAstring, randomStringA(r));

  if (isKeep) {
    ((TOP)fs).addToIndexes();
  }
  return fs;
}
 

private FeatureStructure createFs(Type type, int i, int j) {
  FeatureStructure f = cas.createFS(type);
  f.setIntValue(type.getFeatureByBaseName("used"), i);
  f.setShortValue(type.getFeatureByBaseName("usedShort"), (short) i);
  f.setByteValue(type.getFeatureByBaseName("usedByte"), (byte) i);
  f.setBooleanValue(type.getFeatureByBaseName("usedBoolean"), i == 0 ? false : true);
  f.setStringValue(type.getFeatureByBaseName("usedString"), Integer.toString(i));
  f.setLongValue(type.getFeatureByBaseName("usedLong"), i);
  f.setDoubleValue(type.getFeatureByBaseName("usedDouble"), i);

  f.setIntValue(type.getFeatureByBaseName("ignored"), j);
  return f;
}
 

private void maybeSetByte(FeatureStructure fs, TTypeSystem m, byte value) {
  Feature f = m.getFeature(fs, "Byte");
  if (f != null) {
    fs.setByteValue(f, value);
  }
}
 

/** Test basic blob serialization
 */
public void testBlob() throws Exception {

  /*
   * Test that FS, indexes and strings work after repeated blob serialization
   * For each iteration, add two new FS, serialize and test all created so
   * The first FS sets the string feature using standard API => goes into stringlist
   * The second FS sets the string feature using lowlevel API => goes into stringheap 
   * 
   * Throw in tests of the byte, short and long heaps as well
   * 
   */
String testString = "testString";
cas.reset();
LowLevelCAS ll_cas = cas.getLowLevelCAS();
FSIndexRepository ir = cas.getIndexRepository();
int ll_strfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theStringFeature);
int ll_bytefeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theByteFeature);
int ll_shortfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theShortFeature);
int ll_bytearrayfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theByteArrayFeature);
int ll_shortarrayfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theShortArrayFeature);
int ll_longfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theLongFeature);

for (int cycle = 0; cycle < 10; cycle +=2 ) {
  FeatureStructure newFS1 = cas.createFS(theTypeType); 
  newFS1.setIntValue(startFeature, cycle);
  newFS1.setIntValue(endFeature, cycle+1);
  // set string using normal string feature create
  newFS1.setStringValue(theStringFeature, testString);
  newFS1.setByteValue(theByteFeature, (byte)cycle);
  newFS1.setShortValue(theShortFeature, (short)cycle);
  newFS1.setLongValue(theLongFeature, (long)cycle);
  ByteArrayFS newBA1 = cas.createByteArrayFS(1); 
  ShortArrayFS newSA1 = cas.createShortArrayFS(1); 
  newBA1.set(0, (byte)cycle);
  newSA1.set(0, (short)cycle);
  newFS1.setFeatureValue(theByteArrayFeature, newBA1);
  newFS1.setFeatureValue(theShortArrayFeature, newSA1);
  ir.addFS(newFS1);

  FeatureStructure newFS2 = cas.createFS(theTypeType);
  ByteArrayFS newBA2 = cas.createByteArrayFS(1);
  ShortArrayFS newSA2 = cas.createShortArrayFS(1); 
  newFS2.setIntValue(startFeature, cycle+1);
  newFS2.setIntValue(endFeature, cycle+2);
  ir.addFS(newFS2);
  CASImpl ci = (CASImpl) cas;
  ci.setId2FSsMaybeUnconditionally(newFS2, newBA2, newSA2);
  // set string using lowlevel string create API
  final int llfs2 = ll_cas.ll_getFSRef(newFS2);
  final int llba2 = ll_cas.ll_getFSRef(newBA2);
  final int llsa2 = ll_cas.ll_getFSRef(newSA2);
  
  ll_cas.ll_setCharBufferValue(llfs2, ll_strfeatcode,
          testString.toCharArray(), 0, testString.length());
  ll_cas.ll_setByteValue(llfs2, ll_bytefeatcode, (byte)(cycle+1));
  ll_cas.ll_setShortValue(llfs2, ll_shortfeatcode, (short)(cycle+1));
  ll_cas.ll_setLongValue(llfs2, ll_longfeatcode, (long)(cycle+1));
  ll_cas.ll_setByteArrayValue(llba2, 0, (byte)(cycle+1));
  ll_cas.ll_setShortArrayValue(llsa2, 0, (short)(cycle+1));
  newFS2.setFeatureValue(theByteArrayFeature, newBA2);
  newFS2.setFeatureValue(theShortArrayFeature, newSA2);
  ir.addFS(newFS2);

  ByteArrayOutputStream fos = new ByteArrayOutputStream();
  Serialization.serializeCAS(cas, fos);
    cas.reset();
  ByteArrayInputStream fis = new ByteArrayInputStream(fos.toByteArray());
  Serialization.deserializeCAS(cas, fis);

  FSIndex<AnnotationFS> idx = cas.getAnnotationIndex(theTypeType);
  FSIterator<AnnotationFS> iter = idx.iterator();
  for (int tc = 0; tc < cycle + 1; tc++) {
    FeatureStructure testFS = iter.get();
    iter.moveToNext();
    assertTrue(tc == testFS.getIntValue(startFeature));
    assertTrue(testString.equals(testFS.getStringValue(theStringFeature)));
    assertTrue(tc == testFS.getByteValue(theByteFeature));
    assertTrue(tc == testFS.getShortValue(theShortFeature));
    assertTrue(tc == testFS.getLongValue(theLongFeature));
    ByteArrayFS ba = (ByteArrayFS)testFS.getFeatureValue(theByteArrayFeature);
    assertTrue(tc == ba.get(0));
    ShortArrayFS sa = (ShortArrayFS)testFS.getFeatureValue(theShortArrayFeature);
    assertTrue(tc == sa.get(0));
  }
  }  
}
 

private FeatureStructure setAllValues(int v) throws CASException {
  cas = (CASImpl) cas.getView(CAS.NAME_DEFAULT_SOFA);  // create the default initial view sofa.
  JCas jcas = cas.getJCas();
  boolean s1 = v == 0;
  boolean s2 = v == 1;
  FeatureStructure fs = cas.createFS(allTypesType);
  cas.addFsToIndexes(fs);

  FeatureStructure fs2 = cas.createFS(allTypesType);
  
  fs.setBooleanValue(allTypesType.getFeatureByBaseName("aBoolean"), s1 ? true : false);
  fs.setByteValue   (allTypesType.getFeatureByBaseName("aByte"), s1 ? (byte) -117 : (byte) 0);
  fs.setShortValue  (allTypesType.getFeatureByBaseName("aShort"), s1 ? (short) -112 : (short) 0);
  fs.setIntValue    (allTypesType.getFeatureByBaseName("aInteger"), s1 ? 0 : 1);
  fs.setLongValue   (allTypesType.getFeatureByBaseName("aLong"), s2 ? 4321 : 1234);
  fs.setFloatValue  (allTypesType.getFeatureByBaseName("aFloat"), s1 ?  1.3F : Float.NaN);
  fs.setDoubleValue (allTypesType.getFeatureByBaseName("aDouble"), s2 ? Float.NEGATIVE_INFINITY : 2.6);
  fs.setStringValue (allTypesType.getFeatureByBaseName("aString"),  "some \"String\"");
  fs.setFeatureValue(allTypesType.getFeatureByBaseName("aFS"),  fs2);
  
  FeatureStructure fsAboolean = cas.createBooleanArrayFS(s1 ? 1 : 0);
  ByteArray fsAbyte    = new ByteArray(jcas, s1 ? 2 : 0);
  if (s1) {
    fsAbyte.set(0, (byte) 15);
    fsAbyte.set(1,  (byte) 0xee);
  }
  FeatureStructure fsAshort   = cas.createShortArrayFS(s2 ? 2 : 0);
  FeatureStructure fsAstring  = cas.createStringArrayFS(s1 ? 1 : 0);
  
  fsa1 = cas.createFS(allTypesType);
  fsa2 = cas.createFS(allTypesType);
  fsa3 = cas.createFS(allTypesType);
  
  fsaa = new FSArray(jcas, 3);
  fsaa.set(0, fsa1);
  fsaa.set(1, fsa2);
  fsaa.set(2, fsa3);;
  
  FeatureStructure fsMrAboolean = cas.createBooleanArrayFS(1);
  FeatureStructure fsMrAbyte    = cas.createByteArrayFS(2);
  FeatureStructure fsMrAshort   = cas.createShortArrayFS(0);
  FeatureStructure fsMrAstring  = cas.createStringArrayFS(1);
  
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayBoolean"), fsAboolean);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayByte"),     fsAbyte);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayShort"),    fsAshort);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayString"),   fsAstring);
  
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayMrBoolean"),  fsMrAboolean);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayMrByte"),     fsMrAbyte);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayMrShort"),    fsMrAshort);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aArrayMrString"),   fsMrAstring);

  
  FeatureStructure fsLinteger0 = cas.createFS(tsi.getType(CAS.TYPE_NAME_EMPTY_INTEGER_LIST));
  
  FeatureStructure fsLstring0  = cas.createFS(tsi.getType(CAS.TYPE_NAME_NON_EMPTY_STRING_LIST));
  FeatureStructure fsLstring1  = cas.createFS(tsi.getType(CAS.TYPE_NAME_EMPTY_STRING_LIST));
  fsLstring0.setStringValue (tsi.getFeatureByFullName(CAS.TYPE_NAME_NON_EMPTY_STRING_LIST + ":head"), "testStr");
  fsLstring0.setFeatureValue (tsi.getFeatureByFullName(CAS.TYPE_NAME_NON_EMPTY_STRING_LIST + ":tail"), fsLstring1);
  
  
  FeatureStructure fsLfs0  = cas.createFS(tsi.getType(CAS.TYPE_NAME_NON_EMPTY_FS_LIST));
  FeatureStructure fsLfs1  = cas.createFS(tsi.getType(CAS.TYPE_NAME_EMPTY_FS_LIST));
  fsLfs0.setFeatureValue (tsi.getFeatureByFullName(CAS.TYPE_NAME_NON_EMPTY_FS_LIST + ":tail"), fsLfs1);
  
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aListInteger"), fsLinteger0);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aListString"), fsLstring0);
  fs.setFeatureValue (allTypesType.getFeatureByBaseName("aListFs"), fsLfs0);
  
  cas.addFsToIndexes(fs);
  return fs;
}