How to use

ValueTypeSerializationGenerator

in

pt.ist.fenixframework.dml

protected void generateValueTypeSerialization(ValueType vt) {
  onNewline(out);
  printMethod(out, "public static final", getSerializedFormTypeName(vt), SERIALIZATION_METHOD_PREFIX
      + makeSafeValueTypeName(vt), makeArg(vt.getFullname(), "obj"));
  startMethodBody(out);
  if (vt.getExternalizationElements().size() == 1) {
    print(out, "return (obj == null) ? null : ");
    ExternalizationElement extElem = vt.getExternalizationElements().get(0);
    ValueType extElemVt = extElem.getType();
    print(out, applyExternalizationIfRequired(applyExternalizerTo(extElem, "obj"), extElemVt));
  } else {
    println(out, "if (obj == null) return null;");
    println(out, "JsonObject json = new JsonObject();");
    for (ExternalizationElement extElem : vt.getExternalizationElements()) {
      print(out, "json.add(\"");
      print(out, makePrettySlotName(extElem));
      print(out, "\", JsonConverter.getJsonFor(");
      print(out, applyExternalizationIfRequired(applyExternalizerTo(extElem, "obj"), extElem.getType()));
      print(out, "));");
      newline(out);
    }
    print(out, "return json");
  }
  print(out, ";");
  endMethodBody(out);
}

