public ValueCalculatorFactory(ITypeConverter typeConverter)
        {
            if (typeConverter == null)
                throw new ArgumentNullException("typeConverter");

            _typeConverter = typeConverter;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileFieldMapping"/> class.
        /// </summary>
        /// <param name="property">
        /// The property.
        /// </param>
        /// <param name="nameExpression">
        /// The name expression.
        /// </param>
        /// <param name="contentExpression">
        /// The content expression.
        /// </param>
        /// <param name="locationExpression">
        /// The location expression.
        /// </param>
        /// <param name="typeConverter">
        /// The type converter.
        /// </param>
        /// <param name="fileManager">
        /// The file manager.
        /// </param>
        public FileFieldMapping(
            PropertyInfo property,
            MappingExpression nameExpression,
            MappingExpression contentExpression,
            MappingExpression locationExpression,
            ITypeConverter typeConverter,
            IFileManager fileManager)
        {
            if (property == null)
                throw new ArgumentNullException("property");

            if (!typeof(IFileProcess).IsAssignableFrom(property.PropertyType))
                throw new ArgumentException("The specified property is not a file field.");

            if (typeConverter == null)
                throw new ArgumentNullException("typeConverter");

            if (fileManager == null)
                throw new ArgumentNullException("fileManager");

            _property = property;
            _nameExpression = nameExpression;
            _contentExpression = contentExpression;
            _locationExpression = locationExpression;
            _typeConverter = typeConverter;
            _fileManager = fileManager;
        }

		protected virtual void AddFactories(IConfiguration facilityConfig, ITypeConverter converter)
		{
			if (facilityConfig != null)
			{
				foreach(IConfiguration config in facilityConfig.Children["factories"].Children)
				{
					String id = config.Attributes["id"];
					String creation = config.Attributes["creation"];
					String destruction = config.Attributes["destruction"];

					Type factoryType = (Type)
						converter.PerformConversion( config.Attributes["interface"], typeof(Type) );

					try
					{
						AddTypedFactoryEntry( 
							new FactoryEntry(id, factoryType, creation, destruction) );
					}
					catch(Exception)
					{
						string message = "Invalid factory entry in configuration";

						throw new ConfigurationErrorsException(message);
					}
				}
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="SingleCrossReferenceFieldMapping"/> class.
        /// </summary>
        /// <param name="property">
        /// The property.
        /// </param>
        /// <param name="valueExpression">
        /// The value expression.
        /// </param>
        /// <param name="isKey">
        /// Specifies whether this is a key mapping.
        /// </param>
        /// <param name="typeConverter">
        /// The type converter.
        /// </param>
        /// <param name="dynamicTypeManager">
        /// The dynamic type manager.
        /// </param>
        /// <param name="runtimeDatabase">
        /// The runtime database.
        /// </param>
        /// <param name="childMappings">
        /// The child mappings.
        /// </param>
        public SingleCrossReferenceFieldMapping(
            PropertyInfo property,
            MappingExpression valueExpression,
            bool isKey,
            ITypeConverter typeConverter,
            IDynamicTypeManager dynamicTypeManager,
            IRuntimeDatabase runtimeDatabase,
            IEnumerable<IProcessFieldMapping> childMappings)
        {
            if (property == null)
                throw new ArgumentNullException("property");

            var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>();
            if (crAttribute == null || crAttribute.AllowMultiple || !typeof(int?).IsAssignableFrom(property.PropertyType))
                throw new ArgumentException("The specified property is not a single cross reference field.");

            if (typeConverter == null)
                throw new ArgumentNullException("typeConverter");

            if (dynamicTypeManager == null)
                throw new ArgumentNullException("dynamicTypeManager");

            if (runtimeDatabase == null)
                throw new ArgumentNullException("runtimeDatabase");

            _property = property;
            _valueExpression = valueExpression;
            _isKey = isKey;
            _typeConverter = typeConverter;
            _dynamicTypeManager = dynamicTypeManager;
            _runtimeDatabase = runtimeDatabase;
            _childMappings = (childMappings ?? Enumerable.Empty<IProcessFieldMapping>()).ToArray();
            _referencedProcessName = crAttribute.ReferenceTableName;
        }

		protected override void Init()
		{
			converter = (ITypeConverter) Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);

			Kernel.ComponentModelCreated +=OnComponentModelCreated;
			Kernel.ComponentRegistered +=OnComponentRegistered;
		}

        public ValueBuilder(CultureInfo cultureInfo, ITypeConverter typeConverter)
        {
            // register custom BooleanTypeConverter, this might be a bad idea.
            TypeConverterAttribute converterAttribute = new TypeConverterAttribute(typeof(CustomBooleanConverter));
            _typeDescriptorProvider = TypeDescriptor.AddAttributes(typeof(Boolean), converterAttribute);

            this._typeConverter = typeConverter;
            this._culture = cultureInfo;
            this._errorCollector = null;
            this._targetType = new Stack<Type>();
            this._errorHandlers = new Stack<EventHandler<ErrorEventArg>>();
            this.ResolveInterfaceType +=
                (sender, args) =>
                {
                    if (args.RealType != null)
                        return;

                    if (typeof(IEnumerable) == args.InterfaceType)
                        args.RealType = typeof(List<object>);
                    else
                    {
                        Type[] genArgs;
                        if (args.InterfaceType.IsOfGenericType(typeof(IEnumerable<>), out genArgs))
                            args.RealType = typeof(List<>).MakeGenericType(genArgs);
                        if (args.InterfaceType.IsOfGenericType(typeof(IList<>), out genArgs))
                            args.RealType = typeof(List<>).MakeGenericType(genArgs);
                        else if (args.InterfaceType.IsOfGenericType(typeof(IDictionary<,>), out genArgs))
                            args.RealType = typeof(Dictionary<,>).MakeGenericType(genArgs);
                        else if (args.InterfaceType.IsOfGenericType(typeof(ILookup<,>), out genArgs))
                            args.RealType = typeof(Lookup<,>).MakeGenericType(genArgs);
                    }
                };
        }

        public static IDictionary<string, object> FormatParameters(
            IList<CommandActionParameter> source,
            IList<ParameterDescription> description,
            ITypeConverter converter)
        {
            // Determine parameter values
            Dictionary<string, object> result = new Dictionary<string, object>();

            foreach (CommandActionParameter param in source)
            {
                string name = param.Name;
                object value = param.Value;

                // Find the description of the parameter
                ParameterDescription expectedParam =
                    description.FirstOrDefault(p => p.Name == name);

                // Custom conversion
                value = converter.ConvertClrObject(value, expectedParam.Type);

                result.Add(name, value);
            }

            return result;
        }

 public static ITypeConverter Combine(ICustomAttributeProvider attributeProvider, ITypeConverter typeConverter)
 {
     var results = GetTypeConverters(attributeProvider);
     if (!results.Any())
         return typeConverter;
     else
         return new CombinedTypeConverter(results.Concat(new[] { typeConverter }).ToArray());
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:System.Object"/> class.
        /// </summary>
        public CollectionConverterFixture()
        {
            this.converter = new CollectionConverter();
            this.context = new BindingContext() { TypeConverters = new[] { new FallbackConverter() } };

            this.mockStringTypeConverter = A.Fake<ITypeConverter>();
            A.CallTo(() => mockStringTypeConverter.CanConvertTo(null, null)).WithAnyArguments().Returns(true);
            A.CallTo(() => mockStringTypeConverter.Convert(null, null, null)).WithAnyArguments().Returns(string.Empty);
        }

 public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result)
 {
     if ((Context & context) == context)
     {
         return Converter.TryConvertTo(root, context, convertTo, value, out result);
     }
     result = null;
     return false;
 }

 public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result)
 {
     if (convertTo == typeof(string[]) && (value?.GetType().IsArray ?? false))
     {
         result = new[] { string.Join(",", ((Array)value).Cast<object>().Select(x => root.ConvertTo<string>(context, x))) };
         return true;
     }
     result = null;
     return false;
 }

 public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result)
 {
     foreach (var typeConverter in typeConverters)
     {
         if (typeConverter.TryConvertTo(root, context, convertTo, value, out result))
             return true;
     }
     result = null;
     return false;
 }

		/// <summary>
		///   Initializes a new instance of the <see cref = "RemotingInspector" /> class.
		/// </summary>
		/// <param name = "converter">The converter.</param>
		/// <param name = "isServer">if set to <c>true</c> is a server.</param>
		/// <param name = "isClient">if set to <c>true</c> is a client.</param>
		/// <param name = "baseUri">The base URI.</param>
		/// <param name = "remoteRegistry">The remote registry.</param>
		/// <param name = "localRegistry">The local registry.</param>
		public RemotingInspector(ITypeConverter converter, bool isServer, bool isClient,
		                         String baseUri, RemotingRegistry remoteRegistry, RemotingRegistry localRegistry)
		{
			this.converter = converter;
			this.isServer = isServer;
			this.isClient = isClient;
			this.baseUri = baseUri;
			this.remoteRegistry = remoteRegistry;
			this.localRegistry = localRegistry;
		}

        public XmlSerializableDeserializerSelector(ICompositeObjectContextFactory objectContextFactory, ITypeConverter typeConverter)
        {
            if (objectContextFactory == null)
                throw new ArgumentNullException("objectContextFactory");
            if (typeConverter == null)
                throw new ArgumentNullException("typeConverter");

            _deserializer = new XmlSerializableDeserializer(objectContextFactory, typeConverter);
            _typeConverter = typeConverter;
        }

 public void AddConverter(ITypeConverter converter, int? index = null)
 {
     using (_lock.EnterWriteScope())
     {
         if (index != null)
             _converters.Insert(index.Value, converter);
         else
             _converters.Add(converter);
     }
 }

 public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result)
 {
     if (convertTo.IsInstanceOfType(value))
     {
         result = value;
         return true;
     }
     result = null;
     return false;
 }

		public void Add(ITypeConverter converter)
		{
			converter.Context = this;

			converters.Add(converter);

			if (!(converter is IKernelDependentConverter))
			{
				standAloneConverters.Add(converter);
			}
		}

        public CanonicalFunctionMapper(ITypeConverter converter)
        {
            this.converter = new EdmTypeConverter(converter);
            this.mappings = new Dictionary<string, Func<EdmFunction, Expression[], Expression>>();

            this.AddStringMappings();
            this.AddDateTimeMappings();
            this.AddMathMappings();
            this.AddBitwiseMappings();
            this.AddMiscMappings();
        }

 public object GetField(string name, object ifNull, ITypeConverter converter)
 {
     var v = GetField(name, converter);
     if (v == null || v == DBNull.Value)
     {
         return ifNull;
     }
     else
     {
         return v;
     }
 }

		protected override void Init()
		{
			converter = (ITypeConverter)Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
			Kernel.ComponentModelBuilder.AddContributor(new StartableContributor(converter));
			if(optimizeForSingleInstall)
			{
				Kernel.HandlersChanged += StartAll;
				Kernel.ComponentRegistered += CacheForStart;
				return;
			}
			Kernel.ComponentRegistered +=OnComponentRegistered;
		}