internal static bool IsSpecialXmlType(Type type, out XmlQualifiedName typeName, out XmlSchemaType xsdType, out bool hasRoot) { xsdType = null; hasRoot = true; if (type == Globals.TypeOfXmlElement || type == Globals.TypeOfXmlNodeArray) { string name = null; if (type == Globals.TypeOfXmlElement) { xsdType = CreateAnyElementType(); name = "XmlElement"; hasRoot = false; } else { xsdType = CreateAnyType(); name = "ArrayOfXmlNode"; hasRoot = true; } typeName = new XmlQualifiedName(name, DataContract.GetDefaultStableNamespace(type)); return true; } typeName = null; return false; }
public XQueryItem(object value, XmlSchemaType xmlType) { RawValue = value; if (xmlType == null) xmlType = XQuerySequenceType.XmlSchema.UntypedAtomic; _xmlType = xmlType; }
public override string ImportSchemaType(XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) { if (type == null) { return null; } if (importedTypes[type] != null) { mainNamespace.Imports.Add(new CodeNamespaceImport(typeof(DataSet).Namespace)); compileUnit.ReferencedAssemblies.Add("System.Data.dll"); return (string)importedTypes[type]; } if (!(context is XmlSchemaElement)) return null; if (type is XmlSchemaComplexType) { XmlSchemaComplexType ct = (XmlSchemaComplexType)type; if (ct.Particle is XmlSchemaSequence) { XmlSchemaObjectCollection items = ((XmlSchemaSequence)ct.Particle).Items; if (items.Count == 2 && items[0] is XmlSchemaAny && items[1] is XmlSchemaAny) { XmlSchemaAny any0 = (XmlSchemaAny)items[0]; XmlSchemaAny any1 = (XmlSchemaAny)items[1]; if (any0.Namespace == XmlSchema.Namespace && any1.Namespace == "urn:schemas-microsoft-com:xml-diffgram-v1") { string typeName = typeof(DataTable).FullName; importedTypes.Add(type, typeName); mainNamespace.Imports.Add(new CodeNamespaceImport(typeof(DataTable).Namespace)); compileUnit.ReferencedAssemblies.Add("System.Data.dll"); return typeName; } } } } return null; }
//public override string ImportSchemaType( // string name, // string ns, // XmlSchemaObject context, // XmlSchemas schemas, // XmlSchemaImporter importer, // CodeCompileUnit compileUnit, // CodeNamespace mainNamespace, // CodeGenerationOptions options, // CodeDomProvider codeProvider) //{ // XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType) schemas.Find(new XmlQualifiedName(name, ns), typeof(XmlSchemaSimpleType)); // return ImportSchemaType( // simpleType, // context, // schemas, // importer, // compileUnit, // mainNamespace, // options, // codeProvider); //} public override string ImportSchemaType( XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) { XmlSchemaAnnotated annotatedType = type as XmlSchemaAnnotated; if (annotatedType == null) return null; if (annotatedType.Annotation == null) return null; // create the comments and add them to the hash table under the namespace of the object CreateComments(annotatedType); //mainNamespace.Types. return null; }
//----------------------------------------------- // XmlAtomicValue constructors and methods //----------------------------------------------- internal XmlAtomicValue(XmlSchemaType xmlType, bool value) { if (xmlType == null) throw new ArgumentNullException(nameof(xmlType)); _xmlType = xmlType; _clrType = TypeCode.Boolean; _unionVal.boolVal = value; }
internal TypeDesc(string name, string fullName, XmlSchemaType dataType, TypeKind kind, TypeDesc baseTypeDesc, TypeFlags flags, string formatterName) { this.name = name.Replace('+', '.'); this.fullName = fullName.Replace('+', '.'); this.kind = kind; this.baseTypeDesc = baseTypeDesc; this.flags = flags; this.isXsdType = kind == TypeKind.Primitive; if (this.isXsdType) { this.weight = 1; } else if (kind == TypeKind.Enum) { this.weight = 2; } else if (this.kind == TypeKind.Root) { this.weight = -1; } else { this.weight = (baseTypeDesc == null) ? 0 : (baseTypeDesc.Weight + 1); } this.dataType = dataType; this.formatterName = formatterName; }
internal SchemaObjectInfo(XmlSchemaType type, XmlSchemaElement element, XmlSchema schema, List<XmlSchemaType> knownTypes) { this.type = type; this.element = element; this.schema = schema; this.knownTypes = knownTypes; }
/// <summary> /// Create a type in the schema object /// </summary> /// <param name="type">The type of schema to register</param> /// <param name="Name">The Name of the type</param> internal void CreateType(System.Xml.Schema.XmlSchemaType type, XmlQualifiedName Name) { if (Name == null || type == null) { return; } type.Name = Name.Name; // Copy target namespace(s) foreach (System.Xml.XmlQualifiedName s in type.Namespaces.ToArray()) { if (!namespaces.Contains(s.Name) && s.Name != null) { namespaces.Add(s.Name); } } if (type is System.Xml.Schema.XmlSchemaComplexType) { RegisterComplexType((System.Xml.Schema.XmlSchemaComplexType)type); } else { RegisterSimpleType((System.Xml.Schema.XmlSchemaSimpleType)type); } }
internal static CodeTypeDeclaration CreateClassDeclaration(XmlSchemaType type) { string className = CodeIdentifier.MakeValid(type.QualifiedName.Name); CodeTypeDeclaration codeClass = new CodeTypeDeclaration(className); codeClass.TypeAttributes |= TypeAttributes.Public; return codeClass; }
private void Init (DateTime value, XmlSchemaType xmlType) { if (xmlType == null) throw new ArgumentNullException ("xmlType"); xmlTypeCode = XmlTypeCode.DateTime; this.dateTimeValue = value; schemaType = xmlType; }
private void Init (bool value, XmlSchemaType xmlType) { if (xmlType == null) throw new ArgumentNullException ("xmlType"); xmlTypeCode = XmlTypeCode.Boolean; this.booleanValue = value; schemaType = xmlType; }
private void Init (byte [] value, XmlSchemaType xmlType) { if (xmlType == null) throw new ArgumentNullException ("xmlType"); xmlTypeCode = XmlTypeCode.Base64Binary; this.bytesValue = value; schemaType = xmlType; }
internal XmlNameEx(string prefix, string localName, string ns, int hashCode, XmlDocument ownerDoc, XmlName next, IXmlSchemaInfo schemaInfo) : base(prefix, localName, ns, hashCode, ownerDoc, next) { this.SetValidity(schemaInfo.Validity); this.SetIsDefault(schemaInfo.IsDefault); this.SetIsNil(schemaInfo.IsNil); this.memberType = schemaInfo.MemberType; this.schemaType = schemaInfo.SchemaType; this.decl = (schemaInfo.SchemaElement != null) ? ((object) schemaInfo.SchemaElement) : ((object) schemaInfo.SchemaAttribute); }
internal static void GetXmlTypeInfo(Type type, out XmlQualifiedName stableName, out XmlSchemaType xsdType, out bool hasRoot) { if (IsSpecialXmlType(type, out stableName, out xsdType, out hasRoot)) return; XmlSchemaSet schemas = null; InvokeSchemaProviderMethod(type, schemas, out stableName, out xsdType, out hasRoot); if (stableName.Name == null || stableName.Name.Length == 0) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.InvalidXmlDataContractName, DataContract.GetClrTypeFullName(type)))); }
internal XmlAtomicValue(XmlSchemaType xmlType, bool value) { if (xmlType == null) { throw new ArgumentNullException("xmlType"); } this.xmlType = xmlType; this.clrType = TypeCode.Boolean; this.unionVal.boolVal = value; }
internal XmlAtomicValue(XmlSchemaType xmlType, double value) { if (xmlType == null) { throw new ArgumentNullException("xmlType"); } this.xmlType = xmlType; this.clrType = TypeCode.Double; this.unionVal.dblVal = value; }
internal XmlAtomicValue(XmlSchemaType xmlType, long value) { if (xmlType == null) { throw new ArgumentNullException("xmlType"); } this.xmlType = xmlType; this.clrType = TypeCode.Int64; this.unionVal.i64Val = value; }
XObject[] CreateProtoAnyType(XmlSchemaType schemaType) { if ((schemaType as XmlSchemaComplexType) != null) { return CreateProtoComplexType(schemaType as XmlSchemaComplexType); } else if ((schemaType as XmlSchemaSimpleType) != null) { var value = CreateProtoSimpleType(schemaType as XmlSchemaSimpleType); return new XObject[] { new XText(value) }; } else { throw new Exception("invalid schema type"); } }
internal static void GetXmlTypeInfo(Type type, out XmlQualifiedName stableName, out XmlSchemaType xsdType, out bool hasRoot) { if (IsSpecialXmlType(type, out stableName, out xsdType, out hasRoot)) return; XmlSchemaSet schemas = new XmlSchemaSet(); schemas.XmlResolver = null; InvokeSchemaProviderMethod(type, schemas, out stableName, out xsdType, out hasRoot); if (stableName.Name == null || stableName.Name.Length == 0) throw Fx.Exception.AsError(new InvalidDataContractException(SR.InvalidXmlDataContractName(DataContract.GetClrTypeFullName(type)))); }
private static bool InvokeSchemaProviderMethod(Type clrType, XmlSchemaSet schemas, out XmlQualifiedName stableName, out XmlSchemaType xsdType, out bool hasRoot) { xsdType = null; hasRoot = true; object[] attrs = clrType.GetTypeInfo().GetCustomAttributes(Globals.TypeOfXmlSchemaProviderAttribute, false).ToArray(); if (attrs == null || attrs.Length == 0) { stableName = DataContract.GetDefaultStableName(clrType); return false; } XmlSchemaProviderAttribute provider = (XmlSchemaProviderAttribute)attrs[0]; if (provider.IsAny) { xsdType = CreateAnyElementType(); hasRoot = false; } string methodName = provider.MethodName; if (methodName == null || methodName.Length == 0) { if (!provider.IsAny) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.InvalidGetSchemaMethod, DataContract.GetClrTypeFullName(clrType)))); stableName = DataContract.GetDefaultStableName(clrType); } else { MethodInfo getMethod = clrType.GetMethod(methodName, /*BindingFlags.DeclaredOnly |*/ BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public, new Type[] { typeof(XmlSchemaSet) }); if (getMethod == null) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.MissingGetSchemaMethod, DataContract.GetClrTypeFullName(clrType), methodName))); if (!(Globals.TypeOfXmlQualifiedName.IsAssignableFrom(getMethod.ReturnType))) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.InvalidReturnTypeOnGetSchemaMethod, DataContract.GetClrTypeFullName(clrType), methodName, DataContract.GetClrTypeFullName(getMethod.ReturnType), DataContract.GetClrTypeFullName(Globals.TypeOfXmlQualifiedName)))); object typeInfo = getMethod.Invoke(null, new object[] { schemas }); if (provider.IsAny) { if (typeInfo != null) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.InvalidNonNullReturnValueByIsAny, DataContract.GetClrTypeFullName(clrType), methodName))); stableName = DataContract.GetDefaultStableName(clrType); } else if (typeInfo == null) { xsdType = CreateAnyElementType(); hasRoot = false; stableName = DataContract.GetDefaultStableName(clrType); } else { stableName = (XmlQualifiedName)typeInfo; } } return true; }
public override string ImportSchemaType (XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) { if (type == null) return null; var xe = context as XmlSchemaElement; if (xe == null) return null; return null; }
internal void Clear() { this.isNil = false; this.isDefault = false; this.schemaType = null; this.schemaElement = null; this.schemaAttribute = null; this.memberType = null; this.validity = XmlSchemaValidity.NotKnown; this.contentType = XmlSchemaContentType.Empty; }
public static void AssertElement (XmlSchemaElement element, string name, XmlQualifiedName refName, string id, XmlQualifiedName schemaTypeName, XmlSchemaType schemaType) { Assert.IsNotNull (element); Assert.AreEqual (name, element.Name); Assert.AreEqual (refName, element.RefName); Assert.AreEqual (id, element.Id); Assert.AreEqual (schemaTypeName, element.SchemaTypeName); Assert.AreEqual (schemaType, element.SchemaType); }
private static CompiledFacets GetFacets(XmlSchemaType type) { CompiledFacets compiledFacets = new CompiledFacets(type.Datatype); XmlSchemaSimpleType simpleType = type as XmlSchemaSimpleType; if(simpleType != null) { compiledFacets.compileFacets(simpleType); } return compiledFacets; }
protected void AssertElement (XmlSchemaElement element, string name, XmlQualifiedName refName, string id, XmlQualifiedName schemaTypeName, XmlSchemaType schemaType) { AssertNotNull (element); AssertEquals (name, element.Name); AssertEquals (refName, element.RefName); AssertEquals (id, element.Id); AssertEquals (schemaTypeName, element.SchemaTypeName); AssertEquals (schemaType, element.SchemaType); }
private static void WriteImageWithTopicLink(this MamlWriter writer, TopicManager topicManager, ArtItem artItem, XmlSchemaType type) { var topic = topicManager.GetTopic(type); if (topic != null) { writer.WriteHtmlArtItemWithTopicLink(artItem, topic); } else { writer.WriteHtmlArtItemWithText(artItem, type.QualifiedName.Name); } }
public virtual string ImportSchemaType ( XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider ) { return null; }
public XmlSampleGenerator(XmlSchemaSet schemaSet, XmlQualifiedName rootElem) { if (schemaSet == null || schemaSet.Count == 0) throw new Exception("Provided Schema set is empty. Xml cannot be generated."); this.schemaSet = schemaSet; schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack); if (xmlResolver == null) { xmlResolver = new XmlUrlResolver(); } schemaSet.XmlResolver = xmlResolver; rootElement = rootElem; AnyType = XmlSchemaType.GetBuiltInComplexType(XmlTypeCode.Item); }
internal XmlAtomicValue(XmlSchemaType xmlType, string value) { if (value == null) { throw new ArgumentNullException("value"); } if (xmlType == null) { throw new ArgumentNullException("xmlType"); } this.xmlType = xmlType; this.objVal = value; }
public override string ImportSchemaType(XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) { if ((!this.m_direct && (type is XmlSchemaSimpleType)) && (context is XmlSchemaElement)) { XmlQualifiedName qualifiedName = ((XmlSchemaSimpleType) type).BaseXmlSchemaType.QualifiedName; if ((string.CompareOrdinal(this.m_name, qualifiedName.Name) == 0) && (string.CompareOrdinal(this.m_targetNamespace, qualifiedName.Namespace) == 0)) { compileUnit.ReferencedAssemblies.AddRange(this.m_references); mainNamespace.Imports.AddRange(this.m_namespaceImports); return this.m_destinationType; } } return null; }
private static bool IsExpression(XmlSchemaType schemaType) { if (schemaType.Name == "Expression") { return true; } if (schemaType.BaseXmlSchemaType != null) { return IsExpression(schemaType.BaseXmlSchemaType); } return false; }
private static void AddPrimitive(Type type, string dataTypeName, string formatterName, TypeFlags flags) { XmlSchemaSimpleType dataType = new XmlSchemaSimpleType(); dataType.Name = dataTypeName; TypeDesc typeDesc = new TypeDesc(type, true, dataType, formatterName, flags); if (s_primitiveTypes[type] == null) { s_primitiveTypes.Add(type, typeDesc); } s_primitiveDataTypes.Add(dataType, typeDesc); s_primitiveNames.Add(dataTypeName, XmlSchema.Namespace, typeDesc); }
private static void AddNonXsdPrimitive(Type type, string dataTypeName, string ns, string formatterName, XmlQualifiedName baseTypeName, XmlSchemaFacet[] facets, TypeFlags flags) { XmlSchemaSimpleType dataType = new XmlSchemaSimpleType(); dataType.Name = dataTypeName; TypeDesc typeDesc = new TypeDesc(type, false, dataType, formatterName, flags); if (s_primitiveTypes[type] == null) { s_primitiveTypes.Add(type, typeDesc); } s_primitiveDataTypes.Add(dataType, typeDesc); s_primitiveNames.Add(dataTypeName, ns, typeDesc); }
private Parameter[] GetParameters(string messagePartName) { List <Parameter> parameters = new List <Parameter>(); //Types types = serviceDescription.Types; //System.Xml.Schema.XmlSchema xmlSchema = types.Schemas[0]; foreach (XmlSchemaElement schemaElement in e.GlobalElements.Values) { //} //foreach (object item in xmlSchema.Items) //{ // System.Xml.Schema.XmlSchemaElement schemaElement = item as System.Xml.Schema.XmlSchemaElement; if (schemaElement != null) { if (schemaElement.Name == messagePartName) { System.Xml.Schema.XmlSchemaType schemaType = schemaElement.SchemaType; System.Xml.Schema.XmlSchemaComplexType complexType = schemaType as System.Xml.Schema.XmlSchemaComplexType; if (complexType != null) { System.Xml.Schema.XmlSchemaParticle particle = complexType.Particle; System.Xml.Schema.XmlSchemaSequence sequence = particle as System.Xml.Schema.XmlSchemaSequence; if (sequence != null) { foreach (System.Xml.Schema.XmlSchemaElement childElement in sequence.Items) { string parameterName = childElement.Name; string parameterType = childElement.SchemaTypeName.Name; parameters.Add(new Parameter(parameterName, parameterType, null, null)); } } } break; } } } return(parameters.ToArray()); }
internal abstract XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType);
public static XmlValueConverter Create(XmlSchemaType schemaType) { return(new XmlNumeric10Converter(schemaType)); }
protected XmlNumeric10Converter(XmlSchemaType schemaType) : base(schemaType) { }
internal static XmlSchemaDatatype DeriveByUnion(XmlSchemaSimpleType[] types, XmlSchemaType schemaType) { return(DatatypeImplementation.DeriveByUnion(types, schemaType)); }
//----------------------------------------------- // XmlAtomicValue constructors and methods //----------------------------------------------- internal XmlAtomicValue(XmlSchemaType xmlType !!, bool value)
private ComplexType ToComplexType(Element el) { QName name = el.SchemaTypeName; XmlSchemaType type = el.SchemaType; // 1. element type is complex. ComplexType ct = type as ComplexType; if (ct != null) { return(ct); } // 2. reference to global complexType. XmlSchemaType globalType = schemas.GlobalTypes [name] as XmlSchemaType; ct = globalType as ComplexType; if (ct != null) { return(ct); } ct = new ComplexType(); el.SchemaType = ct; el.SchemaTypeName = QName.Empty; // 3. base type name is xs:anyType or no specification. // <xs:complexType /> if (name == QNameAnyType) { return(ct); } else if (type == null && name == QName.Empty) { return(ct); } SimpleModel sc = new SimpleModel(); ct.ContentModel = sc; // 4. type is simpleType // -> extension of existing simple type. SimpleType st = type as SimpleType; if (st != null) { SimpleRst scr = new SimpleRst(); scr.BaseType = st; sc.Content = scr; return(ct); } SimpleExt sce = new SimpleExt(); sc.Content = sce; // 5. type name points to primitive type // -> simple extension of a primitive type st = XmlSchemaType.GetBuiltInSimpleType(name); if (st != null) { sce.BaseTypeName = name; return(ct); } // 6. type name points to global simpleType. st = globalType as SimpleType; if (st != null) { sce.BaseTypeName = name; return(ct); } throw Error(el, "Unexpected schema component that contains simpleTypeName that could not be resolved."); }
internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { return(XmlMiscConverter.Create(schemaType)); }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { if (base.IsValidated(schema.ValidationId)) { return(this.errorCount); } ArrayList arrayList = new ArrayList(); if (this.MemberTypes != null) { foreach (XmlQualifiedName xmlQualifiedName in this.MemberTypes) { object obj = null; XmlSchemaType xmlSchemaType = schema.FindSchemaType(xmlQualifiedName) as XmlSchemaSimpleType; if (xmlSchemaType != null) { this.errorCount += xmlSchemaType.Validate(h, schema); obj = xmlSchemaType; } else if (xmlQualifiedName == XmlSchemaComplexType.AnyTypeName) { obj = XmlSchemaSimpleType.AnySimpleType; } else if (xmlQualifiedName.Namespace == "http://www.w3.org/2001/XMLSchema" || xmlQualifiedName.Namespace == "http://www.w3.org/2003/11/xpath-datatypes") { obj = XmlSchemaDatatype.FromName(xmlQualifiedName); if (obj == null) { base.error(h, "Invalid schema type name was specified: " + xmlQualifiedName); } } else if (!schema.IsNamespaceAbsent(xmlQualifiedName.Namespace)) { base.error(h, "Referenced base schema type " + xmlQualifiedName + " was not found in the corresponding schema."); } arrayList.Add(obj); } } if (this.BaseTypes != null) { foreach (XmlSchemaObject xmlSchemaObject in this.BaseTypes) { XmlSchemaSimpleType xmlSchemaSimpleType = (XmlSchemaSimpleType)xmlSchemaObject; xmlSchemaSimpleType.Validate(h, schema); arrayList.Add(xmlSchemaSimpleType); } } this.validatedTypes = arrayList.ToArray(); if (this.validatedTypes != null) { this.validatedSchemaTypes = new XmlSchemaSimpleType[this.validatedTypes.Length]; for (int j = 0; j < this.validatedTypes.Length; j++) { object obj2 = this.validatedTypes[j]; XmlSchemaSimpleType xmlSchemaSimpleType2 = obj2 as XmlSchemaSimpleType; if (xmlSchemaSimpleType2 == null && obj2 != null) { xmlSchemaSimpleType2 = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)obj2).TypeCode); } this.validatedSchemaTypes[j] = xmlSchemaSimpleType2; } } this.ValidationId = schema.ValidationId; return(this.errorCount); }
internal abstract XmlSchemaDatatype DeriveByList(XmlSchemaType schemaType);
internal void SetElementType(XmlSchemaType value) { elementType = value; }