public void InitializeTypeMapper(ITypeMapper typeMapper)
        {
            var thisAssembly = Assembly.GetAssembly(GetType());

            foreach (var type in thisAssembly.GetTypes())
            {
                if (!type.IsConcrete())
                    continue;

                var interfaceName = "I" + type.Name;

                var interface_ = type.GetInterface(interfaceName);

                if (interface_ == null)
                    continue;

                // This was tricky to figure out, just getting the interface will get
                // you the generic type w/o generic parameters, not the generic type
                // definition.
                var mappedInterface = (interface_.IsGenericType)
                                          ? interface_.GetGenericTypeDefinition()
                                          : interface_;

                var mappedType = (type.IsGenericType)
                                     ? type.GetGenericTypeDefinition()
                                     : type;

                typeMapper.Map(mappedInterface, mappedType);
            }
        }

 public DataSourceRootNode(ITypeMapper typeMapper, IPomonaDataSource dataSource)
     : base(typeMapper, null, "/")
 {
     if (dataSource == null)
         throw new ArgumentNullException("dataSource");
     this.dataSource = dataSource;
 }

		public NewDelegate(Type delegateType, Operand target, string methodName, ITypeMapper typeMapper)
		{
			_delegateType = delegateType;
			_target = target;
		    _typeMapper = typeMapper;
		    Initialize(target.GetReturnType(typeMapper), methodName);
		}

        public string GetDeleteSql(ITypeMapper mapper, string whereSql)
        {
            if (string.IsNullOrEmpty(whereSql))
                return string.Format("Delete From {0}", DecorateName(mapper.TableName));

            return string.Format("Delete From {0} Where {1}", DecorateName(mapper.TableName), whereSql);
        }

        public void InitializeTypeMapper(ITypeMapper typeMapper)
        {
            typeMapper.Map<IList, ArrayList>();
            typeMapper.Map<IDictionary, Hashtable>();

            typeMapper.Map(typeof(IList<>), typeof(List<>));
            typeMapper.Map(typeof(IDictionary<,>), typeof(Dictionary<,>));
        }

 public UriResolver(ITypeMapper typeMapper, IBaseUriProvider baseUriProvider)
 {
     if (typeMapper == null)
         throw new ArgumentNullException("typeMapper");
     if (baseUriProvider == null)
         throw new ArgumentNullException("baseUriProvider");
     this.typeMapper = typeMapper;
     this.baseUriProvider = baseUriProvider;
 }

 public PomonaHttpQueryTransformer(ITypeMapper typeMapper, QueryExpressionParser parser)
 {
     if (typeMapper == null)
         throw new ArgumentNullException("typeMapper");
     if (parser == null)
         throw new ArgumentNullException("parser");
     this.typeMapper = typeMapper;
     this.parser = parser;
 }

 protected Delta(object original, TypeSpec type, ITypeMapper typeMapper, Delta parent = null)
 {
     if (original == null) throw new ArgumentNullException("original");
     if (type == null) throw new ArgumentNullException("type");
     if (typeMapper == null) throw new ArgumentNullException("typeMapper");
     Original = original;
     Type = type;
     TypeMapper = typeMapper;
     this.parent = parent;
 }

        public static ITypeMapper Creator()
        {
            if (instance == null)
            {
                string typeName = ConfigManager.SettingsSection.AppSettings["typeMapper"].Value;
                instance = (ITypeMapper)Activator.CreateInstance(Type.GetType(typeName));
            }

            return instance;
        }

 public InsertDataCommand(ICommandPerformer<string> exec, ICache cache, ITypeMapper mapper, EntityData value)
 {
     this.value = value;
     this.cache = cache;
     this.executor = exec;
     this.schema = cache.Pick<Document>();
     this.nameSpace = schema.Settings[Keys.Namespace];
     this.mapper = mapper;
     this.properties = schema.Entities.Single(x => x.Name == value.EntityName).Properties;
 }

 protected PathNode(ITypeMapper typeMapper, PathNode parent, string name)
 {
     if (typeMapper == null)
         throw new ArgumentNullException("typeMapper");
     if (name == null)
         throw new ArgumentNullException("name");
     this.typeMapper = typeMapper;
     this.parent = parent;
     this.name = name;
 }

        void Initialize(ITypeMapper typeMapper)
        {
            if (_initialized) return;
            _initialized = true;

            // TODO: proper checking as in specification
            if (_ifTrue.GetReturnType(typeMapper) != _ifFalse.GetReturnType(typeMapper))
                throw new ArgumentException(Properties.Messages.ErrInvalidConditionalVariants);

            if (_cond.GetReturnType(typeMapper) != typeMapper.MapType(typeof(bool))) _cond = _cond.IsTrue();
        }

        public void CreateContext()
        {
            _typeMapper = new Moq.Mock<ITypeMapper>().Object;
            _random = new Moq.Mock<IRandom>().Object;
            _idGenerator = new Moq.Mock<IIdGenerator>().Object;

            var context = Create();

            Assert.That(context.TypeMapper, Is.Not.Null);
            Assert.That(context.Random, Is.Not.Null);
            Assert.That(context.IdGenerator, Is.Not.Null);
        }

 public ResourceResolver(ITypeMapper typeMapper, NancyContext context, IRouteResolver routeResolver)
 {
     if (typeMapper == null)
         throw new ArgumentNullException("typeMapper");
     if (context == null)
         throw new ArgumentNullException("context");
     if (routeResolver == null)
         throw new ArgumentNullException("routeResolver");
     //if (routeResolver == null) throw new ArgumentNullException("routeResolver");
     this.typeMapper = typeMapper;
     this.context = context;
     this.routeResolver = routeResolver;
 }

        public IEnumerable<IGeneratedType> GenerateTypes(IEnumerable<ITypeDescription> typeDescriptions, ITypeMapper typeMapper)
        {
            if (typeDescriptions == null)
            {
                throw new ArgumentNullException("typeDescriptions");
            }

            if (typeMapper == null)
            {
                throw new ArgumentNullException("typeMapper");
            }

            Validate(typeDescriptions);

            var name = "PocoAssembly";
            var assemblyName = new AssemblyName(name);
            var appDomain = Thread.GetDomain();

            AssemblyBuilder assemblyBuilder;
            ModuleBuilder moduleBuilder;

            if (this.getTypeFromDiskAssembly)
            {
                assemblyBuilder = appDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
                moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, this.assemblyName);
            }
            else
            {
                assemblyBuilder = appDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
                moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
            }

            var generatedTypes = new List<IGeneratedType>();
            foreach (var typeDescription in typeDescriptions)
            {
                var result = GenerateType(moduleBuilder, typeDescription, typeMapper);
                typeMapper.RegisterNewType(typeDescription, result);
                generatedTypes.Add(result);
            }

            if (this.getTypeFromDiskAssembly)
            {
                var generatedConvertedTypes = this.LoadFromDisk(assemblyBuilder, generatedTypes);

                return generatedConvertedTypes;
            }
            else
            {
                return generatedTypes;
            }
        }

 /// <summary>
 /// Import framework options from an existing type
 /// </summary>
 public void SetFrameworkOptions(Type from, ITypeMapper mapper)
 {
     if (@from == null) throw new ArgumentNullException(nameof(@from));
     AttributeMap[] attribs = AttributeMap.Create(mapper, @from.Assembly);
     foreach (AttributeMap attrib in attribs)
     {
         if (attrib.AttributeType.FullName == "System.Runtime.Versioning.TargetFrameworkAttribute")
         {
             object tmp;
             if (attrib.TryGet("FrameworkName", out tmp)) TargetFrameworkName = (string)tmp;
             if (attrib.TryGet("FrameworkDisplayName", out tmp)) TargetFrameworkDisplayName = (string)tmp;
             break;
         }
     }
 }

        /// <summary>
        /// Initialize a new object.
        /// </summary>
        /// <param name="nativeDbType">Native database type as used in stored procedures.</param>
        /// <param name="typeMapper">Mapps native to target data types and renders code items associated with data type.</param>
        /// <param name="precision">Native DB type precision - if applicable.</param>
        /// <param name="scale">Native DB type scale - if applicable.</param>
        public TypeInfo(string nativeDbType, ITypeMapper typeMapper, int precision, int scale)
        {
            this.typeMapper = typeMapper;
            this.precision = precision;
            this.scale = scale;

            this.NativeDbType = typeMapper.NativeDbType(nativeDbType);
            this.IsVariableLengthNativeType = typeMapper.IsVariableLengthNativeType(nativeDbType);
            this.Type = typeMapper.Type(nativeDbType, precision, scale);
            this.DefaultValue = typeMapper.DefaultValue(nativeDbType, precision, scale);
            this.IsValueType = typeMapper.IsValueType(nativeDbType);
            this.DbType = typeMapper.DbType(nativeDbType);
            this.NullableType = typeMapper.NullableType(nativeDbType, precision, scale);
            this.NullValue = typeMapper.NullValue(nativeDbType, precision, scale);
            this.DataType = typeMapper.GetType(nativeDbType, precision, scale);
        }

 public ResourceNode(ITypeMapper typeMapper,
     PathNode parent,
     string name,
     Func<object> valueFetcher,
     ResourceType expectedType)
     : base(typeMapper, parent, name)
 {
     this.value = new System.Lazy<object>(valueFetcher);
     this.expectedType = expectedType;
     this.type = new System.Lazy<ResourceType>(() =>
     {
         var localValue = Value;
         if (Value == null)
             return expectedType;
         return (ResourceType)typeMapper.GetClassMapping(localValue.GetType());
     });
 }

 /// <summary>
 /// Adds a type mapper to the chain with given priority. If mapper privided as an external MBean, the
 /// <paramref name="objectName"/> arguments is the name of this MBean; otherwise it is null.
 /// </summary>
 /// <param name="mapper">The mapper instance. In case of external mapper this is a reference to proxy of the MBean.</param>
 /// <param name="objectName">In case of external mapper, this is its <see cref="ObjectName"/>.</param>
 /// <param name="priority">The priority of a mapper. Must be unique.</param>
 /// <exception cref="NonUniquePriorityException">Another mapper with privided priority is already registered.</exception>
 public void AddTypeMapper(ITypeMapper mapper, ObjectName objectName, int priority)
 {
     TypeMapperInfo newMapperInfo = new TypeMapperInfo(priority, objectName == null ? mapper.GetType().AssemblyQualifiedName : null, objectName);
      if (_mappers.ContainsKey(priority))
      {
     TypeMapperInfo exisingMapperInfo = _mapperInfos.Find(delegate(TypeMapperInfo info)
                                                             {
                                                                return info.Priority == priority;
                                                             });
     throw new NonUniquePriorityException(
        newMapperInfo.ObjectName != null ? newMapperInfo.ObjectName.ToString() : newMapperInfo.TypeName,
        exisingMapperInfo.ObjectName != null ? exisingMapperInfo.ObjectName.ToString() : exisingMapperInfo.TypeName,
        priority
        );
      }
      _mappers.Add(priority, mapper);
      _mapperInfos.Add(newMapperInfo);
 }

        public Generator(IPocoGenertor pocoGenerator, ITypeMapper typeMapper)
        {
            if (pocoGenerator == null)
            {
                throw new ArgumentNullException("pocoGenerator");
            }

            this.typeCache = new Dictionary<Type, IGeneratedType>();
            this.typeDescritpionCache = new Dictionary<ITypeDescription, IGeneratedType>();
            this.methodCache = new Dictionary<MethodInfo, IGeneratedType>();
            this.typeMapper = typeMapper;
            this.pocoGenerator = pocoGenerator;

            if (this.typeMapper == null)
            {
                this.typeMapper = new DefaultTypeMapper(this.typeDescritpionCache);
            }
        }