added marr.datamapper source code for easy debugging.

Marr.Data/Mapping/FluentMappings.cs

@@ -0,0 +1,236 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using Marr.Data.Mapping.Strategies;
+using System.Collections;
+
+namespace Marr.Data.Mapping
+{
+    /// <summary>
+    /// Provides a fluent interface for mapping domain entities and properties to database tables and columns.
+    /// </summary>
+    public class FluentMappings
+    {
+        private bool _publicOnly;
+
+        public FluentMappings()
+            : this(true)
+        { }
+
+        public FluentMappings(bool publicOnly)
+        {
+            _publicOnly = publicOnly;
+            
+        }
+
+        public MappingsFluentEntity<TEntity> Entity<TEntity>()
+        {
+            return new MappingsFluentEntity<TEntity>(_publicOnly);
+        }
+
+        public class MappingsFluentEntity<TEntity>
+        {
+            public MappingsFluentEntity(bool publicOnly)
+            {
+                Columns = new MappingsFluentColumns<TEntity>(this, publicOnly);
+                Table = new MappingsFluentTables<TEntity>(this);
+                Relationships = new MappingsFluentRelationships<TEntity>(this, publicOnly);
+            }
+
+            /// <summary>
+            /// Contains methods that map entity properties to database table and view column names;
+            /// </summary>
+            public MappingsFluentColumns<TEntity> Columns { get; private set; }
+
+            /// <summary>
+            /// Contains methods that map entity classes to database table names.
+            /// </summary>
+            public MappingsFluentTables<TEntity> Table { get; private set; }
+
+            /// <summary>
+            /// Contains methods that map sub-entities with database table and view column names.
+            /// </summary>
+            public MappingsFluentRelationships<TEntity> Relationships { get; private set; }
+        }
+
+        public class MappingsFluentColumns<TEntity>
+        {
+            private bool _publicOnly;
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+
+            public MappingsFluentColumns(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, bool publicOnly)
+            {
+                _fluentEntity = fluentEntity;
+                _publicOnly = publicOnly;
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type.
+            /// Maps all properties except ICollection properties.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <returns><see cref="ColumnMapCollection"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapAllProperties()
+            {
+                return AutoMapPropertiesWhere(m => m.MemberType == MemberTypes.Property &&
+                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type.
+            /// Maps all properties that are simple types (int, string, DateTime, etc).  
+            /// ICollection properties are not included.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <returns><see cref="ColumnMapCollection"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapSimpleTypeProperties()
+            {
+                return AutoMapPropertiesWhere(m => m.MemberType == MemberTypes.Property &&
+                    DataHelper.IsSimpleType((m as PropertyInfo).PropertyType) &&
+                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates column mappings for the given type if they match the predicate.
+            /// </summary>
+            /// <typeparam name="T">The type that is being built.</typeparam>
+            /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+            /// <returns><see cref="ColumnMapConfigurator"/></returns>
+            public ColumnMapBuilder<TEntity> AutoMapPropertiesWhere(Func<MemberInfo, bool> predicate)
+            {
+                Type entityType = typeof(TEntity);
+                ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+                strategy.ColumnPredicate = predicate;
+                ColumnMapCollection columns = strategy.MapColumns(entityType);
+                MapRepository.Instance.Columns[entityType] = columns;
+                return new ColumnMapBuilder<TEntity>(_fluentEntity, columns);
+            }
+
+            /// <summary>
+            /// Creates a ColumnMapBuilder that starts out with no pre-populated columns.
+            /// All columns must be added manually using the builder.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <returns></returns>
+            public ColumnMapBuilder<TEntity> MapProperties()
+            {
+                Type entityType = typeof(TEntity);
+                ColumnMapCollection columns = new ColumnMapCollection();
+                MapRepository.Instance.Columns[entityType] = columns;
+                return new ColumnMapBuilder<TEntity>(_fluentEntity, columns);
+            }
+        }
+
+        public class MappingsFluentTables<TEntity>
+        {
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+
+            public MappingsFluentTables(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity)
+            {
+                _fluentEntity = fluentEntity;
+            }
+
+            /// <summary>
+            /// Provides a fluent table mapping interface.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <returns></returns>
+            public TableBuilder<TEntity> AutoMapTable<T>()
+            {
+                return new TableBuilder<TEntity>(_fluentEntity);
+            }
+
+            /// <summary>
+            /// Sets the table name for a given type.
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <param name="tableName"></param>
+            public TableBuilder<TEntity> MapTable(string tableName)
+            {
+                return new TableBuilder<TEntity>(_fluentEntity).SetTableName(tableName);
+            }
+        }
+
+        public class MappingsFluentRelationships<TEntity>
+        {
+            private FluentMappings.MappingsFluentEntity<TEntity> _fluentEntity;
+            private bool _publicOnly;
+
+            public MappingsFluentRelationships(FluentMappings.MappingsFluentEntity<TEntity> fluentEntity, bool publicOnly)
+            {
+                _fluentEntity = fluentEntity;
+                _publicOnly = publicOnly;
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that implement ICollection or are not "simple types".
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> AutoMapICollectionOrComplexProperties()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    (
+                        typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) || !DataHelper.IsSimpleType((m as PropertyInfo).PropertyType)
+                    )
+                );
+
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that implement ICollection.
+            /// </summary>
+            /// <returns><see cref="RelationshipBuilder"/></returns>
+            public RelationshipBuilder<TEntity> AutoMapICollectionProperties()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type.
+            /// Maps all properties that are not "simple types".
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> AutoMapComplexTypeProperties<T>()
+            {
+                return AutoMapPropertiesWhere(m =>
+                    m.MemberType == MemberTypes.Property &&
+                    !DataHelper.IsSimpleType((m as PropertyInfo).PropertyType));
+            }
+
+            /// <summary>
+            /// Creates relationship mappings for the given type if they match the predicate.
+            /// </summary>
+            /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
+            /// <returns><see cref="RelationshipBuilder"/></returns>
+            public RelationshipBuilder<TEntity> AutoMapPropertiesWhere(Func<MemberInfo, bool> predicate)
+            {
+                Type entityType = typeof(TEntity);
+                ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
+                strategy.RelationshipPredicate = predicate;
+                RelationshipCollection relationships = strategy.MapRelationships(entityType);
+                MapRepository.Instance.Relationships[entityType] = relationships;
+                return new RelationshipBuilder<TEntity>(_fluentEntity, relationships);
+            }
+
+            /// <summary>
+            /// Creates a RelationshipBuilder that starts out with no pre-populated relationships.
+            /// All relationships must be added manually using the builder.
+            /// </summary>
+            /// <returns></returns>
+            public RelationshipBuilder<TEntity> MapProperties<T>()
+            {
+                Type entityType = typeof(T);
+                RelationshipCollection relationships = new RelationshipCollection();
+                MapRepository.Instance.Relationships[entityType] = relationships;
+                return new RelationshipBuilder<TEntity>(_fluentEntity, relationships);
+            }
+        }
+    }
+}