You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Lidarr/src/Marr.Data/Mapping/MapBuilder.cs

207 lines
8.3 KiB

using System;
using System.Linq;
using Marr.Data.Mapping.Strategies;
using System.Reflection;
using System.Collections;
namespace Marr.Data.Mapping
{
[Obsolete("This class is obsolete. Please use the 'Mappings' class.")]
public class MapBuilder
{
private bool _publicOnly;
public MapBuilder()
: this(true)
{ }
public MapBuilder(bool publicOnly)
{
_publicOnly = publicOnly;
}
#region - Columns -
/// <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<T> BuildColumns<T>()
{
return BuildColumns<T>(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<T> BuildColumnsFromSimpleTypes<T>()
{
return BuildColumns<T>(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.
/// Maps properties that are included in the include list.
/// </summary>
/// <typeparam name="T">The type that is being built.</typeparam>
/// <param name="propertiesToInclude"></param>
/// <returns><see cref="ColumnMapCollection"/></returns>
public ColumnMapBuilder<T> BuildColumns<T>(params string[] propertiesToInclude)
{
return BuildColumns<T>(m =>
m.MemberType == MemberTypes.Property &&
propertiesToInclude.Contains(m.Name));
}
/// <summary>
/// Creates column mappings for the given type.
/// Maps all properties except the ones in the exclusion list.
/// </summary>
/// <typeparam name="T">The type that is being built.</typeparam>
/// <param name="propertiesToExclude"></param>
/// <returns><see cref="ColumnMapCollection"/></returns>
public ColumnMapBuilder<T> BuildColumnsExcept<T>(params string[] propertiesToExclude)
{
return BuildColumns<T>(m =>
m.MemberType == MemberTypes.Property &&
!propertiesToExclude.Contains(m.Name));
}
/// <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<T> BuildColumns<T>(Func<MemberInfo, bool> predicate)
{
Type entityType = typeof(T);
ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
strategy.ColumnPredicate = predicate;
ColumnMapCollection columns = strategy.MapColumns(entityType);
MapRepository.Instance.Columns[entityType] = columns;
return new ColumnMapBuilder<T>(null, 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<T> Columns<T>()
{
Type entityType = typeof(T);
ColumnMapCollection columns = new ColumnMapCollection();
MapRepository.Instance.Columns[entityType] = columns;
return new ColumnMapBuilder<T>(null, columns);
}
#endregion
#region - Relationships -
/// <summary>
/// Creates relationship mappings for the given type.
/// Maps all properties that implement ICollection.
/// </summary>
/// <typeparam name="T">The type that is being built.</typeparam>
/// <returns><see cref="RelationshipBuilder"/></returns>
public RelationshipBuilder<T> BuildRelationships<T>()
{
return BuildRelationships<T>(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 listed in the include list.
/// </summary>
/// <typeparam name="T">The type that is being built.</typeparam>
/// <param name="propertiesToInclude"></param>
/// <returns><see cref="RelationshipBuilder"/></returns>
public RelationshipBuilder<T> BuildRelationships<T>(params string[] propertiesToInclude)
{
Func<MemberInfo, bool> predicate = m =>
(
// ICollection properties
m.MemberType == MemberTypes.Property &&
typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
propertiesToInclude.Contains(m.Name)
) || ( // Single entity properties
m.MemberType == MemberTypes.Property &&
!typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
propertiesToInclude.Contains(m.Name)
);
return BuildRelationships<T>(predicate);
}
/// <summary>
/// Creates relationship 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="RelationshipBuilder"/></returns>
public RelationshipBuilder<T> BuildRelationships<T>(Func<MemberInfo, bool> predicate)
{
Type entityType = typeof(T);
ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
strategy.RelationshipPredicate = predicate;
RelationshipCollection relationships = strategy.MapRelationships(entityType);
MapRepository.Instance.Relationships[entityType] = relationships;
return new RelationshipBuilder<T>(null, relationships);
}
/// <summary>
/// Creates a RelationshipBuilder that starts out with no pre-populated relationships.
/// All relationships must be added manually using the builder.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public RelationshipBuilder<T> Relationships<T>()
{
Type entityType = typeof(T);
RelationshipCollection relationships = new RelationshipCollection();
MapRepository.Instance.Relationships[entityType] = relationships;
return new RelationshipBuilder<T>(null, relationships);
}
#endregion
#region - Tables -
/// <summary>
/// Provides a fluent table mapping interface.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public TableBuilder<T> BuildTable<T>()
{
return new TableBuilder<T>(null);
}
/// <summary>
/// Sets the table name for a given type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tableName"></param>
public TableBuilder<T> BuildTable<T>(string tableName)
{
return new TableBuilder<T>(null).SetTableName(tableName);
}
#endregion
}
}