public IModelSQLEmit CreateModelSQLEmit(IObjectMapInfoCache cache)
 {
     ITypeMap tm = new TypeMap();
     ISQLTranslator tr = new SQLTranslator();
     IModelColumnsBuilder cb = new ModelColumnsBuilder(tr, tm);
     return new ModelSQLEmit(cache, tr, tm, cb);
 }

        private static Expression CreateDestinationFunc(
            TypeMap typeMap,
            TypeMapRegistry typeMapRegistry,
            ParameterExpression srcParam,
            ParameterExpression destParam,
            ParameterExpression ctxtParam)
        {
            var newDestFunc = ToType(CreateNewDestinationFunc(typeMap, typeMapRegistry, srcParam, ctxtParam),
                typeMap.DestinationTypeToUse);

            var getDest = typeMap.DestinationTypeToUse.GetTypeInfo().IsValueType
                ? newDestFunc
                : Coalesce(destParam, newDestFunc);

            Expression destinationFunc = Assign(destParam, getDest);

            if (typeMap.PreserveReferences)
            {
                var dest = Variable(typeof (object), "dest");

                Expression valueBag = Property(ctxtParam, "InstanceCache");
                var set = Assign(Property(valueBag, "Item", srcParam), dest);
                var setCache =
                    IfThen(NotEqual(srcParam, Constant(null)), set);

                destinationFunc = Block(new[] {dest}, Assign(dest, destinationFunc), setCache, dest);
            }
            return destinationFunc;
        }

            protected override void Establish_context()
            {
                _configuration = new Configuration(new TypeMapFactory(), MapperRegistry.AllMappers());
                _configuration.CreateMap<Source, Destination>();

                _expected = _configuration.FindTypeMapFor(null, typeof(Source), typeof(Destination));
            }

 public override void MapByType( Type t, TypeMap otm )
 {
     this.Context = otm;
     XmlDocument document = new XmlDocument();
     document.Load( this.MappingDocument );
     XmlNode node = document.SelectSingleNode( String.Format( "//type-map[@type={0}]", t.Name ) );
     otm.Table = node.Attributes["table"].InnerText;
 }

        private static MemberAssignment BindCustomProjectionExpression(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
        {
            var visitor = new ParameterReplacementVisitor(result.ResolutionExpression);

            var replaced = visitor.Visit(propertyTypeMap.CustomProjection.Body);

            return Expression.Bind(propertyMap.DestinationProperty.MemberInfo, replaced);
        }

        public void First()
        {
            var map = new TypeMap();

            ushort id;
            Assert.IsTrue (map.GetTypeId (typeof (string), out id));
            Assert.AreEqual (0, id);
        }

        public static NamedTypeSymbol Construct(this NamedTypeSymbol type, params TypeSymbol[] arguments)
        {
            Debug.Assert(type != null);
            Debug.Assert(arguments != null);
            TypeMap map = new TypeMap(ReadOnlyArray<TypeSymbol>.CreateFrom(type.ConstructedFrom.TypeParameters),
                                            arguments.AsReadOnly());

            return map.SubstituteNamedType(type.ConstructedFrom);
        }

        public void Configure(TypeMap typeMap)
        {
            var sourcePropertyConfig = typeMap.FindOrCreateSourceMemberConfigFor(_sourceMember);

            foreach (var action in _sourceMemberActions)
            {
                action(sourcePropertyConfig);
            }
        }

 public SPParameterConfig(SPParameter parameter, TypeMap map)
 {
     Definition = parameter;
     FriendlyName = NamingHelpers.SplitObjectName(Definition.Name);
     IsRequired = Definition.DefaultValue == null;
     Type= map.GetCodeType(Definition.TypeInfo.TypeName);
     SampleValue = Definition.DefaultValue as String;
     Enabled = true;
 }

        public void When_creating_a_new_context_from_an_existing_context_Should_preserve_context_type_map()
        {
            var map = new TypeMap(new TypeInfo(typeof(int)), new TypeInfo(typeof(string)), MemberList.Destination);

            var context = new ResolutionContext(map, 5, typeof(int), typeof(string), new MappingOperationOptions());

            ResolutionContext newContext = context.CreateValueContext(10);

            newContext.GetContextTypeMap().ShouldNotBeNull();
        }

 public TypeMapPlanBuilder(IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry, TypeMap typeMap)
 {
     _configurationProvider = configurationProvider;
     _typeMapRegistry = typeMapRegistry;
     _typeMap = typeMap;
     _source = Parameter(typeMap.SourceType, "src");
     _initialDestination = Parameter(typeMap.DestinationTypeToUse, "dest");
     _context = Parameter(typeof(ResolutionContext), "ctxt");
     _destination = Variable(_initialDestination.Type, "typeMapDestination");
 }

        internal SPConfig(SPInfo definition, ISPLoader loader, TypeMap typeMap)
        {
            _core = definition;
            _loader = loader;
            _typeMap = typeMap;

            //Defaults:
            FriendlyName = NamingHelpers.SplitObjectName(definition.Name);
            Enabled = true;
        }

        public void ToString_Always_Succeeds()
        {
            //Arrange
            var typeMap = new TypeMap(typeof(string), typeof(int));

            //Act
            string actual = typeMap.ToString();

            //Assert
            Assert.AreEqual<string>(string.Format("{{{0}, {1}}}", typeof(string), typeof(int)), actual);
        }

        public void Add_GoodValues_Succeeds()
        {
            //Arrange
            var typeMapCollection = new TypeMapCollection();
            var typeMap = new TypeMap(typeof(Type), typeof(Type));

            //Act
            typeMapCollection.Add(typeMap);

            //Assert
            Assert.AreEqual<TypeMapBase>(typeMap, typeMapCollection.Get(typeof(Type), typeof(Type)));
        }

        public void CtorTypeMap()
        {
            var map = new TypeMap();
            ushort id;
            map.GetTypeId (typeof (string), out id);
            map.GetTypeId (typeof (int), out id);

            var c = new MockClientConnection (new MockConnectionProvider (MockProtocol.Instance));

            var context = new SerializationContext (c, MockProtocol.Instance, map);

            Assert.AreSame (map, context.TypeMap);
        }

        internal static bool HaveSameParameterTypes(ReadOnlyArray<ParameterSymbol> params1, TypeMap typeMap1, ReadOnlyArray<ParameterSymbol> params2, TypeMap typeMap2, bool considerRefOutDifference, bool considerCustomModifiers)
        {
            Contract.ThrowIfNotEquals(params1.Count, params2.Count);

            var numParams = params1.Count;

            for (int i = 0; i < numParams; i++)
            {
                var param1 = params1[i];
                var param2 = params2[i];

                var type1 = SubstituteType(typeMap1, param1.Type);
                var type2 = SubstituteType(typeMap2, param2.Type);

                //the runtime compares custom modifiers using (effectively) SequenceEqual
                if (considerCustomModifiers)
                {
                    if (!type1.IsSameType(type2, ignoreDynamic: true) || !param1.CustomModifiers.SequenceEqual(param2.CustomModifiers))
                    {
                        return false;
                    }
                }
                else if (!type1.IsSameType(type2, ignoreCustomModifiers: true, ignoreDynamic: true))
                {
                    return false;
                }

                var refKind1 = param1.RefKind;
                var refKind2 = param2.RefKind;

                // Metadata signatures don't distinguish ref/out, but C# does - even when comparing metadata method signatures.
                if (considerRefOutDifference)
                {
                    if (refKind1 != refKind2)
                    {
                        return false;
                    }
                }
                else
                {
                    if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None))
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        public void TestSerializationAndDeserialization()
        {
            var map = new TypeMap();
            map.Entries.Add(new TypeInfo());
            map.Entries.Add(new TypeInfo());
            map.Source = "Test Source";

            var f = Path.GetTempFileName();
            map.Save(f);
            var map2 = TypeMap.Load(f);

            Assert.IsNotNull(map2);
            Assert.IsTrue(map.Source == map2.Source);
            Assert.IsTrue(map.Entries.Count == map2.Entries.Count());
        }

        public void Get_GoodValues_ReturnsTypeMap()
        {
            //Arrange
            var typeMapCollection = new TypeMapCollection();
            var typeMap = new TypeMap(typeof(Type), typeof(Type));
            typeMapCollection.Add(typeMap);

            //Act
            var actual = typeMapCollection.Get(typeof(Type), typeof(Type));
            var value = typeMapCollection.Get(typeof(Type), typeof(string));

            //Assert
            Assert.AreEqual<TypeMapBase>(typeMap, actual);
            Assert.IsNull(value);
        }

        public void Multiple()
        {
            var map = new TypeMap();

            ushort id, id2;
            Assert.IsTrue (map.GetTypeId (typeof (string), out id));
            Assert.AreEqual (0, id);

            Assert.IsFalse (map.GetTypeId (typeof (string), out id2));
            Assert.AreEqual (id, id2);

            Assert.IsTrue (map.GetTypeId (typeof (int), out id));
            Assert.AreNotEqual (id2, id);

            Assert.IsFalse (map.GetTypeId (typeof (int), out id2));
            Assert.AreEqual (id, id2);
        }

        public void Ctor()
        {
            var dict = new Dictionary<Type, ushort> { { typeof (string), 0 }, { typeof (int), 1 } };
            TypeMap map = null;
            Assert.DoesNotThrow (() => map = new TypeMap (dict));

            Type type;
            Assert.IsTrue (map.TryGetType (0, out type));
            Assert.AreEqual (typeof (string), type);
            Assert.IsTrue (map.TryGetType (1, out type));
            Assert.AreEqual (typeof (int), type);

            ushort id;
            Assert.IsFalse (map.GetTypeId (typeof (string), out id));
            Assert.AreEqual (0, id);
            Assert.IsFalse (map.GetTypeId (typeof (int), out id));
            Assert.AreEqual (1, id);
        }