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(); } }
public void newValueType(String domainName, ValueType valueType) { if (domainName == null) { domainName = valueType.getFullname(); } valueType.getBaseType().setDomainName(domainName); checkValueTypeName(domainName); valueTypes.put(domainName, valueType); }
protected ValueType getExternalizationType(ValueType vt) { while (!(vt.isBuiltin() || vt.isEnum())) { List<ExternalizationElement> extElems = vt.getExternalizationElements(); if (extElems.size() != 1) { // Value Types with more than one externalization element // are externalized to Json return jsonElementVt; } ExternalizationElement extElem = extElems.get(0); vt = extElem.getType(); } return vt; }
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 internalizationMethodName = "new " + vt.getFullname(); } else if (!internalizationMethodName.contains(".")) { // static method in the same class internalizationMethodName = vt.getFullname() + "." + internalizationMethodName; print(out, "(obj == null) ? null : "); print(out, "(" + vt.getFullname() + ")"); print(out, internalizationMethodName + "("); List<ExternalizationElement> extElems = vt.getExternalizationElements(); if (extElems.size() == 1) { ExternalizationElement extElem = extElems.get(0); ValueType extElemVt = extElem.getType(); if (extElemVt.isBuiltin() || extElemVt.isEnum()) { print(out, "obj"); } else { if (extElemVt.isBuiltin() || extElemVt.isEnum()) { print(out, "JsonConverter.get"); print(out, capitalize(extElem.getType().getDomainName())); print(out, "FromJson(obj.getAsJsonObject().get(\"");; print(out, makePrettySlotName(extElem));
public static String getJdbcTypeFor(DomainModel model, String valueType) { ValueType vt = model.findValueType(valueType); String jdbcType = null; if (vt.isEnum()) { jdbcType = "VARCHAR"; } else if (vt.isBuiltin()) { jdbcType = BUILT_IN_JDBC_MAP.get(valueType); } else { List<ExternalizationElement> extElems = vt.getExternalizationElements(); if (extElems.size() != 1) { return BUILT_IN_JDBC_MAP.get("JsonElement"); } jdbcType = getJdbcTypeFor(model, extElems.get(0).getType().getDomainName()); } if (jdbcType == null) { throw new Error("Couldn't find a JDBC type for the value type " + valueType); } return jdbcType; } }
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); } } }
public String getTypeName() { return type.getFullname(); }
protected String getSqlTypeName(ValueType vt) { ValueType extType = getExternalizationType(vt); String toSqlMethodName = "getValueFor" + (extType.isEnum() ? "Enum" : extType.getDomainName()); for (Method m : ToSqlConverter.class.getDeclaredMethods()) { if (m.getName().equals(toSqlMethodName)) { return m.getReturnType().getName(); } } throw new Error("Something's wrong. Couldn't find the appropriate base value type."); }
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, "\")"); }
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); }
public boolean isEnumType(String valueTypeName) { ValueType vt = findValueType(valueTypeName); return ((vt != null) && vt.isEnum()); }
public static String makeSafeValueTypeName(ValueType vt) { return vt.getDomainName().replace('.', '$'); }
public final void internalizationClause(AST _t, DomainModel model, ValueType valueType ) throws RecognitionException { AST internalizationClause_AST_in = (_t == ASTNULL) ? null : (AST)_t; String methodName; AST __t51 = _t; AST tmp23_AST_in = (AST)_t; match(_t,INTERNALIZATION_CLAUSE); _t = _t.getFirstChild(); methodName=identifier(_t); _t = _retTree; valueType.getBaseType().setInternalizationMethodName(methodName); _t = __t51; _t = _t.getNextSibling(); _retTree = _t; }
public static boolean isNullableType(ValueType vt) { String vtFullName = vt.getFullname(); for (String nonNullableType : NON_NULLABLE_TYPES) { if (nonNullableType.equals(vtFullName)) { return false; } } return true; }
protected static void updateFields(final DomainModel domainModel, final ClassDescriptor classDescriptor, final DomainClass domClass, final Map<String, ClassDescriptor> ojbMetadata, final Class<?> persistentFieldClass) throws Exception { DomainEntity domEntity = domClass; int fieldID = 1; addPrimaryFieldDescriptor(domainModel, "oid", "long", fieldID++, classDescriptor, persistentFieldClass); // write the domainMetaObject for all domain objects addFieldDescriptor(domainModel, "oidDomainMetaObject", "Long", fieldID++, classDescriptor, persistentFieldClass); while (domEntity instanceof DomainClass) { DomainClass dClass = (DomainClass) domEntity; Iterator<Slot> slots = dClass.getSlots(); while (slots.hasNext()) { Slot slot = slots.next(); String slotName = slot.getName(); String slotType = slot.getSlotType().getDomainName(); addFieldDescriptor(domainModel, slotName, slotType, fieldID++, classDescriptor, persistentFieldClass); } for (Role role : dClass.getRoleSlotsList()) { String roleName = role.getName(); if ((role.getMultiplicityUpper() == 1) && (roleName != null)) { String foreignOidField = "oid" + StringUtils.capitalize(roleName); addFieldDescriptor(domainModel, foreignOidField, "Long", fieldID++, classDescriptor, persistentFieldClass); } } domEntity = dClass.getSuperclass(); } }
public final void externalizationElement(AST _t, DomainModel model, ValueType valueType ) throws RecognitionException { AST externalizationElement_AST_in = (_t == ASTNULL) ? null : (AST)_t; String methodName; ValueType elemType; AST __t49 = _t; AST tmp24_AST_in = (AST)_t; match(_t,EXTERNALIZATION_ELEMENT); _t = _t.getFirstChild(); elemType=typeSpec(_t,model, false); _t = _retTree; methodName=identifier(_t); _t = _retTree; ExternalizationElement elem = new ExternalizationElement(elemType, methodName); valueType.getBaseType().addExternalizationElement(elem); _t = __t49; _t = _t.getNextSibling(); _retTree = _t; }
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(); }
protected String applyExternalizerTo(ExternalizationElement extElem, String expr) { String extMethodName = extElem.getMethodName(); // parametric types require cast, so we always cast String cast = "(" + extElem.getType().getFullname() + ")"; return (extMethodName.contains(".")) ? cast + extMethodName + "(" + expr + ")" : cast + expr + "." + extMethodName + "()"; }
vt = new ParamValueType(vt.getBaseType(), "<" + typeArgs + ">"); break;