Example #1
0
        public ClassMapping Map(Type classType, List<AutoMapType> types)
        {
            var classMap = new ClassMapping { Type = classType };

            classMap.SetDefaultValue(x => x.Name, classType.AssemblyQualifiedName);
            classMap.SetDefaultValue(x => x.TableName, GetDefaultTableName(classType));

            mappingTypes = types;
            return (ClassMapping)MergeMap(classType, classMap, new List<string>());
        }
Example #2
0
        public ClassMapping Map(Type classType, List <AutoMapType> types)
        {
            var classMap = new ClassMapping {
                Type = classType
            };

            classMap.SetDefaultValue(x => x.Name, classType.AssemblyQualifiedName);
            classMap.SetDefaultValue(x => x.TableName, GetDefaultTableName(classType));

            mappingTypes = types;
            return((ClassMapping)MergeMap(classType, classMap, new List <string>()));
        }
Example #3
0
        ClassMapping IMappingProvider.GetClassMapping()
        {
            var mapping = new ClassMapping(attributes.CloneInner());

            mapping.Type = typeof(T);
            mapping.Name = typeof(T).AssemblyQualifiedName;

            foreach (var property in properties)
            {
                mapping.AddProperty(property.GetPropertyMapping());
            }

            foreach (var component in components)
            {
                mapping.AddComponent(component.GetComponentMapping());
            }

            if (version != null)
            {
                mapping.Version = version.GetVersionMapping();
            }

            foreach (var oneToOne in oneToOnes)
            {
                mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
            }

            foreach (var collection in collections)
            {
                mapping.AddCollection(collection.GetCollectionMapping());
            }

            foreach (var reference in references)
            {
                mapping.AddReference(reference.GetManyToOneMapping());
            }

            foreach (var any in anys)
            {
                mapping.AddAny(any.GetAnyMapping());
            }

            foreach (var subclass in subclasses.Values)
            {
                mapping.AddSubclass(subclass.GetSubclassMapping());
            }

            foreach (var join in joins)
            {
                mapping.AddJoin(join);
            }

            if (discriminator != null)
            {
                mapping.Discriminator = ((IDiscriminatorMappingProvider)discriminator).GetDiscriminatorMapping();
            }

            if (Cache.IsDirty)
            {
                mapping.Cache = ((ICacheMappingProvider)Cache).GetCacheMapping();
            }

            if (id != null)
            {
                mapping.Id = id.GetIdentityMapping();
            }

            if (compositeId != null)
            {
                mapping.Id = compositeId.GetCompositeIdMapping();
            }

            if (naturalId != null)
            {
                mapping.NaturalId = naturalId.GetNaturalIdMapping();
            }

            if (!mapping.IsSpecified("TableName"))
            {
                mapping.SetDefaultValue(x => x.TableName, GetDefaultTableName());
            }

            foreach (var filter in filters)
            {
                mapping.AddFilter(filter.GetFilterMapping());
            }

            foreach (var storedProcedure in storedProcedures)
            {
                mapping.AddStoredProcedure(storedProcedure.GetStoredProcedureMapping());
            }

            mapping.Tuplizer = tuplizerMapping;

            return(mapping);
        }