Sonarr/Marr.Data/MapRepository.cs

/*  Copyright (C) 2008 - 2011 Jordan Marr

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>. */

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Data.Common;
using Marr.Data.Converters;
using Marr.Data.Parameters;
using Marr.Data.Mapping;
using Marr.Data.Mapping.Strategies;
using Marr.Data.Reflection;

namespace Marr.Data
{
    public class MapRepository
    {
        private static readonly object _tablesLock = new object();
        private static readonly object _columnsLock = new object();
        private static readonly object _relationshipsLock = new object();

        private IDbTypeBuilder _dbTypeBuilder;
        private Dictionary<Type, IMapStrategy> _columnMapStrategies;

        internal Dictionary<Type, string> Tables { get; set; }
        internal Dictionary<Type, ColumnMapCollection> Columns { get; set; }
        internal Dictionary<Type, RelationshipCollection> Relationships { get; set; }
        internal Dictionary<Type, IConverter> TypeConverters { get; set; }

        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static MapRepository()
        { }

        private MapRepository()
        {
            Tables = new Dictionary<Type, string>();
            Columns = new Dictionary<Type, ColumnMapCollection>();
            Relationships = new Dictionary<Type, RelationshipCollection>();
            TypeConverters = new Dictionary<Type, IConverter>();

            // Register a default IReflectionStrategy
            ReflectionStrategy = new CachedReflectionStrategy();
            
            // Register a default type converter for Enums
            TypeConverters.Add(typeof(Enum), new Converters.EnumStringConverter());

            // Register a default IDbTypeBuilder
            _dbTypeBuilder = new Parameters.DbTypeBuilder();

            _columnMapStrategies = new Dictionary<Type, IMapStrategy>();
            RegisterDefaultMapStrategy(new AttributeMapStrategy());

            EnableTraceLogging = false;
        }

        private readonly static MapRepository _instance = new MapRepository();

        /// <summary>
        /// Gets a reference to the singleton MapRepository.
        /// </summary>
        public static MapRepository Instance
        {
            get
            {
                return _instance;
            }
        }

        /// <summary>
        /// Gets or sets a boolean that determines whether debug information should be written to the trace log.
        /// The default is false.
        /// </summary>
        public bool EnableTraceLogging { get; set; }

        #region - Column Map Strategies -

        public void RegisterDefaultMapStrategy(IMapStrategy strategy)
        {
            RegisterMapStrategy(typeof(object), strategy);
        }

        public void RegisterMapStrategy(Type entityType, IMapStrategy strategy)
        {
            if (_columnMapStrategies.ContainsKey(entityType))
                _columnMapStrategies[entityType] = strategy;
            else
                _columnMapStrategies.Add(entityType, strategy);
        }

        private IMapStrategy GetMapStrategy(Type entityType)
        {
            if (_columnMapStrategies.ContainsKey(entityType))
            {
                // Return entity specific column map strategy
                return _columnMapStrategies[entityType];
            }
            else
            {
                // Return the default column map strategy
                return _columnMapStrategies[typeof(object)];
            }
        }

        #endregion

        #region - Table repository -

        internal string GetTableName(Type entityType)
        {
            if (!Tables.ContainsKey(entityType))
            {
                lock (_tablesLock)
                {
                    if (!Tables.ContainsKey(entityType))
                    {
                        string tableName = GetMapStrategy(entityType).MapTable(entityType);
                        Tables.Add(entityType, tableName);
                        return tableName;
                    }
                }
            }

            return Tables[entityType];
        }

        #endregion

        #region - Columns repository -

        public ColumnMapCollection GetColumns(Type entityType)
        {
            if (!Columns.ContainsKey(entityType))
            {
                lock (_columnsLock)
                {
                    if (!Columns.ContainsKey(entityType))
                    {
                        ColumnMapCollection columnMaps = GetMapStrategy(entityType).MapColumns(entityType);
                        Columns.Add(entityType, columnMaps);
                        return columnMaps;
                    }
                }
            }

            return Columns[entityType];
        }

        #endregion

        #region - Relationships repository -

        public RelationshipCollection GetRelationships(Type type)
        {
            if (!Relationships.ContainsKey(type))
            {
                lock (_relationshipsLock)
                {
                    if (!Relationships.ContainsKey(type))
                    {
                        RelationshipCollection relationships = GetMapStrategy(type).MapRelationships(type);
                        Relationships.Add(type, relationships);
                        return relationships;
                    }
                }
            }

            return Relationships[type];
        }
        
        #endregion

        #region - Reflection Strategy -

        /// <summary>
        /// Gets or sets the reflection strategy that the DataMapper will use to load entities.
        /// By default the CachedReflector will be used, which provides a performance increase over the SimpleReflector.  
        /// However, the SimpleReflector can be used in Medium Trust enviroments.
        /// </summary>
        public IReflectionStrategy ReflectionStrategy { get; set; }

        #endregion

        #region - Type Converters -

        /// <summary>
        /// Registers a converter for a given type.
        /// </summary>
        /// <param name="type">The CLR data type that will be converted.</param>
        /// <param name="converter">An IConverter object that will handle the data conversion.</param>
        public void RegisterTypeConverter(Type type, IConverter converter)
        {
            if (TypeConverters.ContainsKey(type))
            {
                TypeConverters[type] = converter;
            }
            else
            {
                TypeConverters.Add(type, converter);
            }
        }

        /// <summary>
        /// Checks for a type converter (if one exists).
        /// 1) Checks for a converter registered for the current columns data type.
        /// 2) Checks to see if a converter is registered for all enums (type of Enum) if the current column is an enum.
        /// 3) Checks to see if a converter is registered for all objects (type of Object).
        /// </summary>
        /// <param name="dataMap">The current data map.</param>
        /// <returns>Returns an IConverter object or null if one does not exist.</returns>
        internal IConverter GetConverter(Type dataType)
        {
            if (TypeConverters.ContainsKey(dataType))
            {
                // User registered type converter
                return TypeConverters[dataType];
            }
            else if (TypeConverters.ContainsKey(typeof(Enum)) && dataType.IsEnum)
            {
                // A converter is registered to handled enums
                return TypeConverters[typeof(Enum)];
            }
            else if (TypeConverters.ContainsKey(typeof(object)))
            {
                // User registered default converter
                return TypeConverters[typeof(object)];
            }
            else
            {
                // No conversion
                return null;
            }
        }

        #endregion

        #region - DbTypeBuilder -

        /// <summary>
        /// Gets or sets the IDBTypeBuilder that is responsible for converting parameter DbTypes based on the parameter value.
        /// Defaults to use the DbTypeBuilder.  
        /// You can replace this with a more specific builder if you want more control over the way the parameter types are set.
        /// </summary>
        public IDbTypeBuilder DbTypeBuilder
        {
            get { return _dbTypeBuilder; }
            set { _dbTypeBuilder = value; }
        }

        #endregion
    }
}