protected virtual AbstractTypeDefinition CreateTemplateOneTypeParamType(TypedefDefinition typedef)
{
if (typedef.IsSharedPtr)
{
return(new DefSharedPtr(typedef.Namespace, typedef.SurroundingClass, typedef.DefiningXmlElement));
}
if (AbstractCodeProducer.IsIteratorWrapper(typedef))
{
return(new DefIterator(typedef.Namespace, typedef.SurroundingClass, typedef.DefiningXmlElement));
}
if (typedef.BaseTypeName.StartsWith("TRect"))
{
return(new DefTRect(typedef.Namespace, typedef.SurroundingClass, typedef.DefiningXmlElement));
}
return(CreateSTLCollectionType(typedef));
}
/// <summary>
/// Generates the code for all types (enums, classes, typedefs, ...) that are nested within the current class.
/// </summary>
/// <seealso cref="GenerateCodePreNestedTypes"/>
/// <seealso cref="GenerateCodePostNestedTypes"/>
protected virtual void GenerateCodeAllNestedTypes()
{
List <AbstractTypeDefinition> enums = new List <AbstractTypeDefinition>();
List <AbstractTypeDefinition> nativePtrClasses = new List <AbstractTypeDefinition>();
List <AbstractTypeDefinition> typedefs = new List <AbstractTypeDefinition>();
List <AbstractTypeDefinition> otherTypes = new List <AbstractTypeDefinition>();
// Only output nested types on interfaces if we are the abstract class
if (_classDefinition.IsInterface && !((this is IncOverridableClassProducer) || (this is OverridableClassCppProducer)))
{
return;
}
foreach (AbstractTypeDefinition nested in _classDefinition.NestedTypes)
{
if (nested.ProtectionLevel == ProtectionLevel.Public ||
((AllowProtectedMembers || AllowSubclassing) &&
nested.ProtectionLevel == ProtectionLevel.Protected))
{
if (nested is EnumDefinition)
{
enums.Add(nested);
}
else if (Wrapper.IsTypeWrappable(nested))
{
if (nested.HasWrapType(WrapTypes.NativePtrValueType))
{
if (nested.HasAttribute <DefinitionIndexAttribute>())
{
nativePtrClasses.Insert(nested.GetAttribute <DefinitionIndexAttribute>().Index, nested);
}
else
{
nativePtrClasses.Add(nested);
}
}
else if (nested is TypedefDefinition)
{
typedefs.Add(nested);
}
else
{
otherTypes.Add(nested);
}
}
}
}
// Add typedefs for value types
foreach (TypedefDefinition nested in typedefs)
{
if (nested.BaseType.Name == "uint32" || nested.BaseType.HasAttribute <ValueTypeAttribute>())
{
GenerateCodeNestedType(nested);
}
}
foreach (AbstractTypeDefinition nested in enums)
{
GenerateCodeNestedType(nested);
}
foreach (AbstractTypeDefinition nested in nativePtrClasses)
{
GenerateCodeNestedType(nested);
}
foreach (AbstractTypeDefinition nested in otherTypes)
{
GenerateCodeNestedType(nested);
}
List <AbstractTypeDefinition> iterators = new List <AbstractTypeDefinition>();
//Add typedefs after class declarations
foreach (TypedefDefinition nested in typedefs)
{
if (nested.BaseType.Name == "uint32" || nested.BaseType.HasAttribute <ValueTypeAttribute>())
{
continue;
}
if (AbstractCodeProducer.IsIteratorWrapper((TypedefDefinition)nested))
{
iterators.Add(nested);
}
else
{
GenerateCodeNestedType(nested);
}
}
//Add iterators last
foreach (AbstractTypeDefinition nested in iterators)
{
GenerateCodeNestedType(nested);
}
// Exit out here if this is CPP
if ((this is OverridableClassCppProducer))
{
return;
}
//Add STL wrappers for fields that doesn't have proper typedefs
List <string> stls = new List <string>();
foreach (MemberDefinitionBase m in _classDefinition.Members)
{
if ((m is MemberFieldDefinition || (m is MemberMethodDefinition && (m as MemberMethodDefinition).IsDeclarableFunction)) &&
!m.IsIgnored &&
(m.ProtectionLevel == ProtectionLevel.Public ||
((AllowSubclassing || AllowProtectedMembers) && m.ProtectionLevel == ProtectionLevel.Protected)))
{
if (m.MemberType.IsUnnamedSTLContainer &&
!stls.Contains(m.MemberType.CLRName))
{
GenerateCodeNestedType(m.MemberType);
stls.Add(m.MemberType.CLRName);
}
}
}
foreach (ClassDefinition iface in _interfaces)
{
if (iface == _classDefinition)
{
continue;
}
foreach (MemberDefinitionBase m in iface.Members)
{
if ((m is MemberFieldDefinition || (m is MemberMethodDefinition && (m as MemberMethodDefinition).IsDeclarableFunction)) &&
!m.IsIgnored &&
(m.ProtectionLevel == ProtectionLevel.Public ||
((AllowSubclassing || AllowProtectedMembers) && m.ProtectionLevel == ProtectionLevel.Protected)))
{
if (m.MemberType.IsUnnamedSTLContainer &&
!stls.Contains(m.MemberType.CLRName))
{
GenerateCodeNestedType(m.MemberType);
stls.Add(m.MemberType.CLRName);
}
}
}
}
}
