示例#1
0
        private Tuple <ITypeMap, ITypeMap> AddTypeMap(XName qualifiedName)
        {
            var typeDefinition = GetRuntimeTypeDefinition(qualifiedName);

            if (typeDefinition == null)
            {
                return(null);
            }

            if (qualifiedName.NamespaceName != typeDefinition.Name.NamespaceName)
            {
                throw XRoadException.UnknownType(qualifiedName.ToString());
            }

            if (!typeDefinition.Type.GetTypeInfo().IsEnum&& !typeDefinition.Type.GetTypeInfo().IsAbstract&& typeDefinition.Type.GetTypeInfo().GetConstructor(Type.EmptyTypes) == null)
            {
                throw XRoadException.NoDefaultConstructorForType(typeDefinition.Name);
            }

            ITypeMap typeMap;

            if (typeDefinition.TypeMapType != null)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeDefinition.TypeMapType, this, typeDefinition);
            }
            else if (typeDefinition.Type.GetTypeInfo().IsEnum)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(EnumTypeMap), typeDefinition);
            }
            else if (typeDefinition.Type.GetTypeInfo().IsAbstract)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(AbstractTypeMap), typeDefinition);
            }
            else if (typeDefinition.HasStrictContentOrder)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(SequenceTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
            }
            else
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(AllTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
            }

            var arrayTypeMap = (ITypeMap)Activator.CreateInstance(typeof(ArrayTypeMap <>).MakeGenericType(typeDefinition.Type), this, schemaDefinitionProvider.GetCollectionDefinition(typeDefinition), typeMap);
            var typeMapTuple = Tuple.Create(typeMap, arrayTypeMap);

            if (!(typeMap is ICompositeTypeMap compositeTypeMap))
            {
                return(xmlTypeMaps.GetOrAdd(qualifiedName, typeMapTuple));
            }

            var partialTypeMaps = new Dictionary <Type, ITypeMap>
            {
                { compositeTypeMap.Definition.Type, compositeTypeMap },
                { arrayTypeMap.Definition.Type, arrayTypeMap }
            };

            compositeTypeMap.InitializeProperties(GetRuntimeProperties(typeDefinition, partialTypeMaps), availableFilters);

            return(xmlTypeMaps.GetOrAdd(qualifiedName, typeMapTuple));
        }
示例#2
0
        private TypeDefinition GetRuntimeTypeDefinition(XName qualifiedName)
        {
            if (!qualifiedName.NamespaceName.StartsWith("http://"))
            {
                var type = contractAssembly.GetType($"{qualifiedName.Namespace}.{qualifiedName.LocalName}");
                return(type != null && type.IsXRoadSerializable() ? schemaDefinitionProvider.GetTypeDefinition(type) : null);
            }

            var typeDefinition = contractAssembly.GetTypes()
                                 .Where(type => type.IsXRoadSerializable())
                                 .Where(type => !Version.HasValue || type.GetTypeInfo().ExistsInVersion(Version.Value))
                                 .Select(type => schemaDefinitionProvider.GetTypeDefinition(type))
                                 .SingleOrDefault(definition => definition.Name == qualifiedName);

            if (typeDefinition != null)
            {
                return(typeDefinition);
            }

            throw XRoadException.UnknownType(qualifiedName.ToString());
        }
示例#3
0
        private ITypeMap AddTypeMap(Type runtimeType, IDictionary <Type, ITypeMap> partialTypeMaps)
        {
            if (runtimeType.IsXRoadSerializable() && Version.HasValue && !runtimeType.GetTypeInfo().ExistsInVersion(Version.Value))
            {
                throw XRoadException.UnknownType(runtimeType.ToString());
            }

            var typeDefinition = schemaDefinitionProvider.GetTypeDefinition(runtimeType);

            ITypeMap typeMap;

            if (typeDefinition.TypeMapType != null)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeDefinition.TypeMapType, this, typeDefinition);
                return(runtimeTypeMaps.GetOrAdd(runtimeType, typeMap));
            }

            var collectionDefinition = typeDefinition as CollectionDefinition;

            if (collectionDefinition != null)
            {
                var elementType = typeDefinition.Type.GetElementType();
                if (!ReferenceEquals(elementType.GetTypeInfo().Assembly, contractAssembly))
                {
                    return(null);
                }

                var itemTypeMap = GetTypeMap(elementType, partialTypeMaps);
                collectionDefinition.ItemDefinition = itemTypeMap.Definition;

                var typeMapType = typeof(ArrayTypeMap <>).MakeGenericType(itemTypeMap.Definition.Type);
                typeMap = (ITypeMap)Activator.CreateInstance(typeMapType, this, collectionDefinition, itemTypeMap);
                return(runtimeTypeMaps.GetOrAdd(runtimeType, typeMap));
            }

            if (!ReferenceEquals(typeDefinition.Type.GetTypeInfo().Assembly, contractAssembly))
            {
                return(null);
            }

            if (!typeDefinition.Type.GetTypeInfo().IsEnum&& !typeDefinition.Type.GetTypeInfo().IsAbstract&& typeDefinition.Type.GetTypeInfo().GetConstructor(Type.EmptyTypes) == null)
            {
                throw XRoadException.NoDefaultConstructorForType(typeDefinition.Type.Name);
            }

            if (typeDefinition.Type.GetTypeInfo().IsEnum)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(EnumTypeMap), typeDefinition);
            }
            else if (typeDefinition.Type.GetTypeInfo().IsAbstract)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(AbstractTypeMap), typeDefinition);
            }
            else if (typeDefinition.HasStrictContentOrder)
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(SequenceTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
            }
            else
            {
                typeMap = (ITypeMap)Activator.CreateInstance(typeof(AllTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
            }

            var compositeTypeMap = typeMap as ICompositeTypeMap;

            if (compositeTypeMap == null)
            {
                return(runtimeTypeMaps.GetOrAdd(runtimeType, typeMap));
            }

            partialTypeMaps = partialTypeMaps ?? new Dictionary <Type, ITypeMap>();
            partialTypeMaps.Add(typeDefinition.Type, compositeTypeMap);
            compositeTypeMap.InitializeProperties(GetRuntimeProperties(typeDefinition, partialTypeMaps), availableFilters);
            partialTypeMaps.Remove(typeDefinition.Type);

            return(runtimeTypeMaps.GetOrAdd(runtimeType, compositeTypeMap));
        }