public void Can_add_subclass() { var joinedSubclass = new JoinedSubclassMapping(); _classMapping.AddSubclass(joinedSubclass); _classMapping.Subclasses.ShouldContain(joinedSubclass); }
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping) { var conventions = finder.Find <IJoinedSubclassConvention>(); Apply <IJoinedSubclassInspector, IJoinedSubclassInstance>(conventions, new JoinedSubclassInstance(subclassMapping)); }
public void ShouldWriteSetForSetMapping() { var mapping = new JoinedSubclassMapping(); writer.VerifyXml(mapping) .RootElement.HasName("joined-subclass"); }
public void ShouldWriteBag() { var mapping = new JoinedSubclassMapping(); mapping.AddCollection(new BagMapping()); writer.VerifyXml(mapping) .Element("bag").Exists(); }
public void ShouldWriteManyToOnes() { var mapping = new JoinedSubclassMapping(); mapping.AddReference(new ManyToOneMapping()); writer.VerifyXml(mapping) .Element("many-to-one").Exists(); }
public void ShouldWriteDynamicComponents() { var mapping = new JoinedSubclassMapping(); mapping.AddComponent(new DynamicComponentMapping()); writer.VerifyXml(mapping) .Element("dynamic-component").Exists(); }
public void ShouldWriteProperties() { var mapping = new JoinedSubclassMapping(); mapping.AddProperty(new PropertyMapping()); writer.VerifyXml(mapping) .Element("property").Exists(); }
public void ShouldWriteSubclass() { var mapping = new JoinedSubclassMapping(); mapping.AddSubclass(new JoinedSubclassMapping()); writer.VerifyXml(mapping) .Element("joined-subclass").Exists(); }
public void ShouldWriteAny() { var mapping = new JoinedSubclassMapping(); mapping.AddAny(new AnyMapping()); writer.VerifyXml(mapping) .Element("any").Exists(); }
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <string> mappedProperties) { var discriminatorSet = false; var isDiscriminated = expressions.IsDiscriminated(classType); foreach (var inheritedClass in mappingTypes.Where(q => q.Type.BaseType == classType && !expressions.IsConcreteBaseType(q.Type.BaseType))) { if (isDiscriminated && !discriminatorSet && mapping is ClassMapping) { var discriminatorColumn = expressions.DiscriminatorColumn(classType); var discriminator = new DiscriminatorMapping { ContainingEntityType = classType, Type = new TypeReference(typeof(string)) }; discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn }); ((ClassMapping)mapping).Discriminator = discriminator; discriminatorSet = true; } ISubclassMapping subclassMapping; var subclassStrategy = expressions.SubclassStrategy(classType); if (subclassStrategy == SubclassStrategy.JoinedSubclass) { // TODO: This id name should be removed. Ideally it needs to be set by a // default and be overridable by a convention (preferably the ForeignKey convention // that already exists) var subclass = new JoinedSubclassMapping { Type = inheritedClass.Type }; subclass.Key = new KeyMapping(); subclass.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" }); subclassMapping = subclass; } else { subclassMapping = new SubclassMapping(); } MapSubclass(mappedProperties, subclassMapping, inheritedClass); mapping.AddSubclass(subclassMapping); MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties); } }
public override void ProcessJoinedSubclass(JoinedSubclassMapping mapping) { var subclasses = FindClosestSubclasses(mapping.Type); foreach (var provider in subclasses) mapping.AddSubclass(provider.GetSubclassMapping(new JoinedSubclassMapping())); base.ProcessJoinedSubclass(mapping); }
public void ShouldWriteOneToOnes() { var mapping = new JoinedSubclassMapping(); mapping.AddOneToOne(new OneToOneMapping()); writer.VerifyXml(mapping) .Element("one-to-one").Exists(); }
public override void ProcessJoinedSubclass(JoinedSubclassMapping mapping) { var subclasses = subclassProviders .Select(x => x.GetSubclassMapping(new JoinedSubclassMapping())) .Where(x => x.Type.BaseType == mapping.Type); foreach (var subclass in subclasses) mapping.AddSubclass(subclass); base.ProcessJoinedSubclass(mapping); }
public override void ProcessJoinedSubclass(JoinedSubclassMapping mapping) { var subclasses = FindClosestSubclasses(mapping.Type); foreach (var provider in subclasses) { mapping.AddSubclass(provider.GetSubclassMapping(new JoinedSubclassMapping())); } base.ProcessJoinedSubclass(mapping); }
ISubclassMapping ISubclassMappingProvider.GetSubclassMapping() { var mapping = new JoinedSubclassMapping(attributes.CloneInner()); mapping.Key = new KeyMapping { ContainingEntityType = typeof(TSubclass) }; mapping.Name = typeof(TSubclass).AssemblyQualifiedName; mapping.Type = typeof(TSubclass); foreach (var column in columns) { mapping.Key.AddColumn(column); } foreach (var property in properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in components) { mapping.AddComponent(component.GetComponentMapping()); } 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()); } return(mapping); }
public virtual void Visit(JoinedSubclassMapping subclassMapping) { }
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping) { ProcessClassBase(subclassMapping); }
public void Should_apply_to_joined_subclass_mapping() { var joinedSubclassMapping = new JoinedSubclassMapping(); joinedSubclassMapping.Type = typeof(Album); _namingConvention.ProcessJoinedSubclass(joinedSubclassMapping); joinedSubclassMapping.Name.ShouldEqual(joinedSubclassMapping.Type.AssemblyQualifiedName); }
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping) { var writer = serviceLocator.GetWriter <JoinedSubclassMapping>(); document = writer.Write(subclassMapping); }
public override void Visit(JoinedSubclassMapping subclassMapping) { subclassMapping.AcceptVisitor(this); }
public void CreateDsl() { mapping = new JoinedSubclassMapping(); inspector = new JoinedSubclassInspector(mapping); }
public JoinedSubclassInspector(JoinedSubclassMapping mapping) { this.mapping = mapping; mappedProperties.Map(x => x.LazyLoad, x => x.Lazy); }
public virtual void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping) { }
public JoinedSubclassInspector(JoinedSubclassMapping mapping) { this.mapping = mapping; mappedProperties.AutoMap(); mappedProperties.Map(x => x.LazyLoad, x => x.Lazy); }
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList<string> mappedProperties) { var discriminatorSet = false; var isDiscriminated = expressions.IsDiscriminated(classType); foreach (var inheritedClass in mappingTypes.Where(q => q.Type.BaseType == classType && !expressions.IsConcreteBaseType(q.Type.BaseType))) { if (isDiscriminated && !discriminatorSet && mapping is ClassMapping) { var discriminatorColumn = expressions.DiscriminatorColumn(classType); var discriminator = new DiscriminatorMapping { ContainingEntityType = classType, Type = new TypeReference(typeof(string)) }; discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn }); ((ClassMapping)mapping).Discriminator = discriminator; discriminatorSet = true; } ISubclassMapping subclassMapping; var subclassStrategy = expressions.SubclassStrategy(classType); if (subclassStrategy == SubclassStrategy.JoinedSubclass) { // TODO: This id name should be removed. Ideally it needs to be set by a // default and be overridable by a convention (preferably the ForeignKey convention // that already exists) var subclass = new JoinedSubclassMapping { Type = inheritedClass.Type }; subclass.Key = new KeyMapping(); subclass.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" }); subclassMapping = subclass; } else subclassMapping = new SubclassMapping(); MapSubclass(mappedProperties, subclassMapping, inheritedClass); mapping.AddSubclass(subclassMapping); MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties); } }
public JoinedSubclassInstance(JoinedSubclassMapping mapping) : base(mapping) { this.mapping = mapping; }