How to use

FieldType

in

org.activityinfo.model.type

public FieldValue get(ResourceId fieldId, FieldType fieldType) {
  FieldValue value = fieldMap.get(fieldId);
  if(value != null && value.getTypeClass() == fieldType.getTypeClass()) {
    return value;
  } else {
    return null;
  }
}

  @Override
  public FieldValue toFieldValue(Object hrdValue) {
    JsonValue element = FormConverter.fromPropertyValue(hrdValue);
    return type.parseJsonValue(element);
  }
};

static ImageResource iconForField(FieldType type) {
  return type.accept(new FieldTypeVisitor<ImageResource>() {
    @Override
    public ImageResource visitAttachment(AttachmentType attachmentType) {

private static FieldValue validateType(FormField field, FieldValue updatedValue) {
  Preconditions.checkNotNull(field);
  if(updatedValue != null) {
    if ( !field.getType().isUpdatable()) {
      throw new InvalidUpdateException(
        format("Field %s ('%s') is a field of type '%s' and its value cannot be set. Found %s",
          field.getId(),
          field.getLabel(),
          field.getType().getTypeClass().getId(),
          updatedValue));
    }
    if (!field.getType().getTypeClass().equals(updatedValue.getTypeClass())) {
      throw new InvalidUpdateException(
        format("Updated value for field %s ('%s') has invalid type. Expected %s, found %s.",
          field.getId(),
          field.getLabel(),
          field.getType().getTypeClass().getId(),
          updatedValue.getTypeClass().getId()));
    }
  }
  return updatedValue;
}

JsonValue fieldValues = jsonObject.get("fieldValues");
for (FormField formField : formClass.getFields()) {
  if(formField.getType().isUpdatable()) {
    if (fieldValues.hasKey(formField.getName())) {
      JsonValue updatedValueElement = fieldValues.get(formField.getName());
      } else {
        try {
          updatedValue = formField.getType().parseJsonValue(updatedValueElement);
        } catch(Exception e) {
          e.printStackTrace();

/**
 * Verify that all required fields are provided for new resources
 */
private static void validateRequiredFields(FormClass formClass, Optional<FormRecord> existingResource, TypedRecordUpdate update) {
  if(!existingResource.isPresent()) {
    for (FormField formField : formClass.getFields()) {
      if (formField.isRequired() &&
        formField.isVisible() &&
        formField.getType().isUpdatable() && !isProvided(formField, existingResource, update)) {
        throw new InvalidUpdateException("Required field '%s' [%s] is missing from record with schema %s",
          formField.getCode(), formField.getId(), formClass.getId().asString());
      }
    }
  }
}

@Override
public String toString() {
  return "FormField{" +
      "id=" + id +
      ", label=" + label +
      ", type=" + type.getTypeClass().getId() +
      '}';
}

@Override
public void set(ResultSet rs) throws SQLException {
  String json = rs.getString(STRING_VALUE_COLUMN);
  if (Strings.isNullOrEmpty(json)) {
    value = null;
  } else {
    value = type.parseJsonValue(parser.parse(json));
  }
}

public static CursorObserver<FieldValue> get(ColumnFactory factory, PendingSlot<ColumnView> result, FieldType type) {
  return type.accept(new ViewBuilderFactory(result, factory));
}

public FieldTypeClass getTypeClass() {
  return field.getType().getTypeClass();
}

public void onNext(RecordObject record) {
  JsonValue jsonValue = record.getField(fieldName);
  if(jsonValue.isJsonNull()) {
    observer.onNext(null);
  } else {
    FieldValue value = fieldType.parseJsonValue(jsonValue);
    observer.onNext(value);
  }
}

public FieldWidget create(FormField field, FieldUpdater updater) {
  return field.getType().accept(new Visitor(field, updater));
}

@Override
public FieldType resolveResultType(List<FieldType> argumentTypes) {
  checkArity(argumentTypes, 3);
  FieldType conditionType = argumentTypes.get(0);
  if(!(conditionType instanceof BooleanType)) {
    throw new ArgumentException(0, "Expected TRUE/FALSE value");
  }
  FieldType trueType = argumentTypes.get(1);
  FieldType falseType = argumentTypes.get(2);
  if(trueType.getTypeClass() != falseType.getTypeClass()) {
    throw new ArgumentException(2, "Must have the same type as the TRUE argument.");
  }
  return trueType;
}

  fieldValue = typeClass.createType().parseJsonValue(Json.parse(textValue));
} catch (JsonException e) {
  LOGGER.severe("Failed to parse indicator " + indicatorId + " with type " + typeClass +

public static BlockManager get(FormField field) {
  return field.getType().accept(new BlockFactory(field));
}

@Override
public FieldType resolveResultType(List<FieldType> argumentTypes) {
  //must be unary or binary function
  if(argumentTypes.size() == 1) {
    if(argumentTypes.get(0) instanceof QuantityType) {
      QuantityType t = (QuantityType) argumentTypes.get(0);
      return new QuantityType().setUnits(t.getUnits());
    } else {
      throw new InvalidTypeException("Not Real Valued Argument");
    }
  } else if(argumentTypes.size() == 2) {
    if(argumentTypes.get(0) instanceof QuantityType &&
        argumentTypes.get(1) instanceof QuantityType) {
      QuantityType t1 = (QuantityType) argumentTypes.get(0);
      QuantityType t2 = (QuantityType) argumentTypes.get(1);
      return new QuantityType().setUnits(applyUnits(t1.getUnits(), t2.getUnits()));
    } else {
      throw new InvalidTypeException("Cannot compare types " +
          argumentTypes.get(0).getTypeClass().getId() + " and " +
          argumentTypes.get(1).getTypeClass().getId());
    }
  } else {
    throw new FormulaSyntaxException("The " + getLabel() + "() function expects exactly 1 or 2 argument(s).");
  }
}

private static FieldValue parseFieldValue(FormField field, JsonValue jsonValue) {
  if(jsonValue.isJsonNull()) {
    return null;
  } else if(field.getType() instanceof EnumType) {
    return parseEnumValue((EnumType)field.getType(), jsonValue);
  } else {
    return field.getType().parseJsonValue(jsonValue);
  }
}

private FieldRenderer buildRenderer(FormTree formTree, FormField field) {
  return field.getType().accept(new FieldTypeVisitor<FieldRenderer>() {
    @Override
    public FieldRenderer visitAttachment(AttachmentType attachmentType) {

private FieldTypeClass findTypeFromSchema(Activity activity, ResourceId fieldId) {
  for (ActivityField activityField : activity.getFields()) {
    if(activityField.getResourceId().equals(fieldId)) {
      return activityField.getFormField().getType().getTypeClass();
    }
  }
  return null;
}

public static TypedFormRecord toTypedFormRecord(FormClass formClass, FormRecord record) {
  TypedFormRecord instance = new TypedFormRecord(ResourceId.valueOf(record.getRecordId()), formClass.getId());
  if (record.getParentRecordId() != null) {
    instance.setParentRecordId(ResourceId.valueOf(record.getParentRecordId()));
  }
  JsonValue fieldsObject = record.getFields();
  for (FormField field : formClass.getFields()) {
    if(fieldsObject.hasKey(field.getName())) {
      JsonValue fieldValue = fieldsObject.get(field.getName());
      if (!fieldValue.isJsonNull()) {
        instance.set(field.getId(), field.getType().parseJsonValue(fieldValue));
      }
    }
  }
  return instance;
}