private static void MarkForGeneration(ClassTemplateSpecialization specialization)
{
specialization.GenerationKind = GenerationKind.Generate;
Declaration declaration = specialization.TemplatedDecl.TemplatedDecl;
while (declaration != null)
{
declaration.GenerationKind = GenerationKind.Generate;
declaration = declaration.Namespace;
}
}
public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
if (!specialization.IsDependent &&
(!specialization.TranslationUnit.IsSystemHeader ||
specialization.IsSupportedStdSpecialization()))
{
var cppTypePrinter = new CppTypePrinter
{
PrintScopeKind = CppTypePrintScopeKind.Qualified,
PrintLogicalNames = true
};
var cppCode = specialization.Visit(cppTypePrinter);
var module = specialization.TranslationUnit.Module;
if (templateInstantiations.ContainsKey(module))
templateInstantiations[module].Add(cppCode);
else
templateInstantiations.Add(module, new HashSet<string> { cppCode });
}
return true;
}
private ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
}
internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
: this(__CopyValue(native))
{
}
private static bool IsSupportedStdSpecialization(ClassTemplateSpecialization specialization)
{
return IsSupportedStdType(specialization) &&
specialization.Arguments[0].Type.Type.IsPrimitiveType(PrimitiveType.Char);
}
private ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
public static ClassTemplateSpecialization __CreateInstance(ClassTemplateSpecialization.Internal native)
{
return new ClassTemplateSpecialization(native);
}
private ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native, bool skipVTables = false)
: this(__CopyValue(native), skipVTables)
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
private static void* __CopyValue(ClassTemplateSpecialization.__Internal native)
{
var ret = Marshal.AllocHGlobal(332);
global::CppSharp.Parser.AST.ClassTemplateSpecialization.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
return ret.ToPointer();
}
public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
specialization.ExplicitlyIgnore();
return(false);
}
public bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
return(false);
}
public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
WriteLine($"template class {GetExporting()}{specialization.Visit(cppTypePrinter)};");
return(true);
}
public virtual TypePrinterResult VisitClassTemplateSpecializationDecl(
ClassTemplateSpecialization specialization)
{
throw new NotImplementedException();
}
public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
Library.ClassTemplateSpecializationDecls.Add(specialization.Name);
return(true);
}
internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native)
: this(new global::System.IntPtr(native))
{
}
internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
: this(&native)
{
}
private Class GetNewInterface(string name, Class @base)
{
var specialization = @base as ClassTemplateSpecialization;
Class @interface;
if (specialization == null)
{
@interface = new Class();
}
else
{
Class template = specialization.TemplatedDecl.TemplatedClass;
Class templatedInterface = GetInterface(template);
@interface = interfaces.FirstOrDefault(i => i.OriginalClass == @base);
if (@interface != null)
{
return(@interface);
}
var specializedInterface = new ClassTemplateSpecialization();
specializedInterface.Arguments.AddRange(specialization.Arguments);
specializedInterface.TemplatedDecl = new ClassTemplate {
TemplatedDecl = templatedInterface
};
@interface = specializedInterface;
}
@interface.Name = name;
@interface.USR = @base.USR;
@interface.Namespace = @base.Namespace;
@interface.Access = @base.Access;
@interface.Type = ClassType.Interface;
@interface.OriginalClass = @base;
@interface.Bases.AddRange(
from b in @base.Bases
where b.Class != null
let i = GetInterface(b.Class)
select new BaseClassSpecifier(b)
{
Type = new TagType(i)
});
@interface.Methods.AddRange(
from m in @base.Methods
where !m.IsConstructor && !m.IsDestructor && !m.IsStatic &&
(m.IsGenerated || (m.IsInvalid && specialization != null)) && !m.IsOperator
select new Method(m)
{
Namespace = @interface, OriginalFunction = m
});
@interface.Properties.AddRange(
from property in @base.Properties
where property.IsDeclared
select CreateInterfaceProperty(property, @interface));
@interface.Fields.AddRange(@base.Fields);
// avoid conflicts when potentially renaming later
@interface.Declarations.AddRange(@base.Declarations);
if (@interface.Bases.Count == 0)
{
var instance = new Property
{
Namespace = @interface,
Name = Helpers.InstanceIdentifier,
QualifiedType = new QualifiedType(new BuiltinType(PrimitiveType.IntPtr)),
GetMethod = new Method
{
SynthKind = FunctionSynthKind.InterfaceInstance,
Namespace = @interface
}
};
@interface.Properties.Add(instance);
var dispose = new Method
{
Namespace = @interface,
Name = "Dispose",
ReturnType = new QualifiedType(new BuiltinType(PrimitiveType.Void)),
SynthKind = FunctionSynthKind.InterfaceDispose,
Mangled = string.Empty
};
@interface.Methods.Add(dispose);
}
@interface.Events.AddRange(@base.Events);
var type = new QualifiedType(new BuiltinType(PrimitiveType.IntPtr));
var adjustmentTo = new Property
{
Namespace = @interface,
Name = "__PointerTo" + @base.Name,
QualifiedType = type,
GetMethod = new Method
{
SynthKind = FunctionSynthKind.InterfaceInstance,
Namespace = @interface,
ReturnType = type
}
};
@interface.Properties.Add(adjustmentTo);
@base.Properties.Add(adjustmentTo);
@base.Bases.Add(new BaseClassSpecifier {
Type = new TagType(@interface)
});
interfaces.Add(@interface);
if (@base.IsTemplate)
{
@interface.IsDependent = true;
@interface.TemplateParameters.AddRange(@base.TemplateParameters);
templatedInterfaces[@base] = @interface;
foreach (var spec in @base.Specializations)
{
@interface.Specializations.Add(
(ClassTemplateSpecialization)GetNewInterface(name, spec));
}
}
return(@interface);
}
public static ClassTemplateSpecialization __CreateInstance(ClassTemplateSpecialization.Internal native, bool skipVTables = false)
{
return new ClassTemplateSpecialization(native, skipVTables);
}
public bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
throw new NotImplementedException();
}
protected ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native, bool skipVTables = false)
: base((CppSharp.Parser.AST.Class.Internal*) null)
{
__PointerAdjustment = 0;
if (native == null)
return;
__Instance = new global::System.IntPtr(native);
}
public string VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
return(VisitClassDecl(specialization));
}
private static ClassTemplateSpecialization.Internal* __CopyValue(ClassTemplateSpecialization.Internal native)
{
var ret = Marshal.AllocHGlobal(552);
CppSharp.Parser.AST.ClassTemplateSpecialization.Internal.cctor_2(ret, new global::System.IntPtr(&native));
return (ClassTemplateSpecialization.Internal*) ret;
}
public virtual bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
{
return(VisitClassDecl(specialization));
}
protected ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native, bool isInternalImpl = false)
: base((CppSharp.Parser.AST.Class.Internal*) native)
{
}
public override TypePrinterResult VisitClassTemplateSpecializationDecl(
ClassTemplateSpecialization specialization)
{
return(VisitClassDecl(specialization));
}
