public void AddComplexRestrictedContentType(XmlSchemaComplexType wrappingType, ClrTypeReference wrappingTypeRef) { string identifier = NameGenerator.MakeValidIdentifier(wrappingType.Name); AnonymousType at = new AnonymousType(); at.identifier = identifier; at.typeRefence = wrappingTypeRef; at.wrappingType = wrappingType; anonymousTypes.Add(at); }
private ClrTypeReference BuildTypeReference( XmlSchemaObject schemaObject, XmlQualifiedName typeQName, bool anonymousType, bool setVariety) { string typeName = typeQName.Name; string typeNs = typeQName.Namespace; if (!anonymousType) { typeNs = configSettings.GetClrNamespace(typeNs); } ClrTypeReference typeRef = new ClrTypeReference( typeName, typeNs, schemaObject, anonymousType, setVariety); return typeRef; }
public void AddAnonymousType(string identifier, XmlSchemaElement parentElement, ClrTypeReference parentElementTypeRef) { AnonymousType at = new AnonymousType(); at.identifier = identifier; at.typeRefence = parentElementTypeRef; at.parentElement = parentElement; anonymousTypes.Add(at); }
private ClrPropertyInfo InitializeTypedValuePropertyInfo(ClrTypeInfo typeInfo, ClrPropertyInfo typedValPropertyInfo, ClrTypeReference innerType) { if (typedValPropertyInfo == null) { typedValPropertyInfo = new ClrPropertyInfo(Constants.SInnerTypePropertyName, string.Empty, Constants.SInnerTypePropertyName, Occurs.One); typedValPropertyInfo.Origin = SchemaOrigin.Text; } else { typedValPropertyInfo.Reset(); } typedValPropertyInfo.TypeReference = innerType; if (typeInfo.IsSubstitutionMember()) { typedValPropertyInfo.IsNew = true; } typedValPropertyInfo.UpdateTypeReference(currentFullTypeName, currentNamespace, nameMappings); return typedValPropertyInfo; }
private ClrPropertyInfo BuildComplexTypeTextProperty(XmlSchemaElement parentElement, XmlSchemaComplexType schemaType) { Debug.Assert(schemaType != null); Debug.Assert(schemaType.GetContentType() == XmlSchemaContentType.TextOnly); ClrPropertyInfo textProperty = new ClrPropertyInfo(Constants.SInnerTypePropertyName, string.Empty, Constants.SInnerTypePropertyName, Occurs.One); textProperty.Origin = SchemaOrigin.Text; ClrTypeReference typeRef = null; bool anonymous = false; //Could be derived by restriction or extension //If first time extension, make the base simple type as the type reference XmlSchemaType baseType = schemaType.BaseXmlSchemaType; if (baseType is XmlSchemaSimpleType) { typeRef = BuildTypeReference(baseType, baseType.QualifiedName, false, true); anonymous = false; if (!textPropInheritanceTracker.ContainsKey(schemaType)) { textPropInheritanceTracker.Add(schemaType, textProperty); } } else if (schemaType.HasFacetRestrictions()) { //Derived by restriction, represents the content type with restrictions as a local type //Make the base simple type as the type reference so that we know if it is a list, union or atomic XmlSchemaSimpleType st = schemaType.GetBaseSimpleType(); Debug.Assert(st != null); typeRef = BuildTypeReference(st, st.QualifiedName, true, true); typeRef.Validate = true; anonymous = true; //Also get its base complex type and see if we need to override the content property ClrPropertyInfo baseProp = null; if (textPropInheritanceTracker.TryGetValue(baseType, out baseProp)) { textProperty.IsOverride = true; if (!baseProp.IsOverride) { baseProp.IsVirtual = true; } } } else { return(null); } if (anonymous) { //anonymous type, fixed up the name later, treat complex type with restrictions as an anonymous type //because we need to generate a type to encapsualte these restrictions if (parentElement != null) { string identifier = localSymbolTable.AddLocalElement(parentElement); localSymbolTable.AddAnonymousType(identifier, parentElement, typeRef); } else { localSymbolTable.AddComplexRestrictedContentType(schemaType, typeRef); } } textProperty.TypeReference = typeRef; return(textProperty); }
private ClrPropertyInfo BuildProperty(XmlSchemaElement elem, bool fromBaseType) { string identifierName = localSymbolTable.AddLocalElement(elem); XmlSchemaType schemaType = elem.ElementSchemaType; XmlQualifiedName schemaTypeName = schemaType.QualifiedName; string schemaName = elem.QualifiedName.Name; string schemaNs = elem.QualifiedName.Namespace; string clrNs = elem.FormResolved() == XmlSchemaForm.Qualified ? configSettings.GetClrNamespace(schemaNs) : string.Empty; SchemaOrigin typeRefOrigin = SchemaOrigin.Fragment; bool isTypeRef = false; bool anonymousType = schemaTypeName.IsEmpty ? true : false; XmlSchemaObject schemaObject = schemaType; ArrayList substitutionMembers = null; if (elem.IsGlobal()) { substitutionMembers = IsSubstitutionGroupHead(elem); schemaTypeName = elem.QualifiedName; isTypeRef = true; typeRefOrigin = SchemaOrigin.Element; schemaObject = schemas.GlobalElements [schemaTypeName]; //For ref, get the element decl SOM object, as nameMappings are keyed off the SOM object anonymousType = false; } ClrTypeReference typeRef = BuildTypeReference(schemaObject, schemaTypeName, anonymousType, true); typeRef.Origin = typeRefOrigin; typeRef.IsTypeRef = isTypeRef; if (anonymousType && !fromBaseType) { //to fixup later. localSymbolTable.AddAnonymousType(identifierName, elem, typeRef); } ClrPropertyInfo propertyInfo = new ClrPropertyInfo(identifierName, schemaNs, schemaName, GetOccurence(elem)); propertyInfo.Origin = SchemaOrigin.Element; propertyInfo.FromBaseType = fromBaseType; propertyInfo.TypeReference = typeRef; propertyInfo.ClrNamespace = clrNs; //SetFixedDefaultValue(elem, propertyInfo); if (substitutionMembers != null) { propertyInfo.SubstitutionMembers = substitutionMembers; } //BuildAnnotationInformation(propertyInfo, elem); return(propertyInfo); //Place it in the element's namespace, maybe element's parent type's namespace? }
public void AddComplexRestrictedContentType(XmlSchemaComplexType wrappingType, ClrTypeReference wrappingTypeRef) { string identifier = NameGenerator.MakeValidIdentifier(wrappingType.Name, this.ConfigSettings.NameMangler2); AnonymousType at = new AnonymousType() { identifier = identifier, typeRefence = wrappingTypeRef, wrappingType = wrappingType }; this.anonymousTypes.Add(at); }
internal void ElementsToTypes() { bool isRoot = false; int rootElementsCount = schemas.GlobalElements.Count; foreach (XmlSchemaElement elem in schemas.GlobalElements.Values) { SymbolEntry symbol = symbolTable.AddElement(elem); XmlSchemaType schemaType = elem.ElementSchemaType; string xsdNamespace = elem.QualifiedName.Namespace; ClrTypeInfo typeInfo = null; XmlSchemaElement headElement = null; if (!elem.SubstitutionGroup.IsEmpty) { headElement = (XmlSchemaElement)schemas.GlobalElements[elem.SubstitutionGroup]; } if (schemaType.IsGlobal()) { //Global elem with global type, generate wrapper class for the element bool hasBaseContentType = headElement != null && headElement.ElementSchemaType == schemaType; ClrWrapperTypeInfo wtypeInfo = new ClrWrapperTypeInfo(hasBaseContentType); ClrTypeReference typeDef = BuildTypeReference(schemaType, schemaType.QualifiedName, false, true); //Save the fixed/default value of the element wtypeInfo.InnerType = typeDef; typeInfo = wtypeInfo; typeInfo.baseType = headElement; //If element is member of substitutionGroup, add derivation step } else { ClrContentTypeInfo ctypeInfo = new ClrContentTypeInfo(); localSymbolTable.Init(symbol.identifierName); ctypeInfo.baseType = headElement; //If element is member of substitutionGroup, add derivation step BuildProperties(elem, schemaType, ctypeInfo); BuildNestedTypes(ctypeInfo); typeInfo = ctypeInfo; } if (!isRoot) { if (rootElementsCount == 1 || CheckUnhandledAttributes(elem)) { typeInfo.IsRoot = true; isRoot = true; } } typeInfo.IsSubstitutionHead = IsSubstitutionGroupHead(elem) != null; typeInfo.IsAbstract = elem.IsAbstract; typeInfo.clrtypeName = symbol.identifierName; typeInfo.clrtypeNs = symbol.clrNamespace; typeInfo.schemaName = symbol.symbolName; typeInfo.schemaNs = xsdNamespace; typeInfo.typeOrigin = SchemaOrigin.Element; BuildAnnotationInformation(typeInfo, schemaType); binding.Types.Add(typeInfo); } }
private void ProcessWrapperTypes() { List <CodeTypeDeclaration> types; if (this.wrapperRootElements != null) { XWrapperTypedElementBuilder wrapperBuilder = new XWrapperTypedElementBuilder(); XSimpleTypedElementBuilder simpleTypeBuilder = new XSimpleTypedElementBuilder(); TypeBuilder builder = null; ClrPropertyInfo typedValPropertyInfo = null; foreach (ClrWrapperTypeInfo typeInfo in this.wrapperRootElements) { this.SetFullTypeName(typeInfo, null); ClrTypeReference innerType = typeInfo.InnerType; if (!innerType.IsSimpleType) { string innerTypeName = null; string innerTypeFullName = innerType.GetClrFullTypeName(typeInfo.clrtypeNs, this.nameMappings, out innerTypeName); string innerTypeNs = innerType.Namespace; CodeTypeDeclaration innerTypeDecl = this.GetCodeTypeDeclaration(innerTypeName, this.GetCodeNamespace(innerTypeNs)); TypeAttributes innerTypeAttributes = TypeAttributes.NotPublic; if (innerTypeDecl != null) { innerTypeAttributes = innerTypeDecl.TypeAttributes; } else if (innerTypeName != "XTypedElement") { continue; } this.currentNamespace = typeInfo.clrtypeNs; wrapperBuilder.Init(innerTypeFullName, innerTypeNs, innerTypeAttributes); wrapperBuilder.CreateTypeDeclaration(typeInfo); wrapperBuilder.CreateFunctionalConstructor(typeInfo.Annotations); wrapperBuilder.ApplyAnnotations(typeInfo); wrapperBuilder.AddTypeToTypeManager(CodeDomTypesGenerator.elementDictionaryAddStatements, CodeDomTypesGenerator.wrapperDictionaryAddStatements); if (!typeInfo.HasBaseContentType) { ClrWrappingPropertyInfo wrappingPropertyInfo = null; if (innerTypeName != "XTypedElement") { wrappingPropertyInfo = new ClrWrappingPropertyInfo(); foreach (CodeTypeMember member in innerTypeDecl.Members) { CodeMemberProperty memberProperty = member as CodeMemberProperty; if (this.ForwardProperty(memberProperty)) { wrappingPropertyInfo.Init(memberProperty); wrapperBuilder.CreateProperty(wrappingPropertyInfo, typeInfo.Annotations); } } } } builder = wrapperBuilder; } else { typedValPropertyInfo = this.InitializeTypedValuePropertyInfo(typeInfo, typedValPropertyInfo, innerType); simpleTypeBuilder.Init(typedValPropertyInfo.ClrTypeName, innerType.IsSchemaList); simpleTypeBuilder.CreateTypeDeclaration(typeInfo); simpleTypeBuilder.CreateFunctionalConstructor(typeInfo.Annotations); typedValPropertyInfo.SetFixedDefaultValue(typeInfo); simpleTypeBuilder.CreateProperty(typedValPropertyInfo, typeInfo.Annotations); simpleTypeBuilder.AddTypeToTypeManager(CodeDomTypesGenerator.elementDictionaryAddStatements, "elementDictionary"); simpleTypeBuilder.ApplyAnnotations(typeInfo); builder = simpleTypeBuilder; } builder.ImplementInterfaces(this.settings.EnableServiceReference); this.codeNamespace = this.GetCodeNamespace(typeInfo.clrtypeNs); this.codeNamespace.Types.Add(builder.TypeDeclaration); this.codeNamespace = this.GetCodeNamespace(typeInfo.clrtypeNs); if (!this.xroots.TryGetValue(this.codeNamespace, out types)) { types = new List <CodeTypeDeclaration>(); this.xroots.Add(this.codeNamespace, types); } types.Add(builder.TypeDeclaration); } } }
public void AddAnonymousType(string identifier, XmlSchemaElement parentElement, ClrTypeReference parentElementTypeRef) { AnonymousType at = new AnonymousType() { identifier = identifier, typeRefence = parentElementTypeRef, parentElement = parentElement }; this.anonymousTypes.Add(at); }
private ClrPropertyInfo InitializeTypedValuePropertyInfo(ClrTypeInfo typeInfo, ClrPropertyInfo typedValPropertyInfo, ClrTypeReference innerType) { if (typedValPropertyInfo != null) { typedValPropertyInfo.Reset(); } else { typedValPropertyInfo = new ClrPropertyInfo("TypedValue", string.Empty, "TypedValue", Occurs.One) { Origin = SchemaOrigin.Text }; } typedValPropertyInfo.TypeReference = innerType; if (typeInfo.IsSubstitutionMember()) { typedValPropertyInfo.IsNew = true; } typedValPropertyInfo.UpdateTypeReference(this.currentFullTypeName, this.currentNamespace, this.nameMappings); return(typedValPropertyInfo); }
private ClrPropertyInfo InitializeTypedValuePropertyInfo(ClrTypeInfo typeInfo, ClrPropertyInfo typedValPropertyInfo, ClrTypeReference innerType) { if (typedValPropertyInfo == null) { typedValPropertyInfo = new ClrPropertyInfo(Constants.SInnerTypePropertyName, string.Empty, Constants.SInnerTypePropertyName, Occurs.One, settings); typedValPropertyInfo.Origin = SchemaOrigin.Text; } else { typedValPropertyInfo.Reset(); } typedValPropertyInfo.TypeReference = innerType; if (typeInfo.IsSubstitutionMember()) { typedValPropertyInfo.IsNew = true; } typedValPropertyInfo.UpdateTypeReference(currentFullTypeName, currentNamespace, nameMappings); return(typedValPropertyInfo); }
private void ProcessWrapperTypes() { if (wrapperRootElements == null) { //No Globalelements with global types return; } XWrapperTypedElementBuilder wrapperBuilder = new XWrapperTypedElementBuilder(settings); XSimpleTypedElementBuilder simpleTypeBuilder = new XSimpleTypedElementBuilder(settings); TypeBuilder builder = null; ClrPropertyInfo typedValPropertyInfo = null; foreach (ClrWrapperTypeInfo typeInfo in wrapperRootElements) { SetFullTypeName(typeInfo, null); ClrTypeReference innerType = typeInfo.InnerType; if (innerType.IsSimpleType) { typedValPropertyInfo = InitializeTypedValuePropertyInfo(typeInfo, typedValPropertyInfo, innerType); simpleTypeBuilder.Init(typedValPropertyInfo.ClrTypeName, innerType.IsSchemaList); simpleTypeBuilder.CreateTypeDeclaration(typeInfo); simpleTypeBuilder.CreateFunctionalConstructor(typeInfo.Annotations); typedValPropertyInfo.SetFixedDefaultValue(typeInfo); simpleTypeBuilder.CreateProperty(typedValPropertyInfo, typeInfo.Annotations); simpleTypeBuilder.AddTypeToTypeManager(elementDictionaryAddStatements, Constants.ElementDictionaryField); simpleTypeBuilder.ApplyAnnotations(typeInfo); builder = simpleTypeBuilder; } else { string innerTypeName = null; string innerTypeFullName = innerType.GetClrFullTypeName(typeInfo.clrtypeNs, nameMappings, out innerTypeName); string innerTypeNs = innerType.Namespace; CodeNamespace innerTypeCodeNamespace = GetCodeNamespace(innerTypeNs); CodeTypeDeclaration innerTypeDecl = GetCodeTypeDeclaration(innerTypeName, innerTypeCodeNamespace); TypeAttributes innerTypeAttributes = TypeAttributes.Class; if (innerTypeDecl != null) { innerTypeAttributes = innerTypeDecl.TypeAttributes; } else if (innerTypeName != Constants.XTypedElement) { continue; } currentNamespace = typeInfo.clrtypeNs; wrapperBuilder.Init(innerTypeFullName, innerTypeNs, innerTypeAttributes); wrapperBuilder.CreateTypeDeclaration(typeInfo); wrapperBuilder.CreateFunctionalConstructor(typeInfo.Annotations); wrapperBuilder.ApplyAnnotations(typeInfo); wrapperBuilder.AddTypeToTypeManager(elementDictionaryAddStatements, wrapperDictionaryAddStatements); if (!typeInfo.HasBaseContentType) { //Add innerType properties only if the wrapper's type is not the same as the substitutionGroup head type ClrWrappingPropertyInfo wrappingPropertyInfo = null; //Create forwarding properties if (innerTypeName != Constants.XTypedElement) { //If the wrapped type is xs:anyType, no forwarding properties to create wrappingPropertyInfo = new ClrWrappingPropertyInfo(); foreach (CodeTypeMember member in innerTypeDecl.Members) { CodeMemberProperty memberProperty = member as CodeMemberProperty; if (ForwardProperty(memberProperty)) { //Do not forward over TypeManager, SchemaName etc wrappingPropertyInfo.Init(memberProperty); wrapperBuilder.CreateProperty(wrappingPropertyInfo, typeInfo.Annotations); } } } } builder = wrapperBuilder; } builder.ImplementInterfaces(settings.EnableServiceReference); codeNamespace = GetCodeNamespace(typeInfo.clrtypeNs); codeNamespace.Types.Add(builder.TypeDeclaration); List <CodeTypeDeclaration> types; codeNamespace = GetCodeNamespace(typeInfo.clrtypeNs); if (!xroots.TryGetValue(codeNamespace, out types)) { types = new List <CodeTypeDeclaration>(); xroots.Add(codeNamespace, types); } types.Add(builder.TypeDeclaration); } }
private ClrPropertyInfo BuildComplexTypeTextProperty(XmlSchemaElement parentElement, XmlSchemaComplexType schemaType) { string identifier; ClrPropertyInfo clrPropertyInfo; Debug.Assert(schemaType != null); Debug.Assert(schemaType.GetContentType() == XmlSchemaContentType.TextOnly); ClrPropertyInfo textProperty = new ClrPropertyInfo("TypedValue", string.Empty, "TypedValue", Occurs.One) { Origin = SchemaOrigin.Text }; ClrTypeReference typeRef = null; bool anonymous = false; XmlSchemaType baseType = schemaType.BaseXmlSchemaType; if (!(baseType is XmlSchemaSimpleType)) { if (schemaType.HasFacetRestrictions()) { goto Label1; } clrPropertyInfo = null; return(clrPropertyInfo); } else { typeRef = this.BuildTypeReference(baseType, baseType.QualifiedName, false, true); anonymous = false; if (!this.textPropInheritanceTracker.ContainsKey(schemaType)) { this.textPropInheritanceTracker.Add(schemaType, textProperty); } } if (anonymous) { if (parentElement == null) { this.localSymbolTable.AddComplexRestrictedContentType(schemaType, typeRef); } else { identifier = this.localSymbolTable.AddLocalElement(parentElement); this.localSymbolTable.AddAnonymousType(identifier, parentElement, typeRef); } } textProperty.TypeReference = typeRef; clrPropertyInfo = textProperty; return(clrPropertyInfo); Label1: XmlSchemaSimpleType st = schemaType.GetBaseSimpleType(); Debug.Assert(st != null); typeRef = this.BuildTypeReference(st, st.QualifiedName, true, true); typeRef.Validate = true; anonymous = true; ClrPropertyInfo baseProp = null; if (this.textPropInheritanceTracker.TryGetValue(baseType, out baseProp)) { textProperty.IsOverride = true; if (!baseProp.IsOverride) { baseProp.IsVirtual = true; } } if (anonymous) { if (parentElement == null) { this.localSymbolTable.AddComplexRestrictedContentType(schemaType, typeRef); } else { identifier = this.localSymbolTable.AddLocalElement(parentElement); this.localSymbolTable.AddAnonymousType(identifier, parentElement, typeRef); } } textProperty.TypeReference = typeRef; clrPropertyInfo = textProperty; return(clrPropertyInfo); }