//Called from Load/parse and auto-typing public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager, Type rootType, Type contentType) { XTypedElement rootElement = GetAnnotation(rootType, xe); if (rootElement == null) { //If not already created XName instanceElementName = xe.Name; //Storing the name since SetName() called from the functional const of rootType will update the name to that of the root type XTypedElement innerType = ToXTypedElement(xe, typeManager, contentType); Debug.Assert(innerType != null); ConstructorInfo constInfo = rootType.GetConstructor(new Type[] { contentType }); if (constInfo != null) { rootElement = (XTypedElement)constInfo.Invoke(new object[] { innerType }); } else { throw new LinqToXsdException(contentType.ToString() + " is not an expected content type for root element type " + rootType.ToString()); } if (!TypeValid(rootElement, instanceElementName)) { throw new LinqToXsdException("Element is not an instance of type " + rootType); } } return(rootElement); }
//Auto-typing public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager) { if (xe == null) { return(null); } XName elementName = xe.Name; Type clrType = null; Dictionary <XName, Type> elementDictionary = typeManager.GlobalElementDictionary; if (elementDictionary.TryGetValue(elementName, out clrType)) { //Check if its a root wrapper type Type contentType = null; if (typeManager.RootContentTypeMapping.TryGetValue(clrType, out contentType)) { return(ToXTypedElement(xe, typeManager, clrType, contentType)); } return(ToXTypedElement(xe, typeManager, clrType)); } Type xsiClrType = GetXsiClrType(xe, typeManager); //Check for global xsi:type, tag might be a fragment or unknown element name if (xsiClrType != null) { return(ToXTypedElement(xe, typeManager, xsiClrType)); } return(null); }
public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager) { XTypedElement xTypedElement; if (xe != null) { XName elementName = xe.Name; Type clrType = null; if (!typeManager.GlobalElementDictionary.TryGetValue(elementName, out clrType)) { Type xsiClrType = XTypedServices.GetXsiClrType(xe, typeManager); if (!(xsiClrType != null)) { xTypedElement = null; } else { xTypedElement = XTypedServices.ToXTypedElement(xe, typeManager, xsiClrType); } } else { Type contentType = null; xTypedElement = (!typeManager.RootContentTypeMapping.TryGetValue(clrType, out contentType) ? XTypedServices.ToXTypedElement(xe, typeManager, clrType) : XTypedServices.ToXTypedElement(xe, typeManager, clrType, contentType)); } } else { xTypedElement = null; } return(xTypedElement); }
private XTypedElement TypeChildElement(XElement element, Dictionary <XName, System.Type> localElementsDict, ILinqToXsdTypeManager typeManager) { Type clrType = null; XTypedElement childTypedElement = null; if (localElementsDict.TryGetValue(element.Name, out clrType)) { Type contentType = null; if (typeManager.RootContentTypeMapping.TryGetValue(clrType, out contentType)) { childTypedElement = XTypedServices.ToXTypedElement(element, typeManager, clrType, contentType); } else if (typeof(XTypedElement).IsAssignableFrom(clrType)) { //It can also be simple types childTypedElement = XTypedServices.ToXTypedElement(element, typeManager, clrType); } } else { //Type not found, fall-back to auto-typing childTypedElement = XTypedServices.ToXTypedElement(element, typeManager); } return(childTypedElement); }
public static W Load <W, T>(string uri, ILinqToXsdTypeManager typeManager) where W : XTypedElement where T : XTypedElement { XDocument doc = XDocument.Load(uri); return(XTypedServices.ToXTypedElement <W, T>(doc.Root, typeManager)); }
public static W Load <W, T>(string uri, ILinqToXsdTypeManager typeManager) where T : XTypedElement where W : XTypedElement { XDocument doc = XDocument.Load(uri); XElement xeroot = doc.Root; return(ToXTypedElement <W, T>(xeroot, typeManager)); }
public static W Load <W, T>(TextReader reader, ILinqToXsdTypeManager typeManager) where W : XTypedElement where T : XTypedElement { XDocument doc = XDocument.Load(reader); return(XTypedServices.ToXTypedElement <W, T>(doc.Root, typeManager)); }
public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager, System.Type t) { if (xe == null) { return(null); } if (!t.IsSubclassOf(typeof(XTypedElement))) { throw new InvalidOperationException("Type t is not a subtype of XTypedElement"); } if (typeManager == null) { throw new ArgumentNullException("typeManager"); } XTypedElement xoSubType = GetAnnotation(t, xe); //Try getting back as the type first, optimized for the cases where xsi:type cannot appear if (xoSubType == null) { //Try xsi:type and lookup in the typeDictionary Type clrType = GetXsiClrType(xe, typeManager); if (clrType != null) { xoSubType = GetAnnotation(clrType, xe); if (xoSubType != null) { return(xoSubType); } if (!t.IsAssignableFrom(clrType)) { //xsi:type is not subtype of schema type clrType = t; } } else { //xsi:type not present or CLRType not found for xsi:type name clrType = t; } if (clrType.IsAbstract) { throw new InvalidOperationException("Cannot cast XElement to an abstract type"); } ConstructorInfo constrInfo = clrType.GetConstructor(System.Type.EmptyTypes); xoSubType = (XTypedElement)constrInfo.Invoke(null); xoSubType.Untyped = xe; xe.AddAnnotation(new XTypedElementAnnotation(xoSubType)); } return(xoSubType); }
public static W Load <W, T>(System.IO.TextReader reader, ILinqToXsdTypeManager typeManager) where T : XTypedElement where W : XTypedElement { XDocument doc = XDocument.Load(reader); XElement xeroot = doc.Root; return(ToXTypedElement <W, T>(xeroot, typeManager)); }
internal static Type GetXsiClrType(XElement xe, ILinqToXsdTypeManager typeManager) { XName typeName = XTypedServices.GetXsiType(xe); Type clrType = null; if (typeName != null) { typeManager.GlobalTypeDictionary.TryGetValue(typeName, out clrType); } return(clrType); }
public static XTypedSubstitutedList <T> Initialize(XTypedElement container, ILinqToXsdTypeManager typeManager, IEnumerable <T> typedObjects, params XName[] itemXNames) { XTypedSubstitutedList <T> typedList = new XTypedSubstitutedList <T>(container, typeManager, itemXNames); typedList.Clear(); foreach (T typedItem in typedObjects) { typedList.Add(typedItem); } return(typedList); }
public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager, Type t) { XTypedElement xTypedElement; if (xe != null) { if (!t.IsSubclassOf(typeof(XTypedElement))) { throw new InvalidOperationException("Type t is not a subtype of XTypedElement"); } if (typeManager == null) { throw new ArgumentNullException("typeManager"); } XTypedElement xoSubType = XTypedServices.GetAnnotation(t, xe); if (xoSubType == null) { Type clrType = XTypedServices.GetXsiClrType(xe, typeManager); if (!(clrType != null)) { clrType = t; } else { xoSubType = XTypedServices.GetAnnotation(clrType, xe); if (xoSubType != null) { xTypedElement = xoSubType; return(xTypedElement); } if (!t.IsAssignableFrom(clrType)) { clrType = t; } } if (clrType.IsAbstract) { throw new InvalidOperationException("Cannot cast XElement to an abstract type"); } ConstructorInfo constrInfo = clrType.GetConstructor(Type.EmptyTypes); xoSubType = (XTypedElement)constrInfo.Invoke(null); xoSubType.Untyped = xe; xe.AddAnnotation(new XTypedElementAnnotation(xoSubType)); } xTypedElement = xoSubType; } else { xTypedElement = null; } return(xTypedElement); }
internal static System.Type GetXsiClrType(XElement xe, ILinqToXsdTypeManager typeManager) { XName typeName = GetXsiType(xe); Type clrType = null; if (typeName != null) { Dictionary <XName, Type> typeDictionary = typeManager.GlobalTypeDictionary; typeDictionary.TryGetValue(typeName, out clrType); } return(clrType); }
public static XTypedElement ToSubstitutedXTypedElement(XTypedElement parentType, ILinqToXsdTypeManager typeManager, params XName[] substitutedMembers) { XElement substElement = null; XElement parentElement = parentType.Untyped; int index = 0; while (substElement == null && index < substitutedMembers.Length) { substElement = parentType.GetElement(substitutedMembers[index++]); } if (substElement != null) { return(XTypedServices.ToXTypedElement(substElement, typeManager)); } return(null); }
public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager, Type rootType, Type contentType) { XTypedElement rootElement = XTypedServices.GetAnnotation(rootType, xe); if (rootElement == null) { XName instanceElementName = xe.Name; XTypedElement innerType = XTypedServices.ToXTypedElement(xe, typeManager, contentType); Debug.Assert(innerType != null); ConstructorInfo constInfo = rootType.GetConstructor(new Type[] { contentType }); if (!(constInfo != null)) { throw new LinqToXsdException(string.Concat(contentType.ToString(), " is not an expected content type for root element type ", rootType.ToString())); } object[] objArray = new object[] { innerType }; rootElement = (XTypedElement)constInfo.Invoke(objArray); if (!XTypedServices.TypeValid(rootElement, instanceElementName)) { throw new LinqToXsdException(string.Concat("Element is not an instance of type ", rootType)); } } return(rootElement); }
//XML Query axes IEnumerable <T> IXTyped.Descendants <T>() { XTypedElement currentObject = this as XTypedElement; Type lookupType = typeof(T); //Metadata IXMetaData schemaMetaData = currentObject as IXMetaData; Dictionary <XName, System.Type> localElementsDict = null; ILinqToXsdTypeManager typeManager = schemaMetaData.TypeManager; Dictionary <XName, Type> typeDictionary = typeManager.GlobalTypeDictionary; //FSM XName matchingName = null; WildCard matchingWildCard = null; int currentState = FSM.InvalidState; XElement parentElement = null; Stack <XTypedElement> elementStack = new Stack <XTypedElement>(); while (true) { schemaMetaData = currentObject as IXMetaData; FSM fsm = currentObject.ValidationStates; if (fsm != null) { StartFsm(); currentState = fsm.Start; } Debug.Assert(schemaMetaData != null); localElementsDict = schemaMetaData.LocalElementsDictionary; parentElement = currentObject.Untyped; matchingName = null; matchingWildCard = null; XTypedElement childObject = null; bool validContent = true; foreach (XElement childElement in parentElement.Elements()) { bool isTypeT = IsAnnoatedElemTypeOf <T>(childElement, out childObject); if (fsm != null) { //Always execute FSM no matter whether we find an element of type T currentState = FsmMakeTransition(currentState, childElement.Name, out matchingName, out matchingWildCard); if (currentState == FSM.InvalidState) { validContent = false; break; } } if (!isTypeT) { //check dictionary if (fsm != null && matchingWildCard != null) { childObject = XTypedServices.ToXTypedElement(childElement, typeManager); //Auto-typing } else { childObject = TypeChildElement(childElement, localElementsDict, typeManager); } if (childObject != null) { Type runtimeType = childObject.GetType(); if (lookupType.IsAssignableFrom(runtimeType)) { isTypeT = true; } else { //Check content type Type contentType = null; if (typeManager.RootContentTypeMapping.TryGetValue(runtimeType, out contentType) && lookupType.IsAssignableFrom(contentType)) { childObject = GetContentType(childObject); isTypeT = true; } } } } if (isTypeT) { yield return((T)childObject); } if (childObject != null) { elementStack.Push(childObject); } } if (validContent && elementStack.Count > 0) { currentObject = elementStack.Pop(); } else { break; } } }
public static XTypedElement ToXTypedElement(XElement xe, ILinqToXsdTypeManager typeManager, System.Type t) { if (xe == null) { return(null); } if (!t.IsSubclassOf(typeof(XTypedElement))) { throw new InvalidOperationException("Type t is not a subtype of XTypedElement"); } if (typeManager == null) { throw new ArgumentNullException("typeManager"); } //Try getting back as the type first, optimized for the cases where xsi:type cannot appear XTypedElement xoSubType = GetAnnotation(t, xe); if (xoSubType == null) { //Try xsi:type and lookup in the typeDictionary Type clrType = GetXsiClrType(xe, typeManager); if (clrType != null) { xoSubType = GetAnnotation(clrType, xe); if (xoSubType != null) { return(xoSubType); } if (!t.IsAssignableFrom(clrType)) { //xsi:type is not subtype of schema type clrType = t; } } else { //xsi:type not present or CLRType not found for xsi:type name clrType = t; } if (clrType.IsAbstract) { throw new InvalidOperationException("Cannot cast XElement to an abstract type"); } // get public or instance var exactBinding = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance; ConstructorInfo constrInfo = clrType.GetConstructor(exactBinding, null, Type.EmptyTypes, null); if (constrInfo == null) { throw new TypeAccessException($"There is no public/internal parameter-less constructor for type: {clrType.FullName}"); } xoSubType = (XTypedElement)constrInfo.Invoke(null); xoSubType.Untyped = xe; xe.AddAnnotation(new XTypedElementAnnotation(xoSubType)); } return(xoSubType); }
public static T ToXTypedElement <T>(XElement xe, ILinqToXsdTypeManager typeManager) where T : XTypedElement { return((T)(XTypedServices.ToXTypedElement(xe, typeManager, typeof(T)) as T)); }
public static W ToXTypedElement <W, T>(XElement xe, ILinqToXsdTypeManager typeManager) where W : XTypedElement where T : XTypedElement { return((W)XTypedServices.ToXTypedElement(xe, typeManager, typeof(W), typeof(T))); }
public static XTypedElement ToSubstitutedXTypedElement(XTypedElement parentType, ILinqToXsdTypeManager typeManager, params XName[] substitutedMembers) { XTypedElement xTypedElement; XElement substElement = null; XElement parentElement = parentType.Untyped; int index = 0; while (true) { if ((substElement != null ? true : index >= (int)substitutedMembers.Length)) { break; } int num = index; index = num + 1; substElement = parentType.GetElement(substitutedMembers[num]); } if (substElement == null) { xTypedElement = null; } else { xTypedElement = XTypedServices.ToXTypedElement(substElement, typeManager); } return(xTypedElement); }
public static W Parse <W, T>(string xml, ILinqToXsdTypeManager typeManager) where W : XTypedElement where T : XTypedElement { return(XTypedServices.ToXTypedElement <W, T>(XElement.Parse(xml), typeManager)); }
private XTypedElement TypeChildElement(XElement element, Dictionary <XName, Type> localElementsDict, ILinqToXsdTypeManager typeManager) { Type clrType = null; XTypedElement childTypedElement = null; if (!localElementsDict.TryGetValue(element.Name, out clrType)) { childTypedElement = XTypedServices.ToXTypedElement(element, typeManager); } else { Type contentType = null; if (typeManager.RootContentTypeMapping.TryGetValue(clrType, out contentType)) { childTypedElement = XTypedServices.ToXTypedElement(element, typeManager, clrType, contentType); } else if (typeof(XTypedElement).IsAssignableFrom(clrType)) { childTypedElement = XTypedServices.ToXTypedElement(element, typeManager, clrType); } } return(childTypedElement); }
public static XTypedList <T> CopyFromWithValidation(IEnumerable <T> typedObjects, XTypedElement container, XName itemXName, ILinqToXsdTypeManager typeManager, string propertyName, SimpleTypeValidator typeDef) { return(Initialize(container, typeManager, typedObjects, itemXName)); }
public XTypedList(XTypedElement container, ILinqToXsdTypeManager typeManager, XName itemXName) : base(container, itemXName) { this.typeManager = typeManager; }
IEnumerable <T> Xml.Schema.Linq.IXTyped.Descendants <T>() { bool flag; bool flag1; bool flag2; XTypedElement xTypedElement = this; Type type = typeof(T); IXMetaData xMetaDatum = xTypedElement; Dictionary <XName, Type> localElementsDictionary = null; ILinqToXsdTypeManager linqToXsdTypeManager = xMetaDatum.TypeManager; Dictionary <XName, Type> globalTypeDictionary = linqToXsdTypeManager.GlobalTypeDictionary; XName xName = null; WildCard wildCard = null; int invalidState = FSM.InvalidState; XElement untyped = null; Stack <XTypedElement> xTypedElements = new Stack <XTypedElement>(); while (true) { xMetaDatum = xTypedElement; FSM validationStates = xTypedElement.ValidationStates; if (validationStates != null) { this.StartFsm(); invalidState = validationStates.Start; } Debug.Assert(xMetaDatum != null); localElementsDictionary = xMetaDatum.LocalElementsDictionary; untyped = xTypedElement.Untyped; xName = null; wildCard = null; XTypedElement xTypedElement1 = null; bool flag3 = true; IEnumerator <XElement> enumerator = untyped.Elements().GetEnumerator(); try { while (enumerator.MoveNext()) { XElement current = enumerator.Current; bool flag4 = this.IsAnnoatedElemTypeOf <T>(current, out xTypedElement1); if (validationStates != null) { invalidState = this.FsmMakeTransition(invalidState, current.Name, out xName, out wildCard); if (invalidState == FSM.InvalidState) { goto Label0; } } if (!flag4) { flag = (validationStates == null ? true : wildCard == null); xTypedElement1 = (flag ? this.TypeChildElement(current, localElementsDictionary, linqToXsdTypeManager) : XTypedServices.ToXTypedElement(current, linqToXsdTypeManager)); if (xTypedElement1 != null) { Type type1 = xTypedElement1.GetType(); if (!type.IsAssignableFrom(type1)) { Type type2 = null; flag1 = (!linqToXsdTypeManager.RootContentTypeMapping.TryGetValue(type1, out type2) ? true : !type.IsAssignableFrom(type2)); if (!flag1) { xTypedElement1 = this.GetContentType(xTypedElement1); flag4 = true; } } else { flag4 = true; } } } if (flag4) { yield return((T)xTypedElement1); } if (xTypedElement1 != null) { xTypedElements.Push(xTypedElement1); } } goto Label1; Label0: flag3 = false; } finally { if (enumerator != null) { enumerator.Dispose(); } } Label1: flag2 = (!flag3 ? true : xTypedElements.Count <= 0); if (flag2) { break; } xTypedElement = xTypedElements.Pop(); } }
public XTypedSubstitutedList(XTypedElement container, ILinqToXsdTypeManager typeManager, params XName[] itemXNames) : base(container, itemXNames) { this.typeManager = typeManager; }