Esempio n. 1
0
        public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs)
        {
            TestDataSet ds = new TestDataSet();

            System.Xml.Schema.XmlSchemaComplexType type     = new System.Xml.Schema.XmlSchemaComplexType();
            System.Xml.Schema.XmlSchemaSequence    sequence = new System.Xml.Schema.XmlSchemaSequence();
            xs.Add(ds.GetSchemaSerializable());
            System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
            any.Namespace = ds.Namespace;
            sequence.Items.Add(any);
            type.Particle = sequence;
            return(type);
        }
Esempio n. 2
0
        /// <summary>
        /// Load this Complex type from the .NET schema
        /// </summary>
        /// <param name="type">The type to load</param>
        public void Load(System.Xml.Schema.XmlSchemaComplexType type)
        {
            base.Load(type);

            this.Name      = type.Name ?? type.QualifiedName.Name;
            this.Namespace = !type.QualifiedName.IsEmpty ? type.QualifiedName.Namespace : Schema.TargetNamespace;
            schemaPtr      = type;
            this.mixed     = type.IsMixed;
            this.abst      = type.IsAbstract;

            // Find base class
            if (type.BaseXmlSchemaType != null && type.BaseXmlSchemaType.Name != null)
            {
                BaseClass = Schema.FindType(type.BaseXmlSchemaType.Name);
            }
        }
        private string CreateProcessXmlFieldSchemaString(string name)
        {
            System.Xml.Schema.XmlSchema            xmlSchema   = new System.Xml.Schema.XmlSchema();
            System.Xml.Schema.XmlSchemaComplexType complexType = new System.Xml.Schema.XmlSchemaComplexType();
            System.Xml.Schema.XmlSchemaSequence    sequence    = new System.Xml.Schema.XmlSchemaSequence();
            complexType.Particle = sequence;
            System.Xml.Schema.XmlSchemaElement rootElement = new System.Xml.Schema.XmlSchemaElement();
            rootElement.SchemaType = complexType;
            rootElement.Name       = name;
            xmlSchema.Items.Add(rootElement);
            System.IO.StringWriter stream = new System.IO.StringWriter();
            xmlSchema.Write(stream);
            string outString = stream.ToString();

            stream.Close();
            stream.Dispose();
            return(outString);
        }
Esempio n. 4
0
 public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
     System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
     System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
     IBDataset ds = new IBDataset();
     xs.Add(ds.GetSchemaSerializable());
     System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
     any1.Namespace = "http://www.w3.org/2001/XMLSchema";
     any1.MinOccurs = new decimal(0);
     any1.MaxOccurs = decimal.MaxValue;
     any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
     sequence.Items.Add(any1);
     System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
     any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
     any2.MinOccurs = new decimal(1);
     any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
     sequence.Items.Add(any2);
     System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
     attribute1.Name = "namespace";
     attribute1.FixedValue = ds.Namespace;
     type.Attributes.Add(attribute1);
     System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
     attribute2.Name = "tableTypeName";
     attribute2.FixedValue = "SPR_TOVDataTable";
     type.Attributes.Add(attribute2);
     type.Particle = sequence;
     return type;
 }
