private LogicalType GetTypeInternal(TypeAndNamespace typeAndNamespace, bool encoded, TypeOrigin originsToSearch, out TypeOrigin typeOrigin) { Dictionary <TypeAndNamespace, LogicalType> typeTable; lock (_lookUpLock) { typeTable = encoded ? _userEncodedTypesByType : _userLiteralTypesByType; if (0 != (originsToSearch & TypeOrigin.Intrinsic) && s_intrinsicsByType.ContainsKey(typeAndNamespace.Type)) { typeOrigin = TypeOrigin.Intrinsic; return(s_intrinsicsByType[typeAndNamespace.Type]); } else if (0 != (originsToSearch & TypeOrigin.User) && typeTable.ContainsKey(typeAndNamespace)) { typeOrigin = TypeOrigin.User; return(typeTable[typeAndNamespace]); } else { typeOrigin = TypeOrigin.None; return(null); } } }
public override bool Equals(object obj) { if (!(obj is TypeAndNamespace)) { return(false); } TypeAndNamespace other = (TypeAndNamespace)obj; return(Type == other.Type && DefaultNamespace == other.DefaultNamespace); }
private LogicalType GetType(TypeAndNamespace typeAndNamespace, bool encoded, TypeOrigin originsToSearch, out TypeOrigin typeOrigin) { // If a specific namespace is needed, check to see whether the type sought after is // a one-namespace-fits-all and has already been reflected. if (typeAndNamespace.DefaultNamespace != null) { // looking for a specific namespace // does a one-size-fits-all exist? LogicalType lType = GetTypeInternal(new TypeAndNamespace(typeAndNamespace.Type, null), encoded, originsToSearch, out typeOrigin); if (lType != null) { return(lType); } } // The sought for type either hasn't been reflected over, or must be prepared // for each namespace it appears in. Search for the specific one and return result. return(GetTypeInternal(typeAndNamespace, encoded, originsToSearch, out typeOrigin)); }
/// <summary> /// Adds a LogicalType to the TypeContainer. The LogicalType is mapped by /// Framework Type, i.e FX Type => LogicalType, as well as by XmlQualifiedName, /// i.e (Name:Namespace) => LogicalType. /// </summary> public void AddType(LogicalType lType, string name, string ns, bool encoded) { Dictionary <TypeAndNamespace, LogicalType> typesByTypeTable; Dictionary <XmlQualifiedName, LogicalType> typesByNameTable; bool allowTypeMapping, allowNameMapping; XmlQualifiedName typeQName; TypeAndNamespace typeAndNamespace; // Most type should avoid the null namespace, but some types (like XmlNode) // really don't have any need for a ns because they are inherently portable // by carrying all their namespace info with them. Debug.Assert(ns != null || lType.NamespaceIsPortable, "A non-portable type MUST specify a namespace."); lock (_lookUpLock) { if (encoded) { typesByTypeTable = _userEncodedTypesByType; typesByNameTable = _userEncodedTypesByQName; } else { typesByTypeTable = _userLiteralTypesByType; typesByNameTable = _userLiteralTypesByQName; } allowTypeMapping = (lType.MappingFlags & TypeMappingFlags.AllowTypeMapping) != 0; allowNameMapping = (lType.MappingFlags & TypeMappingFlags.AllowNameMapping) != 0; typeQName = new XmlQualifiedName(name, ns); typeAndNamespace = new TypeAndNamespace(lType.Type, lType.NamespaceIsPortable ? null : ns); //if we're allowed to map the C# type to the LogicalType if (allowTypeMapping) { // Don't add the type yet. Verify that I can also add it to the type table before committing it. if (typesByTypeTable.ContainsKey(typeAndNamespace)) { Debug.WriteLine("Adding " + ns + ":" + lType.Type + " twice."); throw new InvalidOperationException(SR.Format(SR.XmlS_TwoMappings_1, lType.Type)); } // We should never have both a null namespace for a type in our table and a non-null namespace. // We should EITHER have the type in our table at most once, with the null namespace; // OR we should have the type in our table any number of times, all with non-null namespaces. Debug.Assert(!(typeAndNamespace.DefaultNamespace != null && typesByTypeTable.ContainsKey(new TypeAndNamespace(typeAndNamespace.Type, null)))); } //If we're allowed to map the qname to this LogicalType if (allowNameMapping) { if (typesByNameTable.ContainsKey(typeQName)) { Debug.WriteLine("Two types in " + lType.Namespace + ":" + lType.Name); throw new InvalidOperationException(SR.Format(SR.XmlS_TwoMappings_1, typeQName)); } typesByNameTable[typeQName] = lType; } if (allowTypeMapping) { typesByTypeTable[typeAndNamespace] = lType; } if (encoded && !_userEncodedNamespaces.Contains(ns)) { _userEncodedNamespaces.Add(ns); } } }