protected void generateValueTypeDeSerialization(ValueType vt) {
  onNewline(out);
  printMethod(out, "public static final", vt.getFullname(), DESERIALIZATION_METHOD_PREFIX + makeSafeValueTypeName(vt),
      makeArg(getSerializedFormTypeName(vt), "obj"));
  startMethodBody(out);
  String internalizationMethodName = vt.getInternalizationMethodName();
  if (internalizationMethodName == null) { // class constructor
  print(out, "return ");
  if (DomainModel.isNullableTypeFullName(getSerializedFormTypeName(vt))) {
    print(out, "(obj == null) ? null : ");
  print(out, "(" + vt.getFullname() + ")");
  print(out, internalizationMethodName + "(");
    ValueType extElemVt = extElem.getType();
    if (extElemVt.isBuiltin() || extElemVt.isEnum()) {
      print(out, "obj");
    } else {
      print(out, DESERIALIZATION_METHOD_PREFIX + makeSafeValueTypeName(extElemVt) + "(obj)");
        newline(out);
        firstArg = false;
      } else {
        println(out, ",");
        print(out, "JsonConverter.get");
        print(out, capitalize(extElem.getType().getDomainName()));
        print(out, "FromJson(obj.getAsJsonObject().get(\"");;
        print(out, makePrettySlotName(extElem));

@Override
public void generateCode() {
  // create the ValueTypeSerializationGenerator before starting the "standard" generation.
  File file = new File(getBaseDirectoryFor(SERIALIZER_CLASS_PACKAGE), SERIALIZER_CLASS_SIMPLE_NAME + ".java");
  try {
    file.getParentFile().mkdirs();
    this.out = new PrintWriter(new FileWriter(file), true);
  } catch (java.io.IOException ioe) {
    throw new Error("Can't open file" + file);
  }
  generateFilePreamble(SERIALIZER_CLASS_PACKAGE, this.out);
  newline(out);
  println(out, "@SuppressWarnings(\"all\")");
  printWords(out, "public", "final", "class", SERIALIZER_CLASS_SIMPLE_NAME);
  newBlock(out);
  generateValueTypeSerializations();
  closeBlock(out);
}

protected void generateValueTypeSerializations() {
  for (ValueType vt : getDomainModel().getAllValueTypes()) {
    if (!(vt.isBuiltin() || vt.isEnum())) {
      println(out, "");
      print(out, "// VT: " + vt.getDomainName() + " serializes as " + getSerializedFormTypeName(vt));
      generateValueTypeSerialization(vt);
      generateValueTypeDeSerialization(vt);
    }
  }
}

protected String getExternalizationExpression(ValueType vt) {
  StringBuilder expression = new StringBuilder();
  // Use the ValueTypeSerializer class to get the final type, 
  // and then convert it to the correct SQL type
  expression.append(TO_SQL_CONVERTER_CLASS);
  expression.append(".getValueFor");
  if (vt.isEnum()) {
    expression.append("Enum(value)");
    return expression.toString();
  }
  expression.append(ValueTypeSerializationGenerator.getSerializedFormTypeName(vt, true));
  expression.append("(");
  if (vt.isBuiltin() || vt.isEnum()) {
    expression.append("value)");
  } else {
    expression.append(ValueTypeSerializationGenerator.SERIALIZER_CLASS_SIMPLE_NAME);
    expression.append(".");
    expression.append(ValueTypeSerializationGenerator.SERIALIZATION_METHOD_PREFIX);
    expression.append(ValueTypeSerializationGenerator.makeSafeValueTypeName(vt));
    expression.append("(value))");
  }
  return expression.toString();
}

protected String getRsReaderExpression(ValueType vt) {
  if (vt.isBuiltin() || vt.isEnum()) {
    return "value";
  }
  StringBuilder builder = new StringBuilder();
  builder.append(ValueTypeSerializationGenerator.SERIALIZER_CLASS_SIMPLE_NAME);
  builder.append(".");
  builder.append(ValueTypeSerializationGenerator.DESERIALIZATION_METHOD_PREFIX);
  builder.append(ValueTypeSerializationGenerator.makeSafeValueTypeName(vt));
  builder.append("(value)");
  return builder.toString();
}

public static String getSerializedFormTypeName(ValueType vt) {
  return getSerializedFormTypeName(vt, false);
}

/**
 * Generate the backend-specific code for the domain model.
 */
public void generateCode() {
  // used by the value-type generator
  ValueTypeSerializationGenerator valueTypeGenerator = new ValueTypeSerializationGenerator(compArgs, domainModel);
  valueTypeGenerator.generateCode();
  generateClasses(getDomainModel().getClasses());
  generateBackEndId();
}

protected void generateInfinispanGetterBody(Slot slot, PrintWriter out, String cacheGetMethod) {
  generateGetterDAPStatement(dC, slot.getName(), slot.getTypeName(), out);//DAP read stats update statement
  println(out,
      "Object obj = InfinispanBackEnd.getInstance()." + cacheGetMethod + "(getOid().getFullId() + \":" + slot.getName()
          + "\");");
  String defaultValue;
  PrimitiveToWrapperEntry wrapperEntry = findWrapperEntry(slot.getTypeName());
  if (wrapperEntry != null) { // then it is a primitive type
    defaultValue = wrapperEntry.defaultPrimitiveValue;
  } else {
    defaultValue = "null";
  }
  println(out, "if (obj == null || obj instanceof Externalization.NullClass) { return " + defaultValue + "; }");
  String returnExpression = "return (" + getReferenceType(slot.getTypeName()) + ")";
  ValueType vt = slot.getSlotType();
  if (vt.isBuiltin() || vt.isEnum()) {
    returnExpression += "obj";
  } else {
    returnExpression +=
        VT_DESERIALIZER + ValueTypeSerializationGenerator.makeSafeValueTypeName(vt) + "(("
            + getReferenceType(ValueTypeSerializationGenerator.getSerializedFormTypeName(vt)) + ")obj)";
  }
  returnExpression += ";";
  print(out, returnExpression);
}

protected String applyExternalizationIfRequired(String expr, ValueType vt) {
  if ((vt.isBuiltin() || vt.isEnum())) {
    return expr;
  } else {
    return SERIALIZATION_METHOD_PREFIX + makeSafeValueTypeName(vt) + "(" + expr + ")";
  }
}

public static String getSerializedFormTypeName(ValueType vt, boolean simple) {
  List<ExternalizationElement> extElems = vt.getExternalizationElements();
  if (extElems.size() == 0) { // built-in type do not have externalizers
    return simple ? vt.getDomainName() : vt.getFullname();
  } else if (extElems.size() == 1) {
    // It's just a wrapper.  So, our serialized form is the same as our component's
    return getSerializedFormTypeName(extElems.get(0).getType(), simple);
  } else {
    // Alas, we need a full-blown SerializedForm for this one
    return simple ? JsonElement.class.getSimpleName() : JsonElement.class.getName();
  }
}

protected void generateInfinispanSetterBody(Slot slot, PrintWriter out) {
  generateSetterDAPStatement(dC, slot.getName(), slot.getTypeName(), out);//DAP write stats update statement
  generateSetterTxIntrospectorStatement(slot, out); // TxIntrospector
  onNewline(out);
  String slotName = slot.getName();
  String setterExpression;
  if (findWrapperEntry(slot.getTypeName()) != null) { // then it is a primitive type
    setterExpression = slotName;
  } else {
    setterExpression = "(" + slotName + " == null ? Externalization.NULL_OBJECT : ";
    ValueType vt = slot.getSlotType();
    if (vt.isBuiltin() || vt.isEnum()) {
      setterExpression += slotName;
    } else { // derived value type must be externalized
      setterExpression +=
          VT_SERIALIZER + ValueTypeSerializationGenerator.makeSafeValueTypeName(vt) + "(" + slotName + ")";
    }
    setterExpression += ")";
  }
  print(out, "InfinispanBackEnd.getInstance().cachePut(getOid().getFullId() + \":" + slotName + "\", " + setterExpression
      + ");");
}

protected void printRsReaderExpressions(PrintWriter out, ValueType vt, String colBaseName) {
  print(out, RESULT_SET_READER_CLASS);
  print(out, ".read");
  if (vt.isEnum()) {
    print(out, "Enum(");
    print(out, vt.getFullname());
    print(out, ".class, ");
  } else {
    print(out, ValueTypeSerializationGenerator.getSerializedFormTypeName(vt, true));
    print(out, "(");
  }
  print(out, "rs, \"");
  print(out, colBaseName);
  print(out, "\")");
}