Esempio n. 5
0
 public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) {
     IBDataset ds = new IBDataset();
     System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
     System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
     xs.Add(ds.GetSchemaSerializable());
     System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
     any.Namespace = ds.Namespace;
     sequence.Items.Add(any);
     type.Particle = sequence;
     return type;
 }
        /// <summary> Fill the ClassDeclaration with Attributes of the XmlSchemaElement. </summary>
        public static void GenerateAttribute(System.Xml.Schema.XmlSchemaElement attElt, Refly.CodeDom.ClassDeclaration cd, System.Xml.Schema.XmlSchemaComplexType refSchemaType)
        {
            cd.Doc.Summary.AddText(AnnotationToString(attElt.Annotation));             // Create the <summary />
            cd.Parent = new Refly.CodeDom.StringTypeDeclaration("BaseAttribute");
            // Add [AttributeUsage(AttributeTargets, AllowMultiple]  and  [Serializable]
            // Note: There is a problem with the order of the arguments, that's why they are together
            bool   targetsAll       = Utils.TargetsAll(Utils.Capitalize(attElt.Name));
            string attributeTargets = "System.AttributeTargets.";

            if (Utils.IsRoot(Utils.Capitalize(attElt.Name)) || targetsAll)
            {
                attributeTargets += "Class | System.AttributeTargets.Struct | System.AttributeTargets.Interface";
            }
            if (targetsAll)
            {
                attributeTargets += " | System.AttributeTargets.";
            }
            if (!Utils.IsRoot(Utils.Capitalize(attElt.Name)) || targetsAll)
            {
                attributeTargets += "Property | System.AttributeTargets.Field";
            }
            Refly.CodeDom.AttributeDeclaration attribUsage = cd.CustomAttributes.Add("System.AttributeUsage");
            attribUsage.Arguments.Add("", new Refly.CodeDom.Expressions.SnippetExpression(
                                          attributeTargets + ", AllowMultiple=" + Utils.AllowMultipleValue(attElt.Name)));
            cd.CustomAttributes.Add("System.Serializable");

            // Add the constructors
            Refly.CodeDom.ConstructorDeclaration defCtor = cd.AddConstructor();
            defCtor.Doc.Summary.AddText(" Default constructor (position=0) ");             // Create the <summary />
            defCtor.BaseContructorArgs.Add(new Refly.CodeDom.Expressions.SnippetExpression("0"));
            Refly.CodeDom.ConstructorDeclaration posCtor = cd.AddConstructor();
            posCtor.Doc.Summary.AddText(" Constructor taking the position of the attribute. ");             // Create the <summary />
            posCtor.Signature.Parameters.Add(typeof(int), "position");
            posCtor.BaseContructorArgs.Add(new Refly.CodeDom.Expressions.SnippetExpression("position"));

            System.Xml.Schema.XmlSchemaComplexType type = attElt.SchemaType as System.Xml.Schema.XmlSchemaComplexType;
            if (type == null && !attElt.SchemaTypeName.IsEmpty)            // eg:  <xs:element name="cache" type="cacheType" />
            {
                type = refSchemaType;
            }

            if (type != null)
            {
                // Add the attribute members
                System.Collections.ArrayList attribMembers = Utils.GetAttributes(type.Attributes);
                log.Debug("Add Attribute members: Count=" + attribMembers.Count);
                foreach (System.Xml.Schema.XmlSchemaAttribute attribMember in attribMembers)
                {
                    string memberType = Utils.GetAttributeTypeName(attElt, attribMember);
                    if (attribMember.SchemaTypeName.Name == string.Empty)                  // Create the dynamically generated enumeration
                    {
                        log.Debug("Generate Enumeration for SimpleType: " + memberType);
                        GenerateEnumeration(attribMember.SchemaType, cd.Namespace.AddEnum(memberType, false));
                    }

                    // Add the field with its default value
                    Refly.CodeDom.FieldDeclaration fd = cd.AddField(
                        memberType, attribMember.Name.Replace("-", "").ToLower());
                    // Set the unspecified value (to know if specified by the user)
                    fd.InitExpression = new Refly.CodeDom.Expressions.SnippetExpression(Utils.GetUnspecifiedValue(attElt, attribMember));
                    // Add its public property with a comment
                    Refly.CodeDom.PropertyDeclaration pd = cd.AddProperty(fd, true, true, false);
                    pd.Doc.Summary.AddText(AnnotationToString(attribMember.Annotation));                     // Create the <summary />
                    if (memberType == "System.Boolean")
                    {
                        // Add the field+property to know if this field has been specified
                        Refly.CodeDom.FieldDeclaration boolIsSpec = cd.AddField(
                            "System.Boolean", fd.Name + "specified");
                        cd.AddProperty(boolIsSpec, true, false, false).Doc.Summary.AddText(" Tells if " + pd.Name + " has been specified. ");                         // Create the <summary />
                        pd.Set.Add(new Refly.CodeDom.Expressions.SnippetExpression(
                                       boolIsSpec.Name + " = true"));
                    }

                    // Add the System.Type property (to allow setting this attribute with a type)
                    if (Utils.IsSystemType(attElt.Name, attribMember, memberType))
                    {
                        log.Debug("  Create System.Type for <" + attElt.Name + "> <" + attribMember.Name + ">");
                        Refly.CodeDom.PropertyDeclaration pdType = cd.AddProperty(typeof(System.Type), pd.Name + "Type");
                        pdType.Doc.Summary.AddText(AnnotationToString(attribMember.Annotation));                         // Create the <summary />
                        pdType.Get.Add(new Refly.CodeDom.Expressions.SnippetExpression(
                                           "return System.Type.GetType( this." + pd.Name + " )"));
                        pdType.Set.Add(new Refly.CodeDom.Expressions.SnippetExpression(string.Format(
                                                                                           @"if(value.Assembly == typeof(int).Assembly)
					this.{0} = value.FullName.Substring(7);
				else
					this.{0} = value.FullName + "", "" + value.Assembly.GetName().Name"                    , pd.Name)));
                    }

                    // Add the object property (to allow setting this attribute with any object)
                    if (Utils.IsSystemObject(attElt.Name, attribMember, memberType))
                    {
                        bool IsSystemEnum = Utils.IsSystemEnum(attElt.Name, attribMember, memberType);
                        log.Debug("  Create object version " + (IsSystemEnum?"+ EnumFormat ":"") + "for <" + attElt.Name + "> <" + attribMember.Name + ">");
                        Refly.CodeDom.PropertyDeclaration pdType = cd.AddProperty(typeof(object), pd.Name + "Object");
                        pdType.Doc.Summary.AddText(AnnotationToString(attribMember.Annotation));                         // Create the <summary />
                        pdType.Get.Add(new Refly.CodeDom.Expressions.SnippetExpression(
                                           "return this." + pd.Name));
                        // handle conversion of enum values
                        if (IsSystemEnum)
                        {
                            pdType.Set.Add(new Refly.CodeDom.Expressions.SnippetExpression(string.Format(
                                                                                               @"if(value is System.Enum)
					this.{0} = System.Enum.Format(value.GetType(), value, this.{0}EnumFormat);
				else
					this.{0} = value==null ? ""null"" : value.ToString()"                    , pd.Name)));
                        }
                        else
                        {
                            pdType.Set.Add(new Refly.CodeDom.Expressions.SnippetExpression(string.Format(
                                                                                               @"this.{0} = value==null ? ""null"" : value.ToString()", pd.Name)));
                        }

                        // Add the field xxxEnumFormat to set the string to use when formatting an Enum
                        if (IsSystemEnum)
                        {
                            Refly.CodeDom.FieldDeclaration fdEnumFormat = cd.AddField(
                                typeof(string), (fd.Name + "EnumFormat").ToLower());
                            // Set the default value
                            fdEnumFormat.InitExpression = new Refly.CodeDom.Expressions.SnippetExpression("\"g\"");
                            // Add its public property with a comment
                            Refly.CodeDom.PropertyDeclaration pdEnumFormat = cd.AddProperty(fdEnumFormat, true, true, false);
                            pdEnumFormat.Doc.Summary.AddText("'format' used by System.Enum.Format() in " + pdType.Name);                             // Create the <summary />
                        }
                    }
                }

                if (type.IsMixed)                // used by elements like <param>
                {
                    // Add the field with its default value
                    Refly.CodeDom.FieldDeclaration fd = cd.AddField("System.String", "Content");
                    // Add the unspecified value (to know if specified by the user)
                    fd.InitExpression = new Refly.CodeDom.Expressions.SnippetExpression("null");
                    // Add its public property with a comment
                    Refly.CodeDom.PropertyDeclaration pd = cd.AddProperty(fd, true, true, false);
                    pd.Doc.Summary.AddText(" Gets or sets the content of this element ");                     // Create the <summary />
                }
            }
            else
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder();
                sb.Append("Unknow Element: ").Append(attElt.Name);
                if (attElt.SchemaType != null)
                {
                    sb.Append(", SchemaType = ").Append(attElt.SchemaType).Append(" - ").Append(attElt.SchemaType.Name);
                }
                if (!attElt.SchemaTypeName.IsEmpty)
                {
                    sb.Append(", SchemaTypeName = ").Append(attElt.SchemaTypeName.Name);
                }
                if (attElt.ElementType != null)
                {
                    sb.Append(", ElementType = ").Append(attElt.ElementType);
                }
                log.Warn(sb.ToString());
            }
        }
        static void Main()
        {
            try
            {
                log.Info("Generation of NHibernate.Mapping.Attributes");

                // Open the Schema (in /NHMA/ directory)
                System.Xml.XmlTextReader reader = new System.Xml.XmlTextReader("../../../../NHibernate.Mapping.Attributes/nhibernate-mapping.xsd");
                schema = System.Xml.Schema.XmlSchema.Read(reader, null);

                Refly.CodeDom.NamespaceDeclaration nd = new Refly.CodeDom.NamespaceDeclaration("NHibernate.Mapping.Attributes", conformer);
                nd.Imports.Clear();                 // remove "using System;"
                conformer.Capitalize = true;
                Refly.CodeDom.ClassDeclaration hbmWriter = nd.AddClass("HbmWriter");
                hbmWriter.Attributes = System.Reflection.TypeAttributes.Public;
                hbmWriter.Doc.Summary.AddText(" Write a XmlSchemaElement from attributes in a System.Type. ");                 // Create the <summary />

                Refly.CodeDom.FieldDeclaration fdDefaultHelper = hbmWriter.AddField("HbmWriterHelper", "DefaultHelper");
                fdDefaultHelper.InitExpression = new Refly.CodeDom.Expressions.SnippetExpression("new HbmWriterHelperEx()");
                // Add its public property with a comment
                Refly.CodeDom.PropertyDeclaration pdDefaultHelper = hbmWriter.AddProperty(fdDefaultHelper, true, true, false);
                pdDefaultHelper.Doc.Summary.AddText(" Gets or sets the HbmWriterHelper used by HbmWriter ");                 // Create the <summary />

                Refly.CodeDom.FieldDeclaration fdStartQuote = hbmWriter.AddField(typeof(string), "StartQuote");
                // Add its public property with a comment
                Refly.CodeDom.PropertyDeclaration pdStartQuote = hbmWriter.AddProperty(fdStartQuote, false, true, false);
                pdStartQuote.Get.Add(new Refly.CodeDom.Expressions.SnippetExpression(@"if(_startQuote==null || _startQuote.Length==0)
					_startQuote = ""{{"";
				return _startQuote"                ));
                pdStartQuote.Doc.Summary.AddText(" Gets or sets the beginning string used when declaring an identifier for an AttributeIdenfierAttribute ");                 // Create the <summary />

                Refly.CodeDom.FieldDeclaration fdEndQuote = hbmWriter.AddField(typeof(string), "EndQuote");
                // Add its public property with a comment
                Refly.CodeDom.PropertyDeclaration pdEndQuote = hbmWriter.AddProperty(fdEndQuote, false, true, false);
                pdEndQuote.Get.Add(new Refly.CodeDom.Expressions.SnippetExpression(@"if(_endQuote==null || _endQuote.Length==0)
					_endQuote = ""}}"";
				return _endQuote"                ));
                pdEndQuote.Doc.Summary.AddText(" Gets or sets the ending string used when declaring an identifier for an AttributeIdenfierAttribute ");                 // Create the <summary />

                Refly.CodeDom.FieldDeclaration fdPatterns = hbmWriter.AddField(typeof(System.Collections.Hashtable), "Patterns");
                // Add its public property with a comment
                Refly.CodeDom.PropertyDeclaration pdPatterns = hbmWriter.AddProperty(fdPatterns, false, true, false);
                pdPatterns.Get.Add(new Refly.CodeDom.Expressions.SnippetExpression(@"if(_patterns==null)
				{
					_patterns = new System.Collections.Hashtable();
					_patterns.Add(@""Nullables.Nullable(\w+), Nullables"", ""Nullables.NHibernate.Nullable$1Type, Nullables.NHibernate"");
					_patterns.Add(@""System.Data.SqlTypes.Sql(\w+), System.Data"", ""NHibernate.UserTypes.SqlTypes.Sql$1Type, NHibernate.UserTypes.SqlTypes"");
				}
				return _patterns"                ));
                pdPatterns.Doc.Summary.AddText(" Gets or sets the Patterns to convert properties types (the key is the pattern string and the value is the replacement string) ");                 // Create the <summary />

                HbmWriterGenerator.FillFindAttributedMembers(hbmWriter.AddMethod("FindAttributedMembers"));
                HbmWriterGenerator.FillGetSortedAttributes(hbmWriter.AddMethod("GetSortedAttributes"));
                HbmWriterGenerator.FillIsNextElement(hbmWriter.AddMethod("IsNextElement"), schema.Items);
                HbmWriterGenerator.FillGetXmlEnumValue(hbmWriter.AddMethod("GetXmlEnumValue"));
                HbmWriterGenerator.FillGetAttributeValue(hbmWriter.AddMethod("GetAttributeValue"));
                HbmWriterGenerator.FillWriteUserDefinedContent(hbmWriter.AddMethod("WriteUserDefinedContent"),
                                                               hbmWriter.AddMethod("WriteUserDefinedContent"));


                log.Info("Browse Schema.Items (Count=" + schema.Items.Count + ")");
                foreach (System.Xml.Schema.XmlSchemaObject obj in schema.Items)
                {
                    if (obj is System.Xml.Schema.XmlSchemaAttributeGroup)
                    {
                        // Ignore (used by Elements: <xs:attributeGroup ref="..." />)
                        log.Debug("Ignore AttributeGroup: " + (obj as System.Xml.Schema.XmlSchemaAttributeGroup).Name + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
                    }
                    else if (obj is System.Xml.Schema.XmlSchemaGroup)
                    {
                        // Ignore (used by Elements: <xs:group ref="..." />)
                        log.Debug("Ignore Group: " + (obj as System.Xml.Schema.XmlSchemaGroup).Name + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
                    }
                    else if (obj is System.Xml.Schema.XmlSchemaSimpleType)
                    {
                        System.Xml.Schema.XmlSchemaSimpleType elt = obj as System.Xml.Schema.XmlSchemaSimpleType;
                        log.Debug("Generate Enumeration for SimpleType: " + elt.Name + string.Format(", nh-mapping.xsd({0})", elt.LineNumber));
                        AttributeAndEnumGenerator.GenerateEnumeration(elt, nd.AddEnum(Utils.Capitalize(elt.Name), false));
                    }
                    else if (obj is System.Xml.Schema.XmlSchemaElement)
                    {
                        System.Xml.Schema.XmlSchemaElement     elt  = obj as System.Xml.Schema.XmlSchemaElement;
                        System.Xml.Schema.XmlSchemaComplexType type = null;
                        if (!elt.SchemaTypeName.IsEmpty)                        // eg:  <xs:element name="cache" type="cacheType" />
                        {
                            foreach (System.Xml.Schema.XmlSchemaObject o in schema.Items)
                            {
                                System.Xml.Schema.XmlSchemaComplexType t = o as System.Xml.Schema.XmlSchemaComplexType;
                                if (t != null && t.Name == elt.SchemaTypeName.Name)
                                {
                                    type = t;
                                    break;
                                }
                            }
                        }
                        string eltName = Utils.Capitalize(elt.Name);
                        log.Debug("Generate Attrib and EltWriter for Elt: " + elt.Name + string.Format(", nh-mapping.xsd({0})", elt.LineNumber));
                        AttributeAndEnumGenerator.GenerateAttribute(elt, nd.AddClass(eltName + "Attribute"), type);
                        HbmWriterGenerator.GenerateElementWriter(elt, eltName, hbmWriter.AddMethod("Write" + eltName), type, schema.Items);
                        if (Utils.IsRoot(eltName))
                        {
                            HbmWriterGenerator.FillWriteNestedTypes(eltName, hbmWriter.AddMethod("WriteNested" + eltName + "Types"));
                        }
                    }
                    else if (obj is System.Xml.Schema.XmlSchemaComplexType)
                    {
                        // Ignore (Note: Make sure that it is used by Elements only like this: <xs:element name="XXX" type="YYY" />)
                        System.Xml.Schema.XmlSchemaComplexType elt = obj as System.Xml.Schema.XmlSchemaComplexType;
                        log.Debug("Don't generate ComplexType: " + elt.Name + string.Format(", nh-mapping.xsd({0})", elt.LineNumber));                         // like <query> and <sql-query>
                    }
                    else
                    {
                        log.Warn("Unknown Object: " + obj.ToString() + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
                    }
                }


                // Generate the source code
                // Note: NameConformer.WordSplit() has been replaced in Refly.
                Refly.CodeDom.CodeGenerator gen = new Refly.CodeDom.CodeGenerator();
                gen.Options.IndentString = "	";                 // Tab
                gen.CreateFolders        = false;
                #region Copyright
                gen.Copyright = string.Format(@"
 NHibernate.Mapping.Attributes
 This product is under the terms of the GNU Lesser General Public License.


------------------------------------------------------------------------------
 <autogenerated>
     This code was generated by a tool.
     Runtime Version: {0}.{1}.{2}.x

     Changes to this file may cause incorrect behavior and will be lost if 
     the code is regenerated.
 </autogenerated>
------------------------------------------------------------------------------


 This source code was auto-generated by Refly, Version={3} (modified).
",
                                              System.Environment.Version.Major, System.Environment.Version.Minor, System.Environment.Version.Build,
                                              gen.GetType().Assembly.GetName(false).Version);
                #endregion

                log.Info("CodeGenerator.GenerateCode()... Classes=" + nd.Classes.Count + ", Enums=" + nd.Enums.Count);
                gen.GenerateCode(@"../../../../NHibernate.Mapping.Attributes", nd);
                log.Info("Done !");
            }
            catch (System.Exception ex)
            {
                log.Error("Unexpected Exception", ex);
            }
        }
Esempio n. 8
0
		// 3.4.4 Element Locally Valid (Complex Type)
		// FIXME: use SchemaInfo for somewhere (? it is passed to ValidateEndOfAttributes() for some reason)
		private void AssessCloseStartElementLocallyValidComplexType (ComplexType cType, XmlSchemaInfo info)
		{
			// 1.
			if (cType.IsAbstract) {
				HandleError ("Target complex type is abstract.");
				return;
			}

			// 2 (xsi:nil and content prohibition)
			// See AssessStartElementSchemaValidity() and ValidateCharacters()
			// 3. attribute uses and  5. wild IDs are handled at
			// ValidateAttribute(), except for default/fixed values.

			// Collect default attributes.
			// 4.
			foreach (XsAttribute attr in GetExpectedAttributes ()) {
				if (attr.ValidatedUse == XmlSchemaUse.Required && 
					attr.ValidatedFixedValue == null)
					HandleError ("Required attribute " + attr.QualifiedName + " was not found.");
				else if (attr.ValidatedDefaultValue != null || attr.ValidatedFixedValue != null)
					defaultAttributesCache.Add (attr);
			}
			if (defaultAttributesCache.Count == 0)
				defaultAttributes = emptyAttributeArray;
			else
				defaultAttributes = (XsAttribute []) 
					defaultAttributesCache.ToArray (
						typeof (XsAttribute));
			defaultAttributesCache.Clear ();
			// 5. wild IDs was already checked at ValidateAttribute().

			// 3. - handle default attributes
#region ID Constraints
			if (!IgnoreIdentity) {
				foreach (XsAttribute a in defaultAttributes) {
					var atype = a.AttributeType as XmlSchemaDatatype ?? a.AttributeSchemaType.Datatype;
					object avalue = a.ValidatedFixedValue ?? a.ValidatedDefaultValue;
					string error = idManager.AssessEachAttributeIdentityConstraint (atype, avalue, ((QName) elementQNameStack [elementQNameStack.Count - 1]).Name);
					if (error != null)
						HandleError (error);
				}
			}
#endregion

#region Key Constraints
			if (!IgnoreIdentity)
				foreach (XsAttribute a in defaultAttributes)
					ValidateKeyFieldsAttribute (a, a.ValidatedFixedValue ?? a.ValidatedDefaultValue);
#endregion
		}
Esempio n. 9
0
        /// <summary>
        /// Compile this type
        /// </summary>
        public void Compile()
        {
            if (compiled)
            {
                return;
            }

            System.Xml.Schema.XmlSchemaComplexType type = (schemaPtr as System.Xml.Schema.XmlSchemaComplexType);

            // Load attributes (HL7 schemas like AttributeUses
            foreach (System.Xml.Schema.XmlSchemaObject o in type.AttributeUses.Values)
            {
                if (o is System.Xml.Schema.XmlSchemaAttributeGroup)
                {
                    foreach (System.Xml.Schema.XmlSchemaObject xso in (o as System.Xml.Schema.XmlSchemaAttributeGroup).Attributes)
                    {
                        RegisterAttribute(xso as System.Xml.Schema.XmlSchemaAttribute);
                    }
                }
                else if (o is System.Xml.Schema.XmlSchemaAttribute && (o as System.Xml.Schema.XmlSchemaAttribute).Name != null)
                {
                    RegisterAttribute(o as System.Xml.Schema.XmlSchemaAttribute);
                }
            }

            // Load Complex Elements
            if (type.Particle != null)
            {
                RegisterContent(type.Particle);
            }
            else if (type.ContentModel is System.Xml.Schema.XmlSchemaComplexContent)
            {
                // Correct base class if possible
                if (BaseClass == null && type.ContentModel.Content is System.Xml.Schema.XmlSchemaComplexContentExtension) // Determine base class
                {
                    this.BaseClass = Schema.FindType((type.ContentModel.Content as System.Xml.Schema.XmlSchemaComplexContentExtension).BaseTypeName.Name);
                }

                // Go through the particle(s)
                if (type.ContentModel.Content is System.Xml.Schema.XmlSchemaComplexContentExtension)
                {
                    RegisterContent((type.ContentModel.Content as System.Xml.Schema.XmlSchemaComplexContentExtension).Particle);
                }
                else if (type.ContentModel.Content is System.Xml.Schema.XmlSchemaComplexContentRestriction)
                {
                    RegisterRestriction((type.ContentModel.Content as System.Xml.Schema.XmlSchemaComplexContentRestriction).Particle);
                }

                // If sequence is null then create an empty one
                if (Content == null)
                {
                    content = new XmlSchemaSequence(Schema, this);
                }
            }
            else
            {
                // Simple content
            }

            compiled = true;
        }
 public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) {
     NorthwindDataSet ds = new NorthwindDataSet();
     System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
     System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
     xs.Add(ds.GetSchemaSerializable());
     if (PublishLegacyWSDL()) {
         System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
         any.Namespace = ds.Namespace;
         sequence.Items.Add(any);
     }
     else {
         System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
         any1.Namespace = "http://www.w3.org/2001/XMLSchema";
         any1.MinOccurs = new decimal(0);
         any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
         sequence.Items.Add(any1);
         System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
         any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
         any2.MinOccurs = new decimal(0);
         any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
         sequence.Items.Add(any2);
         sequence.MaxOccurs = decimal.MaxValue;
         System.Xml.Schema.XmlSchemaAttribute attribute = new System.Xml.Schema.XmlSchemaAttribute();
         attribute.Name = "namespace";
         attribute.FixedValue = ds.Namespace;
         type.Attributes.Add(attribute);
     }
     type.Particle = sequence;
     return type;
 }
Esempio n. 11
0
        /// <summary> Add the content of the method IsNextElement(). </summary>
        public static void FillIsNextElement(Refly.CodeDom.MethodDeclaration method, System.Xml.Schema.XmlSchemaObjectCollection schemaItems)
        {
            method.Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.Overloaded;
            method.Doc.Summary.AddText(" Tells if 'element1' come after 'element2' in rootType's 'sub-elements' order. ");             // Create the <summary />
            method.Signature.Parameters.Add("BaseAttribute", "element1");
            method.Signature.Parameters.Add("BaseAttribute", "baseAttrib");
            method.Signature.Parameters.Add(typeof(System.Type), "typeOfElement2");
            method.Signature.ReturnType = new Refly.CodeDom.TypeTypeDeclaration(typeof(bool));

            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                @"if( element1 == null )
				return false;"                ));

            foreach (System.Xml.Schema.XmlSchemaObject obj in schemaItems)
            {
                if (obj is System.Xml.Schema.XmlSchemaElement)
                {
                    System.Xml.Schema.XmlSchemaElement elt = obj as System.Xml.Schema.XmlSchemaElement;
                    method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
			if( baseAttrib is "             + Utils.Capitalize(elt.Name) + @"Attribute )
			{"            ));

                    if (elt.SchemaType is System.Xml.Schema.XmlSchemaComplexType)
                    {
                        System.Xml.Schema.XmlSchemaComplexType type = elt.SchemaType as System.Xml.Schema.XmlSchemaComplexType;

                        // Add the elements
                        if (type.Particle is System.Xml.Schema.XmlSchemaSequence)
                        {
                            System.Xml.Schema.XmlSchemaSequence seq     = (elt.SchemaType as System.Xml.Schema.XmlSchemaComplexType).Particle as System.Xml.Schema.XmlSchemaSequence;
                            System.Collections.ArrayList        members = Utils.GetElements(seq.Items, schemaItems);
                            for (int i = 0; i < members.Count; i++)
                            {
                                System.Xml.Schema.XmlSchemaElement member = members[i] as System.Xml.Schema.XmlSchemaElement;
                                if (member.RefName.Name == string.Empty)
                                {
                                    continue;                                                            // Ignore elements like <query> and <sql-query>
                                }
                                string memberName = Utils.Capitalize(member.Name + member.RefName.Name); // One of them is empty

                                System.Text.StringBuilder sb = new System.Text.StringBuilder();
                                sb.Append(
                                    @"	if( typeOfElement2 == typeof("+ memberName + @"Attribute) )
				{
					if( "                    );
                                for (int j = i + 1; j < members.Count; j++)
                                {
                                    System.Xml.Schema.XmlSchemaElement nextMember = members[j] as System.Xml.Schema.XmlSchemaElement;
                                    if (nextMember.RefName.Name == string.Empty)
                                    {
                                        continue;                                                                        // Ignore elements like <query> and <sql-query>
                                    }
                                    string nextMemberName = Utils.Capitalize(nextMember.Name + nextMember.RefName.Name); // One of them is empty
                                    sb.Append("element1 is " + nextMemberName + "Attribute || ");
                                }
                                // Add "typeOfElement2 == null" at the end to handle "||" and empty "if()" without compilation warning
                                sb.Append(@"typeOfElement2 == null )
						return true;
				}"                );
                                method.Body.Add(Refly.CodeDom.Stm.Snippet(sb.ToString()));
                            }
                        }
                    }
                    method.Body.Add(Refly.CodeDom.Stm.Snippet("}"));
                }
            }

            method.Body.Add(Refly.CodeDom.Stm.Snippet("return false;"));
            // -----------------------------------------------------------------
        }
Esempio n. 12
0
        /// <summary> Generate a Writer method for a XmlSchemaElement. </summary>
        public static void GenerateElementWriter(System.Xml.Schema.XmlSchemaElement schemaElt, string schemaEltName, Refly.CodeDom.MethodDeclaration method, System.Xml.Schema.XmlSchemaComplexType refSchemaType, System.Xml.Schema.XmlSchemaObjectCollection schemaItems)
        {
            bool schemaEltIsRoot = Utils.IsRoot(schemaEltName);

            method.Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.Overloaded;
            method.Doc.Summary.AddText(" Write a " + schemaEltName + " XML Element from attributes in a " + (schemaEltIsRoot?"type":"member") + ". ");             // Create the <summary />
            method.Signature.Parameters.Add(typeof(System.Xml.XmlWriter), "writer");
            if (schemaEltIsRoot)
            {
                method.Signature.Parameters.Add(typeof(System.Type), "type");
            }
            else
            {
                method.Signature.Parameters.Add(typeof(System.Reflection.MemberInfo), "member");
                method.Signature.Parameters.Add(schemaEltName + "Attribute", "attribute");
                method.Signature.Parameters.Add("BaseAttribute", "parentAttribute");
                method.Signature.Parameters.Add(typeof(System.Type), "mappedClass");
            }

            // Beginning of the method's body
            if (schemaEltIsRoot)
            {
                method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
                                                              @"object[] attributes = {1}.GetCustomAttributes(typeof({0}Attribute), false);
			if(attributes.Length == 0)
				return;
			{0}Attribute attribute = attributes[0] as {0}Attribute;
", schemaEltName, schemaEltIsRoot ? "type" : "member"))); // Note : Root should never allow multiple !
            }
            method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
                                                          "writer.WriteStartElement( \"{0}\" );", schemaElt.Name)));


            System.Xml.Schema.XmlSchemaComplexType type = schemaElt.SchemaType as System.Xml.Schema.XmlSchemaComplexType;
            if (type == null && !schemaElt.SchemaTypeName.IsEmpty)            // eg:  <xs:element name="cache" type="cacheType" />
            {
                type = refSchemaType;
            }

            if (type != null)
            {
                // Add the attributes
                System.Collections.ArrayList attributes = Utils.GetAttributes(type.Attributes);
                log.Debug("Add Attributes: Count=" + attributes.Count);
                foreach (System.Xml.Schema.XmlSchemaAttribute attrib in attributes)
                {
                    string attribName       = attrib.Name + attrib.RefName.Name;               // One is empty
                    string methodAttribName = "attribute." + Utils.Capitalize(attribName);
                    method.Body.Add(Refly.CodeDom.Stm.Comment("Attribute: <" + attribName + ">"));

                    // If the attribute is not explicitly marked required, then we consider it optionnal
                    if (attrib.Use != System.Xml.Schema.XmlSchemaUse.Required)
                    {
                        if ("System.Boolean" == Utils.GetAttributeTypeName(schemaElt, attrib))
                        {
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                                string.Format(@"if( {0} )", methodAttribName + "Specified")));
                        }
                        else
                        {
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                                string.Format(@"if({0} != {1})", methodAttribName,
                                                              Utils.GetUnspecifiedValue(schemaElt, attrib))));
                        }
                    }
                    // Write the value
                    if (attrib.Use == System.Xml.Schema.XmlSchemaUse.Required)
                    {
                        // Here, we use a helper if the field is not specified (mainly used for "name" which is the name of the member)
                        log.Debug("  Create Helper for " + (schemaEltIsRoot ? "ClassType" : "MemberInfo") + " <" + schemaElt.Name + "> <" + attribName + ">");
                        string helper = string.Format(@"{0}=={1} ? DefaultHelper.Get_{2}_{3}_DefaultValue({4}) : ",                          // "typed" method name :)
                                                      methodAttribName, Utils.GetUnspecifiedValue(schemaElt, attrib), schemaEltName,
                                                      Utils.Capitalize(attribName),
                                                      schemaEltIsRoot ? "type" : "member");
                        method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                            string.Format(@"writer.WriteAttributeString(""{0}"", {2}{1});",
                                                          attribName, AttributeToXmlValue(schemaElt, attrib, attribName, schemaEltIsRoot), helper)));
                    }
                    else
                    {
                        method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                            string.Format(@"writer.WriteAttributeString(""{0}"", {1});",
                                                          attribName, AttributeToXmlValue(schemaElt, attrib, attribName, schemaEltIsRoot))));
                        if (schemaEltName == "Property" && attribName == "type")
                        {
                            // Special case to handle Patterns for <property ... type="..." />
                            // Eg: set Nullables.NHibernate.NullableXXXType for Nullables.NullableXXX
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(@"else
			{
				System.Type type = null;
				if(member is System.Reflection.PropertyInfo)
					type = (member as System.Reflection.PropertyInfo).PropertyType;
				else if(member is System.Reflection.FieldInfo)
					type = (member as System.Reflection.FieldInfo).FieldType;
				if(type != null) // Transform using RegularExpressions
				{
					string typeName = HbmWriterHelper.GetNameWithAssembly(type);
					foreach(System.Collections.DictionaryEntry pattern in Patterns)
					{
						if(System.Text.RegularExpressions.Regex.IsMatch(typeName, pattern.Key as string))
						{
							writer.WriteAttributeString( ""type"",
								System.Text.RegularExpressions.Regex.Replace(typeName,
									pattern.Key as string,
									pattern.Value as string) );
							break;
						}
					}
				}
			}"            ));
                        }
                    }
                }

                // Add the elements
                method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                    schemaEltIsRoot ? @"
			WriteUserDefinedContent(writer, type, null, attribute);"             : @"
			WriteUserDefinedContent(writer, member, null, attribute);"
                                    ));

                if (type.Particle is System.Xml.Schema.XmlSchemaSequence)
                {
                    System.Xml.Schema.XmlSchemaSequence seq     = (schemaElt.SchemaType as System.Xml.Schema.XmlSchemaComplexType).Particle as System.Xml.Schema.XmlSchemaSequence;
                    System.Collections.ArrayList        members = Utils.GetElements(seq.Items, schemaItems);
                    if (!schemaEltIsRoot)
                    {
                        method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(@"
			System.Collections.ArrayList memberAttribs = GetSortedAttributes(member);
			int attribPos; // Find the position of the {0}Attribute (its <sub-element>s must be after it)
			for(attribPos=0; attribPos<memberAttribs.Count; attribPos++)
				if( memberAttribs[attribPos] is {0}Attribute
					&& ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position )
					break; // found
			int i = attribPos + 1;
", schemaEltName)));
                    }

                    foreach (System.Xml.Schema.XmlSchemaElement member in members)
                    {
                        if (member.RefName.Name != null && member.RefName.Name != string.Empty &&
                            member.Name != null && member.Name != string.Empty)
                        {
                            log.Error(string.Format("Both member.RefName.Name({0}) & member.Name({1}) are not empty", member.RefName.Name, member.Name));
                        }
                        string realMemberName = member.Name + member.RefName.Name;                         // One of them should be empty
                        string memberName     = Utils.Capitalize(realMemberName);
                        string listName       = memberName + "List";
                        string attributeName  = memberName + "Attribute";
                        log.Debug(schemaEltName + " Element: <" + realMemberName + ">");
                        method.Body.Add(Refly.CodeDom.Stm.Comment("Element: <" + realMemberName + ">"));
                        // There are three way to treat elements:
                        // if(eltName is root)
                        //     if(memberName is root)
                        //         => They are both root, so we process the nestedTypes (eg. <class> to <sub-class>)
                        //     else
                        //         => It is an element of a root => we add them as element
                        // else
                        //     => They are both members, so we use the member again (eg. <list> to <one-to-many>)
                        if (schemaEltIsRoot)
                        {
                            if (Utils.IsRoot(memberName))
                            {
                                method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
                                                                              @"WriteNested{0}Types(writer, type);", memberName)));
                            }
                            else
                            {
                                method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
                                                                              @"System.Collections.ArrayList {1} = FindAttributedMembers( attribute, typeof({2}), type );
			foreach( System.Reflection.MemberInfo member in {1} )
			"            , memberName, listName, attributeName) + "{"
                                                                          + string.Format(
                                                                              @"
				object[] objects = member.GetCustomAttributes(typeof({2}), false);
				System.Collections.ArrayList memberAttribs = new System.Collections.ArrayList();
				memberAttribs.AddRange(objects);
				memberAttribs.Sort();
" + (Utils.CanContainItself(memberName) ?
     // => Just take the first (others will be inside it)
     @"				Write{0}(writer, member, memberAttribs[0] as {2}, attribute, type);"
                                                                        :
     @"				foreach(object memberAttrib in memberAttribs)
					Write{0}(writer, member, memberAttrib as {2}, attribute, type);"                    ),
                                                                              memberName, listName, attributeName) + @"
			}"            ));
                            }
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                                "WriteUserDefinedContent(writer, type, typeof(" + attributeName + "), attribute);"));
                        }
                        else
                        {
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                                @"for(; i<memberAttribs.Count; i++)
			{
				BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute;
				if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType())
					|| IsNextElement(memberAttrib, attribute, typeof("                     + attributeName + @")) )
					break; // next attributes are 'elements' of the same level OR for 'sub-elements'"
                                                + (Utils.IsRoot(memberName) ? ""                  // A NotRoot can not contain a Root! eg. [DynComp] can't contain a [Comp] (instead, use [CompProp])
                                                                : @"
				else
				{"
                                                   + (Utils.CanContainItself(memberName) ? "" : @"
					if( memberAttrib is "                     + schemaEltName + @"Attribute )
						break; // Following attributes are for this "                         + schemaEltName) + @"
					if( memberAttrib is "                     + attributeName + @" )
						Write"                         + memberName + @"(writer, member, memberAttrib as " + attributeName + @", attribute, mappedClass);
				}"                ) + @"
			}"            ));
                            method.Body.Add(Refly.CodeDom.Stm.Snippet(
                                                "WriteUserDefinedContent(writer, member, typeof(" + attributeName + "), attribute);"));
                        }
                    }
                }

                if (type.IsMixed)                // used by elements like <param>
                {
                    method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
			// Write the content of this element (mixed=""true"")
			writer.WriteString(attribute.Content);"            ));
                }
            }
            else
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder();
                sb.Append("Unknow Element: ").Append(schemaElt.Name);
                if (schemaElt.SchemaType != null)
                {
                    sb.Append(", SchemaType = ").Append(schemaElt.SchemaType).Append(" - ").Append(schemaElt.SchemaType.Name);
                }
                if (!schemaElt.SchemaTypeName.IsEmpty)
                {
                    sb.Append(", SchemaTypeName = ").Append(schemaElt.SchemaTypeName.Name);
                }
                if (schemaElt.ElementSchemaType != null)
                {
                    sb.Append(", ElementType = ").Append(schemaElt.ElementSchemaType.Name);
                }
                log.Warn(sb.ToString());
            }

            method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
			writer.WriteEndElement();"            ));
        }