Simplified type maps by using static objects to disable as needed.

Signed-off-by: Dimitar Dobrev <[email protected]>

Author: ddobrev

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -381,7 +381,7 @@ public override bool VisitClassDecl(Class @class)
             var typeMaps = new List<System.Type>();
             var keys = new List<string>();
             // disable the type maps, if any, for this class because of copy ctors, operators and others
-            this.DisableTypeMap(@class, typeMaps, keys);
+            this.DisableTypeMap(@class);
 
             PushBlock(BlockKind.Class);
             GenerateDeclarationCommon(@class);
@@ -443,8 +443,8 @@ public override bool VisitClassDecl(Class @class)
             UnindentAndWriteCloseBrace();
             PopBlock(NewLineKind.BeforeNextBlock);
 
-            for (int i = 0; i < typeMaps.Count; i++)
-                Context.TypeMaps.TypeMaps.Add(keys[i], typeMaps[i]);
+            foreach (var typeMap in Context.TypeMaps.TypeMaps.Values)
+                typeMap.IsEnabled = true;
 
             return true;
         }
@@ -694,11 +694,11 @@ public override void GenerateClassSpecifier(Class @class)
                 {
                     var typeMaps = new List<System.Type>();
                     var keys = new List<string>();
-                    this.DisableTypeMap(@base.Class, typeMaps, keys);
+                    this.DisableTypeMap(@base.Class);
                     var printedBase = @base.Type.Desugar().Visit(TypePrinter);
                     bases.Add(printedBase.Type);
-                    for (int i = 0; i < typeMaps.Count; i++)
-                        Context.TypeMaps.TypeMaps.Add(keys[i], typeMaps[i]);
+                    foreach (var typeMap in Context.TypeMaps.TypeMaps.Values)
+                        typeMap.IsEnabled = true;
                 }
             }
 

src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs

@@ -8,14 +8,13 @@ namespace CppSharp.Generators.CSharp
 {
     public static class CSharpSourcesExtensions
     {
-        public static void DisableTypeMap(this CSharpSources gen, Class @class,
-            List<System.Type> typeMaps, List<string> keys)
+        public static void DisableTypeMap(this CSharpSources gen, Class @class)
         {
             var mapped = @class.OriginalClass ?? @class;
-            DisableSingleTypeMap(mapped, typeMaps, keys, gen.Context);
+            DisableSingleTypeMap(mapped, gen.Context);
             if (mapped.IsDependent)
                 foreach (var specialization in mapped.Specializations)
-                    DisableSingleTypeMap(specialization, typeMaps, keys, gen.Context);
+                    DisableSingleTypeMap(specialization, gen.Context);
         }
 
         public static void GenerateNativeConstructorsByValue(
@@ -93,25 +92,16 @@ public static void GenerateMember(this CSharpSources gen,
             }
         }
 
-        private static void DisableSingleTypeMap(Class mapped,
-            List<System.Type> typeMaps, List<string> keys, BindingContext context)
+        private static void DisableSingleTypeMap(Class mapped, BindingContext context)
         {
             var names = new List<string> { mapped.OriginalName };
             foreach (TypePrintScopeKind kind in Enum.GetValues(typeof(TypePrintScopeKind)))
             {
                 var cppTypePrinter = new CppTypePrinter { PrintScopeKind = kind };
                 names.Add(mapped.Visit(cppTypePrinter));
             }
-            foreach (var name in names)
-            {
-                if (context.TypeMaps.TypeMaps.ContainsKey(name))
-                {
-                    keys.Add(name);
-                    typeMaps.Add(context.TypeMaps.TypeMaps[name]);
-                    context.TypeMaps.TypeMaps.Remove(name);
-                    break;
-                }
-            }
+            foreach (var name in names.Where(context.TypeMaps.TypeMaps.ContainsKey))
+                context.TypeMaps.TypeMaps[name].IsEnabled = false;
         }
 
         private static void WriteTemplateSpecializationCheck(CSharpSources gen,

src/Generator/Types/TypeMap.cs

@@ -40,6 +40,8 @@ public class TypeMap
         public Declaration Declaration { get; set; }
         public ITypeMapDatabase TypeMapDatabase { get; set; }
 
+        public bool IsEnabled { get; set; } = true;
+
         public virtual bool IsIgnored
         {
             get { return false; }
@@ -122,7 +124,6 @@ public interface ITypeMapDatabase
         bool FindTypeMapRecursive(Type type, out TypeMap typeMap);
         bool FindTypeMap(Type decl, out TypeMap typeMap);
         bool FindTypeMap(Declaration decl, out TypeMap typeMap);
-        bool FindTypeMap(string name, out TypeMap typeMap);
     }
 
 

src/Generator/Types/TypeMapDatabase.cs

@@ -13,11 +13,11 @@ namespace CppSharp.Types
 {
     public class TypeMapDatabase : ITypeMapDatabase
     {
-        public IDictionary<string, System.Type> TypeMaps { get; set; }
+        public IDictionary<string, TypeMap> TypeMaps { get; set; }
 
         public TypeMapDatabase()
         {
-            TypeMaps = new Dictionary<string, System.Type>();
+            TypeMaps = new Dictionary<string, TypeMap>();
         }
 
         public void SetupTypeMaps(GeneratorKind generatorKind)
@@ -41,14 +41,16 @@ public void SetupTypeMaps(GeneratorKind generatorKind)
 
         private void SetupTypeMaps(IEnumerable<System.Type> types, GeneratorKind generatorKind)
         {
-            foreach (var typeMap in types)
+            foreach (var type in types)
             {
-                var attrs = typeMap.GetCustomAttributes(typeof(TypeMapAttribute), true);
+                var attrs = type.GetCustomAttributes(typeof(TypeMapAttribute), true);
                 foreach (TypeMapAttribute attr in attrs)
                 {
                     if (attr.GeneratorKind == 0 || attr.GeneratorKind == generatorKind)
                     {
-                        TypeMaps[attr.Type] = typeMap;
+                        var typeMap = (TypeMap) Activator.CreateInstance(type);
+                        typeMap.TypeMapDatabase = this;
+                        this.TypeMaps[attr.Type] = typeMap;
                     }
                 }
             }
@@ -164,27 +166,9 @@ public bool FindTypeMapRecursive(Type type, out TypeMap typeMap)
             }
         }
 
-        public bool FindTypeMap(string name, out TypeMap typeMap)
+        private bool FindTypeMap(string name, out TypeMap typeMap)
         {
-            if (string.IsNullOrWhiteSpace(name))
-            {
-                typeMap = null;
-                return false;
-            }
-
-            System.Type type;
-            TypeMaps.TryGetValue(name, out type);
-
-            if (type == null)
-            {
-                typeMap = null;
-                return false;
-            }
-
-            typeMap = (TypeMap)Activator.CreateInstance(type);
-            typeMap.TypeMapDatabase = this;
-
-            return true;
+            return TypeMaps.TryGetValue(name, out typeMap) && typeMap.IsEnabled;
         }
     }
 }