public override bool VisitTemplateSpecializationType(TemplateSpecializationType template, TypeQualifiers quals)
        {
            if (AlreadyVisited(template) || template.Template.Access == AccessSpecifier.Private)
                return false;

            if (template.Arguments.Select(a => a.Type.Type.Desugar()).All(t => t.IsAddress() && !t.GetFinalPointee().IsDependent))
            {
                var cppTypePrinter = new CppTypePrinter { PrintScopeKind = CppTypePrintScopeKind.Qualified };
                templateInstantiations.Add(string.Format("{0}<{1}>", template.Template.Name,
                    string.Join(", ", template.Arguments.Select(a => a.Type.Type.Visit(cppTypePrinter)))));
            }

            return true;
        }

 protected TemplateSpecializationType(TemplateSpecializationType.Internal* native, bool isInternalImpl = false)
     : base((CppSharp.Parser.AST.Type.Internal*) native)
 {
 }

 private static TemplateSpecializationType.Internal* __CopyValue(TemplateSpecializationType.Internal native)
 {
     var ret = Marshal.AllocHGlobal(48);
     CppSharp.Parser.AST.TemplateSpecializationType.Internal.cctor_1(ret, new global::System.IntPtr(&native));
     return (TemplateSpecializationType.Internal*) ret;
 }

 public static TemplateSpecializationType __CreateInstance(TemplateSpecializationType.Internal native)
 {
     return new TemplateSpecializationType(native);
 }

 protected TemplateSpecializationType(TemplateSpecializationType.Internal* native, bool skipVTables = false)
     : base((CppSharp.Parser.AST.Type.Internal*) null)
 {
     __PointerAdjustment = 0;
     if (native == null)
         return;
     __Instance = new global::System.IntPtr(native);
 }

 public static TemplateSpecializationType __CreateInstance(TemplateSpecializationType.Internal native, bool skipVTables = false)
 {
     return new TemplateSpecializationType(native, skipVTables);
 }

 private static void* __CopyValue(TemplateSpecializationType.__Internal native)
 {
     var ret = Marshal.AllocHGlobal(32);
     global::CppSharp.Parser.AST.TemplateSpecializationType.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
     return ret.ToPointer();
 }

 internal TemplateSpecializationType(TemplateSpecializationType.Internal native)
     : this(&native)
 {
 }

 private TemplateSpecializationType(TemplateSpecializationType.Internal native)
     : this(__CopyValue(native))
 {
     __ownsNativeInstance = true;
 }

 internal TemplateSpecializationType(TemplateSpecializationType.Internal native)
     : this(__CopyValue(native))
 {
 }

 public override bool VisitTemplateSpecializationType(
     TemplateSpecializationType template, TypeQualifiers quals)
 {
     TypeMap typeMap;
     if (TypeMapDatabase.FindTypeMap(template, out typeMap))
     {
         if (typeMap.IsIgnored)
             Ignore();
         return false;
     }
     Ignore();
     return base.VisitTemplateSpecializationType(template, quals);
 }

        public override bool VisitTemplateSpecializationType(TemplateSpecializationType template,
                                                    TypeQualifiers quals)
        {
            TypeMap typeMap;
            if (Context.Driver.TypeDatabase.FindTypeMap(template, out typeMap) && typeMap.DoesMarshalling)
            {
                typeMap.Type = template;
                typeMap.CLIMarshalToManaged(Context);
                return true;
            }

            return template.Template.Visit(this);
        }

        public override bool VisitTemplateSpecializationType(
            TemplateSpecializationType template, TypeQualifiers quals)
        {
            TypeMap typeMap;
            if (TypeMapDatabase.FindTypeMap(template, out typeMap))
            {
                if (typeMap.IsIgnored)
                    Ignore();
                return false;
            }

            var specialization = template.GetClassTemplateSpecialization();
            if (specialization == null || specialization.Ignore)
                Ignore();
            return base.VisitTemplateSpecializationType(template, quals);
        }