Example #1
0
        public void Map(ClassMappingBase classMap, Member member)
        {
            // don't map the component here, mark it as a reference which'll
            // allow us to integrate with ComponentMap or automap at a later
            // stage
            var mapping = new ReferenceComponentMapping(ComponentType.Component, member, member.PropertyType, classMap.Type, cfg.GetComponentColumnPrefix(member));

            classMap.AddComponent(mapping);
        }
        private ReferenceComponentMapping CreateInstance()
        {
            var property = new DummyPropertyInfo("ComponentProperty", typeof(ComponentTarget)).ToMember();
            var instance = new ReferenceComponentMapping(ComponentType.Component, property, typeof(ComponentTarget), typeof(Target), null);

            instance.AssociateExternalMapping(new ExternalComponentMapping(ComponentType.Component));

            return(instance);
        }
        public override void establish_context()
        {
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
            var externalComponent = Stub <IExternalComponentMappingProvider> .Create(cfg =>
                                                                                     cfg.Stub(x => x.GetComponentMapping()).Return(externalComponentMapping));

            visitor = new ComponentReferenceResolutionVisitor(new [] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponent });
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
Example #4
0
        public override void establish_context()
        {
            external_component_mapping = new ExternalComponentMapping(ComponentType.Component)
            {
                Type = typeof(ComponentTarget)
            };
            var external_component = Stub <IExternalComponentMappingProvider> .Create(cfg =>
                                                                                      cfg.Stub(x => x.GetComponentMapping()).Return(external_component_mapping));

            visitor = new ComponentReferenceResolutionVisitor(new[] { external_component });
            reference_component_mapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
        public override void establish_context()
        {
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));

            var externalComponent = A.Fake <IExternalComponentMappingProvider>();

            A.CallTo(() => externalComponent.GetComponentMapping()).Returns(externalComponentMapping);
            A.CallTo(() => externalComponent.Type).Returns(null);

            visitor = new ComponentReferenceResolutionVisitor(new[] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponent });
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
Example #6
0
        public override void establish_context()
        {
            visitor = new ComponentColumnPrefixVisitor();
            reference_with_a_prefix = new ReferenceComponentMapping(ComponentType.Component, new DummyPropertyInfo("PROPERTY", typeof(Target)).ToMember(), typeof(ComponentTarget), typeof(Target), column_prefix);
            reference_with_a_prefix.AssociateExternalMapping(new ExternalComponentMapping(ComponentType.Component));

            reference_without_a_prefix = new ReferenceComponentMapping(ComponentType.Component, new DummyPropertyInfo("PROPERTY", typeof(Target)).ToMember(), typeof(ComponentTarget), typeof(Target), null);

            var external_mapping = new ExternalComponentMapping(ComponentType.Component);

            external_mapping.AddProperty(property_with_column("propertyColumn"));

            reference_without_a_prefix.AssociateExternalMapping(external_mapping);
        }
        public override void ProcessComponent(ReferenceComponentMapping mapping)
        {
            var providers = componentProviders.Where(x => x.Type == mapping.Type);

            if (!providers.Any())
            {
                throw new MissingExternalComponentException(mapping.Type, mapping.ContainingEntityType, mapping.Member);
            }
            if (providers.Count() > 1)
            {
                throw new AmbiguousComponentReferenceException(mapping.Type, mapping.ContainingEntityType, mapping.Member);
            }

            mapping.AssociateExternalMapping(providers.Single().GetComponentMapping());

            mapping.MergedModel.AcceptVisitor(this);
        }
Example #8
0
        public override void ProcessComponent(ReferenceComponentMapping mapping)
        {
            var context = new ComponentResolutionContext
            {
                ComponentType   = mapping.Type,
                ComponentMember = mapping.Member,
                EntityType      = mapping.ContainingEntityType
            };
            var component = resolvers
                            .Select(x => x.Resolve(context, componentProviders))
                            .FirstOrDefault(x => x != null);

            if (component == null)
            {
                throw new MissingExternalComponentException(mapping.Type, mapping.ContainingEntityType, mapping.Member);
            }

            mapping.AssociateExternalMapping(component);
            mapping.MergedModel.AcceptVisitor(this);
        }
Example #9
0
        public override void establish_context()
        {
            parentMapping            = new ParentMapping();
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Access, Layer.Defaults, "access");
            externalComponentMapping.Set(x => x.Insert, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Lazy, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.OptimisticLock, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Parent, Layer.Defaults, parentMapping);
            externalComponentMapping.Set(x => x.Unique, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Update, Layer.Defaults, true);
            externalComponentMapping.AddAny(new AnyMapping());
            externalComponentMapping.AddCollection(CollectionMapping.Bag());
            externalComponentMapping.AddComponent(new ComponentMapping(ComponentType.Component));
            externalComponentMapping.AddFilter(new FilterMapping());
            externalComponentMapping.AddOneToOne(new OneToOneMapping());
            externalComponentMapping.AddProperty(new PropertyMapping());
            externalComponentMapping.AddReference(new ManyToOneMapping());

            memberProperty            = new DummyPropertyInfo("Component", typeof(Target)).ToMember();
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, memberProperty, typeof(ComponentTarget), typeof(Target), "column-prefix");
        }
Example #10
0
        public override void establish_context()
        {
            parent_mapping             = new ParentMapping();
            external_component_mapping = new ExternalComponentMapping(ComponentType.Component)
            {
                Access         = "access",
                Insert         = true,
                Lazy           = true,
                OptimisticLock = true,
                Parent         = parent_mapping,
                Unique         = true,
                Update         = true
            };
            external_component_mapping.AddAny(new AnyMapping());
            external_component_mapping.AddCollection(new BagMapping());
            external_component_mapping.AddComponent(new ComponentMapping(ComponentType.Component));
            external_component_mapping.AddFilter(new FilterMapping());
            external_component_mapping.AddOneToOne(new OneToOneMapping());
            external_component_mapping.AddProperty(new PropertyMapping());
            external_component_mapping.AddReference(new ManyToOneMapping());

            member_property             = new DummyPropertyInfo("Component", typeof(Target)).ToMember();
            reference_component_mapping = new ReferenceComponentMapping(ComponentType.Component, member_property, typeof(ComponentTarget), typeof(Target), "column-prefix");
        }
 public virtual void ProcessComponent(ReferenceComponentMapping componentMapping)
 {
 }
Example #12
0
 public override void ProcessComponent(ReferenceComponentMapping componentMapping)
 {
     componentMapping.MergedModel.AcceptVisitor(this);
 }
Example #13
0
 public override void establish_context()
 {
     member_property             = new DummyPropertyInfo("Component", typeof(Target)).ToMember();
     reference_component_mapping = new ReferenceComponentMapping(ComponentType.Component, member_property, typeof(ComponentTarget), typeof(Target), null);
 }