public static Namespace GetNamespace(this SoalType type, Namespace currentNamespace) { if (type is PrimitiveType) { return(SoalGenerator.XsdNamespace); } if (type is NullableType) { return(GetNamespace(((NullableType)type).InnerType, currentNamespace)); } if (type is ArrayType) { if (((ArrayType)type).InnerType.MId == SoalInstance.Byte.MId) { return(SoalGenerator.XsdNamespace); } else { return(currentNamespace); } } if (type is Enum) { Enum etype = (Enum)type; return(etype.Namespace); } if (type is Struct) { Struct stype = (Struct)type; return(stype.Namespace); } return(null); }
private void CheckXsdNamespace(SoalType type, ISymbol symbol) { if (!type.HasXsdNamespace()) { this.AddDiagnostic(symbol, SoalGeneratorErrorCode.TypeHasNoXsdNamespace); } }
public static bool IsNullable(this SoalType type) { if (type is NonNullableType) { return(false); } if (type is NullableType) { return(true); } if (type is PrimitiveType) { return(((PrimitiveType)type).Nullable); } if (type is ArrayType) { return(true); } if (type is Enum) { return(false); } if (type is Struct) { return(true); } return(false); }
public static string GetEntityMappingString(this Struct me, SoalType field) { Struct property = field as Struct; if (property != null && property.IsEntity()) { // field typed entity is conatied in me string mapping = "@OneToOne"; foreach (Property prop in property.Properties) { SoalType type = prop.Type; if (type.Equals(me)) { return mapping; } ArrayType foraignArray = type as ArrayType; if (foraignArray != null) { if (foraignArray.InnerType.Equals(me)) { return "@ManyToOne"; } } } return mapping; } ArrayType array = field as ArrayType; if (array != null) { Struct innerProperty = array.InnerType as Struct; if (innerProperty != null && innerProperty.IsEntity()) { // I have a list of an entity string mapping = "@OneToMany"; foreach (Property prop in innerProperty.Properties) { SoalType type = prop.Type; if (type.Equals(me)) { return mapping + "(mappedBy=\"" + prop.Name.ToCamelCase() + "\")"; } ArrayType foraignArray = type as ArrayType; if (foraignArray != null) { if (foraignArray.InnerType.Equals(me)) { return "@ManyToMany // TODO add @JoinTable"; } } } return mapping + " // TODO add @JoinColumn"; } } return ""; }
public static bool HasXsdNamespace(this SoalType type) { if (type is PrimitiveType) { return(true); } if (type is NullableType) { return(HasXsdNamespace(((NullableType)type).InnerType)); } if (type is NonNullableType) { return(HasXsdNamespace(((NonNullableType)type).InnerType)); } if (type is ArrayType) { return(HasXsdNamespace(((ArrayType)type).InnerType)); } if (type is Enum) { Enum etype = (Enum)type; return(etype.Namespace != null && etype.Namespace.Uri != null); } if (type is Struct) { Struct stype = (Struct)type; return(stype.Namespace != null && stype.Namespace.Uri != null); } return(false); }
private static void CheckArrayType(SoalType type, IList <Annotation> annotations, HashSet <string> arrayNames, List <ArrayType> arrayTypes) { if (annotations.Any(a => a.Name == SoalAnnotations.Element && !(bool)a.GetPropertyValue(SoalAnnotationProperties.Wrapped))) { return; } if (type is ArrayType) { ArrayType atype = (ArrayType)type; string aname = atype.GetXsdName(); if (atype.InnerType != SoalInstance.Byte && !arrayNames.Contains(aname)) { arrayNames.Add(aname); arrayTypes.Add(atype); } } else if (type is NonNullableType) { ArrayType atype = ((NonNullableType)type).InnerType as ArrayType; if (atype != null) { string aname = atype.GetXsdName(); if (atype.InnerType != SoalInstance.Byte && !arrayNames.Contains(aname)) { arrayNames.Add(aname); arrayTypes.Add(atype); } } } }
private void AnalyseSoalType(Component project, string typeOwnerName, SoalType type) { Struct entity = type as Struct; ArrayType list = type as ArrayType; Symbols.Enum enumtype = type as Symbols.Enum; PrimitiveType primitiv = type as PrimitiveType; if (list != null) { entity = list.InnerType as Struct; string importString = JavaImportConfigHandler.getValue(JavaTypeConfigHandler.SwitchTypeName(list.MMetaClass.Name)); if (importString != null) { string importPackage = importString.Substring(0, importString.LastIndexOf(".")); string importObjectName = importString.Substring(importString.LastIndexOf(".") + 1); AddImport(project.Name, project.Namespace.Name, typeOwnerName, importPackage, importObjectName, false); } } if (entity != null) { bool success = AddImport(project.Name, project.Namespace.Name, typeOwnerName, JavaConventionHelper.packageConvention(project.Namespace.Name) + ".entities", entity.Name, isFileGenerationNeeded(project, entity)); if (success) { foreach (var attr in entity.Properties) { SoalType attrToType = attr.Type as SoalType; Symbols.Enum attrToEnum = attr.Type as Symbols.Enum; if (attrToEnum != null) { AddImport(project.Name, project.Namespace.Name, entity.Name, JavaConventionHelper.packageConvention(project.Namespace.Name) + ".enums", attrToEnum.Name, isFileGenerationNeeded(project, attrToEnum)); } else if (attrToType != null) { AnalyseSoalType(project, entity.Name, attrToType); } } } } else if (primitiv != null) { string importString = JavaImportConfigHandler.getValue(JavaTypeConfigHandler.SwitchTypeName(primitiv.MName)); if (importString != null) { string importPackage = importString.Substring(0, importString.LastIndexOf(".")); string importObjectName = importString.Substring(importString.LastIndexOf(".") + 1); AddImport(project.Name, project.Namespace.Name, typeOwnerName, importPackage, importObjectName, false); } } }
bool isFileGenerationNeeded(Component project, SoalType type) { foreach (var dec in project.Namespace.Declarations) { Struct obj = dec as Struct; if (obj != null) { if (obj.Name.Equals(type.MName)) { return(true); } } } return(false); }
public static SoalType GetCoreType(this SoalType type) { if (type == null) { return(null); } if (type is NullableType) { return(((NullableType)type).InnerType.GetCoreType()); } if (type is ArrayType) { return(((ArrayType)type).InnerType.GetCoreType()); } return(type); }
public static bool IsArrayType(this SoalType type) { if (type == null) { return(false); } if (type is NullableType) { return(((NullableType)type).InnerType.IsArrayType()); } if (type is ArrayType) { return(true); } return(false); }
public static string classNameConvention(SoalType c) { ArrayType at = c as ArrayType; if (c.MName != null) { return(JavaTypeConfigHandler.SwitchTypeName(c.MName)); } else if (at.InnerType != null) { return(JavaTypeConfigHandler.SwitchTypeName(at.MMetaClass.Name) + "<" + JavaTypeConfigHandler.SwitchTypeName(at.InnerType.MName) + ">"); } else { return("UNKNOWN_TYPE"); } }
private void CheckXsdNamespace(SoalType type, ModelObject symbol) { if (!type.HasXsdNamespace()) { this.Diagnostics.AddError("The type of this element has no XSD namespace.", this.FileName, symbol); } }
private SoalType ImportPhase2SimpleType(SoalType type, XElement elem) { XAttribute nameAttr = elem.Attribute("name"); XAttribute typeAttr = elem.Attribute("type"); XElement restriction = elem.Element(xsd + "restriction"); if (restriction != null) { XAttribute baseAttr = restriction.Attribute("base"); if (baseAttr != null) { XName baseRef = this.GetXName(restriction, baseAttr.Value); if (baseRef == null) { return null; } SoalType baseType = this.Importer.ResolveXsdType(baseRef); if (baseType == null) { this.Importer.Diagnostics.AddError("Could not resolve type '" + baseAttr.Value + "'.", this.Uri, this.GetTextSpan(baseAttr)); return null; } Enum enm = type as Enum; if (enm != null) { string name = enm.Name; if (baseType is Enum) { enm.BaseType = (Enum)baseType; } IEnumerable<XElement> enums = restriction.Elements(xsd + "enumeration"); foreach (var enumValue in enums) { XAttribute valueAttr = enumValue.Attribute("value"); if (valueAttr != null) { string value = valueAttr.Value; EnumLiteral enmLit = SoalFactory.Instance.CreateEnumLiteral(); string newValue = this.GetNewEnumLiteralName(enm, value); enmLit.Name = newValue; enm.EnumLiterals.Add(enmLit); if (value != newValue) { enmLit.SetAnnotationPropertyValue(SoalAnnotations.Enum, SoalAnnotationProperties.Name, value); } } else { this.Importer.Diagnostics.AddError("The enumeration has no 'value' attribute.", this.Uri, this.GetTextSpan(restriction)); return null; } } return enm; } else { SoalImporter.CopyAnnotations(baseType as AnnotatedElement, type as AnnotatedElement); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.Pattern); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.Length); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MinLength); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MaxLength); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MinInclusive); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MinExclusive); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MaxInclusive); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.MaxExclusive); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.TotalDigits); this.ProcessXsdRestriction(type, restriction, SoalAnnotationProperties.FractionDigits); this.Importer.RegisterReplacementType(type, baseType); return type; } } else { return null; } } else { return null; } }
private void ProcessXsdRestriction(SoalType type, XElement elem, string restrictionName) { XElement restrElem = elem.Element(xsd + restrictionName); if (restrElem != null) { XAttribute valueAttr = restrElem.Attribute("value"); if (valueAttr != null) { AnnotatedElement ae = type as AnnotatedElement; if (ae != null) { long longValue = 0; if (restrictionName == SoalAnnotationProperties.Pattern) { ae.SetAnnotationPropertyValue(SoalAnnotations.Restriction, restrictionName, valueAttr.Value); } else if (long.TryParse(valueAttr.Value, out longValue)) { ae.SetAnnotationPropertyValue(SoalAnnotations.Restriction, restrictionName, longValue); } else { ae.SetAnnotationPropertyValue(SoalAnnotations.Restriction, restrictionName, valueAttr.Value); } } } } }
private static List<SoalType> HandleArrayType(SoalType type) { List<SoalType> result = new List<SoalType>(); ArrayType array = type as ArrayType; if (array != null) { if (array.InnerType != SoalInstance.Byte) { result.Add(array); result.Add(array.InnerType); } } else { result.Add(type); } return result; }
private static string SubPackage(SoalType type) { if (type is Interface) { Interface iface = type as Interface; if (iface.Name.Contains("Repository")) { return ".repository"; } else { return ".interfaces"; } } if (type is Enum) return ".enums"; Struct str = type as Struct; if (str != null) { if (str.IsException()) return ".exception"; if (str.IsEntity()) return ".entity"; } return null; }
private static void CheckArrayType(SoalType type, IList<Annotation> annotations, HashSet<string> arrayNames, List<ArrayType> arrayTypes) { if (annotations.Any(a => a.Name == SoalAnnotations.Element && !(bool)a.GetPropertyValue(SoalAnnotationProperties.Wrapped))) return; if (type is ArrayType) { ArrayType atype = (ArrayType)type; string aname = atype.GetXsdName(); if (atype.InnerType != SoalInstance.Byte && !arrayNames.Contains(aname)) { arrayNames.Add(aname); arrayTypes.Add(atype); } } else if (type is NonNullableType) { ArrayType atype = ((NonNullableType)type).InnerType as ArrayType; if (atype != null) { string aname = atype.GetXsdName(); if (atype.InnerType != SoalInstance.Byte && !arrayNames.Contains(aname)) { arrayNames.Add(aname); arrayTypes.Add(atype); } } } }
internal SoalTypeBuilder ResolveXsdPrimitiveType(XName name) { if (name.NamespaceName == XsdReader.XsdNamespace) { SoalType result = null; SoalTypeBuilder resultAsBuilder = null; switch (name.LocalName) { case "any": result = SoalInstance.Object; break; case "anySimpleType": result = SoalInstance.Object; break; case "string": result = SoalInstance.String; break; case "anyURI": result = SoalInstance.String; break; case "QName": result = SoalInstance.String; break; case "NOTATION": result = SoalInstance.String; break; case "normalizedString": result = SoalInstance.String; break; case "token": result = SoalInstance.String; break; case "language": result = SoalInstance.String; break; case "Name": result = SoalInstance.String; break; case "NCName": result = SoalInstance.String; break; case "NMTOKEN": result = SoalInstance.String; break; case "NMTOKENS": result = SoalInstance.String; break; case "ID": result = SoalInstance.String; break; case "IDREF": result = SoalInstance.String; break; case "IDREFS": result = SoalInstance.String; break; case "ENTITY": result = SoalInstance.String; break; case "ENTITIES": result = SoalInstance.String; break; case "integer": result = SoalInstance.Int; break; case "nonPositiveInteger": result = SoalInstance.Int; break; case "negativeInteger": result = SoalInstance.Int; break; case "int": result = SoalInstance.Int; break; case "short": result = SoalInstance.Int; break; case "nonNegativeInteger": result = SoalInstance.Int; break; case "positiveInteger": result = SoalInstance.Int; break; case "unsignedInt": result = SoalInstance.Int; break; case "unsignedShort": result = SoalInstance.Int; break; case "long": result = SoalInstance.Long; break; case "unsignedLong": result = SoalInstance.Int; break; case "float": result = SoalInstance.Float; break; case "double": result = SoalInstance.Double; break; case "decimal": result = SoalInstance.Double; break; case "byte": result = SoalInstance.Byte; break; case "unsignedByte": result = SoalInstance.Byte; break; case "base64Binary": resultAsBuilder = this.byteArray; break; case "hexBinary": resultAsBuilder = this.byteArray; break; case "bool": result = SoalInstance.Bool; break; case "boolean": result = SoalInstance.Bool; break; case "time": result = SoalInstance.Time; break; case "date": result = SoalInstance.Date; break; case "dateTime": result = SoalInstance.DateTime; break; case "duration": result = SoalInstance.TimeSpan; break; case "gDay": result = SoalInstance.Date; break; case "gMonth": result = SoalInstance.Date; break; case "gMonthDay": result = SoalInstance.Date; break; case "gYear": result = SoalInstance.Date; break; case "gYearMonth": result = SoalInstance.Date; break; default: break; } if (resultAsBuilder == null && result != null) { resultAsBuilder = result.ToMutable(); } return(resultAsBuilder); } return(null); }
public static string IsNullableXsd(this SoalType type) { return(type.IsNullable().ToString().ToLower()); }
/// <summary> /// Implements the constructor: SoalType() /// </summary> public virtual void SoalType(SoalType @this) { }
public static bool IsNullable(this SoalType type) { return(type is NullableType); }
public static string GetXsdName(this SoalType type) { if (type is PrimitiveType) { string name = ((PrimitiveType)type).Name; switch (name) { case "int": case "long": case "float": case "double": case "string": case "byte": return(name); case "object": return("anyType"); case "bool": return("boolean"); case "Date": return("date"); case "Time": return("time"); case "DateTime": return("dateTime"); case "TimeSpan": return("duration"); default: break; } } if (type is NullableType) { return(GetXsdName(((NullableType)type).InnerType)); } if (type is NonNullableType) { return(GetXsdName(((NonNullableType)type).InnerType)); } if (type is ArrayType) { if (((ArrayType)type).InnerType == SoalInstance.Byte) { return("base64Binary"); } else { return((GetXsdName(((ArrayType)type).InnerType) + "List").ToPascalCase()); } } if (type is Enum) { Enum etype = (Enum)type; string newName = etype.GetAnnotationPropertyValue(SoalAnnotations.Type, SoalAnnotationProperties.Name) as string; return(newName ?? etype.Name); } if (type is Struct) { Struct stype = (Struct)type; string newName = stype.GetAnnotationPropertyValue(SoalAnnotations.Type, SoalAnnotationProperties.Name) as string; return(newName ?? stype.Name); } return(null); }
private Property ImportPhase4ElementProperty(Struct st, SoalType rt, XElement elem, bool attribute) { XAttribute refAttr = elem.Attribute("ref"); XAttribute nameAttr = elem.Attribute("name"); XAttribute typeAttr = elem.Attribute("type"); bool required = false; XAttribute useAttr = elem.Attribute("use"); if (useAttr != null && useAttr.Value == "required") { required = true; } bool sap = false; ArrayType sapArray = null; string sapName = null; string name = null; SoalType type = null; if (refAttr != null) { XName refName = this.GetXName(elem, refAttr.Value); XElement originalElem = null; if (refName != null) { if (attribute) { originalElem = this.Importer.XsdAttributes.GetX(refName); } else { originalElem = this.Importer.XsdElements.GetX(refName); } } if (originalElem != null) { name = refName.LocalName; if (attribute) { type = this.Importer.XsdAttributes.Get(refName); useAttr = originalElem.Attribute("use"); if (useAttr != null && useAttr.Value == "required") { required = true; } } else { type = this.Importer.XsdElements.Get(refName); } if (type == null) { this.Importer.Diagnostics.AddError("Could not resolve type '" + refAttr.Value + "'.", this.Uri, this.GetTextSpan(refAttr)); return null; } } else { this.Importer.Diagnostics.AddError("Could not resolve the reference.", this.Uri, this.GetTextSpan(refAttr)); return null; } } else { if (nameAttr != null) { name = nameAttr.Value; } if (name == null) { this.Importer.Diagnostics.AddError("The element has no name.", this.Uri, this.GetTextSpan(elem)); return null; } if (typeAttr == null) { XElement simpleType = elem.Element(xsd + "simpleType"); XElement complexType = elem.Element(xsd + "complexType"); string typeName = this.GetUniqueName(name, true); if (simpleType != null) { type = this.ImportPhase1SimpleType(simpleType, typeName, attribute ? XsdTypeKind.Attribute : XsdTypeKind.Element, elem, false); type = this.ImportPhase2SimpleType(type, simpleType); } else if (complexType != null) { type = this.ImportPhase1ComplexType(complexType, typeName, attribute ? XsdTypeKind.Attribute : XsdTypeKind.Element, elem, false); Struct childSt = type as Struct; if (childSt != null) { type = this.ImportPhase2ComplexType(childSt, complexType); childSt = type as Struct; if (childSt != null) { type = this.ImportPhase4ComplexType(childSt, complexType); childSt = type as Struct; if (name == "item" && childSt != null && childSt.HasAnnotation(SoalAnnotations.All) && childSt.Properties.Count == 1) { SoalType innerType = childSt.Properties[0].Type; if (innerType.IsArrayType()) { } else { sap = true; sapName = childSt.Properties[0].Name; sapArray = SoalFactory.Instance.CreateArrayType(); sapArray.InnerType = innerType; //this.Importer.RegisterReplacementType(type, sapArray); this.Importer.RemoveType(type); } } } } } else { this.Importer.Diagnostics.AddError("The element has no type.", this.Uri, this.GetTextSpan(elem)); return null; } } else { XName typeRef = this.GetXName(elem, typeAttr.Value); if (typeRef == null) { this.Importer.Diagnostics.AddError("Invalid type reference: '" + typeAttr.Value + "'", this.Uri, this.GetTextSpan(typeAttr)); return null; } type = this.Importer.XsdTypes.Get(typeRef) as SoalType; if (type == null) { type = this.Importer.ResolveXsdPrimitiveType(typeRef) as SoalType; } if (type == null) { this.Importer.Diagnostics.AddError("Could not resolve type '" + typeAttr.Value + "'.", this.Uri, this.GetTextSpan(typeAttr)); return null; } } } SoalType originalType = type; type = this.Importer.ResolveXsdReplacementType(type); XAttribute nillableAttr = elem.Attribute("nillable"); XAttribute minOccursAttr = elem.Attribute("minOccurs"); XAttribute maxOccursAttr = elem.Attribute("maxOccurs"); bool nillable = false; int minOccurs = 1; int maxOccurs = 1; if (nillableAttr != null) { nillable = nillableAttr.Value == "1" || nillableAttr.Value.ToLower() == "true"; } if (minOccursAttr != null) { if (!int.TryParse(minOccursAttr.Value, out minOccurs)) { minOccurs = 1; } } if (maxOccursAttr != null) { if (maxOccursAttr.Value.ToLower() == "unbounded") { maxOccurs = -1; } else if (!int.TryParse(maxOccursAttr.Value, out maxOccurs)) { maxOccurs = 1; } } if (type is PrimitiveType) { if (nillable && type != SoalInstance.Object && type != SoalInstance.String) { NullableType nullable = SoalFactory.Instance.CreateNullableType(); nullable.InnerType = type; type = nullable; } else if (!nillable && (type == SoalInstance.Object || type == SoalInstance.String)) { NonNullableType nonNull = SoalFactory.Instance.CreateNonNullableType(); nonNull.InnerType = type; type = nonNull; } } else { if (!nillable) { NonNullableType nonNull = SoalFactory.Instance.CreateNonNullableType(); nonNull.InnerType = type; type = nonNull; } } Property prop = SoalFactory.Instance.CreateProperty(); string newName = this.GetNewPropertyName(st, name); prop.Name = newName; if (attribute) { prop.Type = type; Annotation attrAnnot = prop.AddAnnotation(SoalAnnotations.Attribute); if (required) { attrAnnot.SetPropertyValue(SoalAnnotationProperties.Required, true); } if (newName != name) { attrAnnot.SetPropertyValue(SoalAnnotationProperties.Name, name); } } else { if (newName != name) { Annotation elemAnnot = prop.AddAnnotation(SoalAnnotations.Element); elemAnnot.SetPropertyValue(SoalAnnotationProperties.Name, name); } if (rt != null && rt is ArrayType) { if (sap) { ((ArrayType)rt).InnerType = sapArray.InnerType; this.Importer.RegisterReplacementType(type, rt); Annotation arrayAnnot = st.AddAnnotation(SoalAnnotations.Type); arrayAnnot.SetPropertyValue(SoalAnnotationProperties.Wrapped, true); arrayAnnot.SetPropertyValue(SoalAnnotationProperties.Items, sapName); arrayAnnot.SetPropertyValue(SoalAnnotationProperties.Sap, true); } else { if (type.IsArrayType()) { type = originalType; this.Importer.Reference(type); } ((ArrayType)rt).InnerType = type; SoalType coreType = type.GetCoreType(); Annotation arrayAnnot = st.AddAnnotation(SoalAnnotations.Type); arrayAnnot.SetPropertyValue(SoalAnnotationProperties.Wrapped, true); if (coreType is NamedElement && ((NamedElement)coreType).Name != prop.Name) { arrayAnnot.SetPropertyValue(SoalAnnotationProperties.Items, prop.Name); } } prop.Type = rt; } else { if (maxOccurs < 0 || maxOccurs > 1) { ArrayType array = SoalFactory.Instance.CreateArrayType(); array.InnerType = type; type = array; } prop.Type = type; } if (minOccurs == 0 && maxOccurs == 1) { prop.SetAnnotationPropertyValue(SoalAnnotations.Element, SoalAnnotationProperties.Optional, true); } } this.Importer.RegisterOriginalType((ModelObject)prop, originalType); st.Properties.Add(prop); return prop; }