getter for specificType - gets
@generated
@return value of the feature
515372
public String getSpecificType() {
    if (ConceptMention_Type.featOkTst && ((ConceptMention_Type)jcasType).casFeat_specificType == null)
      jcasType.jcas.throwFeatMissing("specificType", "de.julielab.jules.types.ConceptMention");
    return jcasType.ll_cas.ll_getStringValue(addr, ((ConceptMention_Type)jcasType).casFeatCode_specificType);}
1168090
public Object getAttributeValue(FeatureDescriptor feature,
                                    String attributeName) {

        if (feature == null || attributeName == null) {
            return null;
        }

        return feature.getValue(attributeName);
    }
326942
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static int getType(Cursor cursor, String columnName) {
        if (cursor == null) {
            return Cursor.FIELD_TYPE_NULL;
        }

        return cursor.getType(cursor.getColumnIndex(columnName));
    }
727653
public List<abstractTiffType> getDescriptiveValueObject() {
    Tag tag = TiffTags.getTag(id);
    if (tag != null) {
      if (tag.hasReadableDescription()){
        String desc = this.toString();
        String tagDescription = tag.getTextDescription(toString());
        if (tagDescription != null){
          desc = tagDescription;
        }
        return Arrays.asList(new Text(desc));
      } else {
        return getValue();
      }
    }
    return null;
  }
182409
@SuppressWarnings("unchecked")
  protected Class<T> getParameterizedType() {
    Class<T> clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass())
        .getActualTypeArguments()[0];
    return clazz;
  }
321526
@Override
  public <T extends Feature<T>> T get(FeatureType<T> featureType) {
    @SuppressWarnings("unchecked")
    T feature = (T) featuresByType.get(featureType.type());
    if (feature != null) {
      return feature;
    }
    return featureType.testDefault(this);
  }
1074280
public AbstractType<?> getAbstractType() {
        if (abstractType != null) {
            return abstractType;
        }

        try {

            if (validatorKind == Kind.NOT_A_COLLECTION) {
                abstractType = MAP_ABSTRACT_TYPE_CLASS_TO_ABSTRACT_TYPE.get(forName
                        (validatorClassName));

            } else {
                throw new DeepGenericException("Cannot determine collection kind for " + validatorKind);

            }

        } catch (ClassNotFoundException e) {
            throw new DeepGenericException(e);
        }

        return abstractType;
    }
932619
@Pure
	public VisualizationType getVisualizationType() {
		if (this.vizualizationType == null) {
			final AttributeValue val = getAttributeCollection().getAttribute(ATTR_VISUALIZATION_TYPE);
			if (val != null) {
				try {
					this.vizualizationType = val.getJavaObject();
				} catch (Exception e) {
					//
				}
			}
			if (this.vizualizationType == null) {
				this.vizualizationType = VisualizationType.SHAPE_ONLY;
			}
		}
		return this.vizualizationType;
	}
690062
public String getType()
    {
        if ( _propDecl == null || _propDecl.getReturnType() == null )
            return "";
        
        return _propDecl.getReturnType().toString();
    }
287520
public float getValue() {
    if (VariableAssignment_Type.featOkTst && ((VariableAssignment_Type)jcasType).casFeat_value == null)
      jcasType.jcas.throwFeatMissing("value", "ch.epfl.bbp.uima.types.VariableAssignment");
    return jcasType.ll_cas.ll_getFloatValue(addr, ((VariableAssignment_Type)jcasType).casFeatCode_value);}
188323
public static <E> GenericData getDataModelForType(Class<E> type) {
    // Need to check if SpecificRecord first because specific records also
    // implement GenericRecord
    if (SpecificRecord.class.isAssignableFrom(type)) {
      return new SpecificData(type.getClassLoader());
    } else if (IndexedRecord.class.isAssignableFrom(type)) {
      return GenericData.get();
    } else {
      return AllowNulls.get();
    }
  }
493131
public String getValue() {
    if (MMAXAttribute_Type.featOkTst && ((MMAXAttribute_Type)jcasType).casFeat_value == null)
      jcasType.jcas.throwFeatMissing("value", "de.julielab.jules.types.mmax.MMAXAttribute");
    return jcasType.ll_cas.ll_getStringValue(addr, ((MMAXAttribute_Type)jcasType).casFeatCode_value);}
775565
public Class<?> getJavaType() {
		if(javaType==null) {
			javaType=JKTypeMapping.getType(getCode()).getClass();
			if(javaType==null) {
				JK.error("JKType cannot by null, and code not avaiable %s",code);
			}
		}
		return javaType;
	}
315822
public String getAce_type() {
    if (SourceFile_Type.featOkTst && ((SourceFile_Type)jcasType).casFeat_ace_type == null)
      jcasType.jcas.throwFeatMissing("ace_type", "de.julielab.jules.types.ace.SourceFile");
    return jcasType.ll_cas.ll_getStringValue(addr, ((SourceFile_Type)jcasType).casFeatCode_ace_type);}
1237972
public String getAnnotType() {
    if (DictTerm_Type.featOkTst && ((DictTerm_Type)jcasType).casFeat_annotType == null)
      jcasType.jcas.throwFeatMissing("annotType", "ch.epfl.bbp.uima.types.DictTerm");
    return jcasType.ll_cas.ll_getStringValue(addr, ((DictTerm_Type)jcasType).casFeatCode_annotType);}
195214
@Override
    public Type getType() {
        ParameterizedType type = (ParameterizedType) field.getGenericType();
        if (type.getActualTypeArguments()[0] instanceof ParameterizedType) {
            ParameterizedType first = (ParameterizedType) type.getActualTypeArguments()[0];
            return first.getRawType();
        } else {
            return type.getActualTypeArguments()[0];
        }
    }
1250031
public String getUnit() {
    if (Measure_Type.featOkTst && ((Measure_Type)jcasType).casFeat_unit == null)
      jcasType.jcas.throwFeatMissing("unit", "ch.epfl.bbp.uima.types.Measure");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Measure_Type)jcasType).casFeatCode_unit);}