private TypeScriptInterface BuildInterface(CodeClass codeClass, TypeScriptInterfaceAttributeValues attributeValues, TypeContext typeContext)
{
var tsInterface = new TypeScriptInterface
{
FullName = codeClass.FullName,
Name = GetInterfaceName(attributeValues)
};
TypescriptType indexedType;
if (TryGetIndexedType(codeClass, typeContext, out indexedType))
{
tsInterface.IndexedType = indexedType;
}
new ClassTraverser(codeClass, (property) =>
{
TypeScriptInterfaceMember member;
if (TryGetMember(property, typeContext, out member))
{
tsInterface.Members.Add(member);
}
});
return(tsInterface);
}
public InterfaceType(string name)
{
AttributeValues = new TypeScriptInterfaceAttributeValues
{
Name = name
};
}
public InterfaceType(string name)
{
AttributeValues = new TypeScriptInterfaceAttributeValues
{
Name = name
};
}
private string GetInterfaceName(TypeScriptInterfaceAttributeValues attributeValues)
{
if (!string.IsNullOrEmpty(attributeValues.NamePrefix))
{
return(attributeValues.NamePrefix + attributeValues.Name);
}
return(attributeValues.Name);
}
private TypeScriptInterface BuildInterface(
CodeClass codeClass,
TypeScriptInterfaceAttributeValues attributeValues,
TypeContext typeContext,
bool directlyMarkedInterface,
bool indirectlyMarkedInterface
)
{
var tsInterface = new TypeScriptInterface
{
FullName = codeClass.FullName,
Name = GetInterfaceName(attributeValues),
IsIndirectlyMarkedInterface = indirectlyMarkedInterface,
IsDirectlyMarkedInterface = directlyMarkedInterface
};
try {
tsInterface.DocComment = codeClass.DocComment;
}
catch (Exception exception) {
tsInterface.DocComment = "Error resolving CodeClass.DocComment.";
}
TypescriptType indexedType;
if (TryGetIndexedType(codeClass, typeContext, out indexedType))
{
tsInterface.IndexedType = indexedType;
}
new ClassTraverser(codeClass, (property) =>
{
TypeScriptInterfaceMember member;
if (TryGetMember(property, typeContext, out member))
{
tsInterface.Members.Add(member);
}
});
return(tsInterface);
}
private void ProcessCodeClass(TypeContext typeContext, IDictionary <CodeClass, TypeScriptInterface> tsMap,
IDictionary <string, TypeScriptModule> byModuleName, CodeClass codeClass)
{
InterfaceType interfaceType;
if (typeContext.TryGetInterfaceType(codeClass.FullName, out interfaceType))
{
TypeScriptInterfaceAttributeValues values = interfaceType.AttributeValues;
TypeScriptModule module;
if (!byModuleName.TryGetValue(values.Module, out module))
{
module = new TypeScriptModule {
QualifiedName = values.Module
};
byModuleName.Add(values.Module, module);
}
TypeScriptInterface tsInterface = BuildInterface(codeClass, values, typeContext);
tsMap.Add(codeClass, tsInterface);
tsInterface.Module = module;
module.Interfaces.Add(tsInterface);
}
}
private string GetInterfaceName(TypeScriptInterfaceAttributeValues attributeValues)
{
if (!string.IsNullOrEmpty(attributeValues.NamePrefix))
return attributeValues.NamePrefix + attributeValues.Name;
return attributeValues.Name;
}
private TypeScriptInterface BuildInterface(CodeClass codeClass, TypeScriptInterfaceAttributeValues attributeValues, TypeContext typeContext)
{
var tsInterface = new TypeScriptInterface
{
FullName = codeClass.FullName,
Name = GetInterfaceName(attributeValues)
};
TypescriptType indexedType;
if (TryGetIndexedType(codeClass, typeContext, out indexedType))
tsInterface.IndexedType = indexedType;
new ClassTraverser(codeClass, (property) =>
{
TypeScriptInterfaceMember member;
if (TryGetMember(property, typeContext, out member))
tsInterface.Members.Add(member);
});
return tsInterface;
}
private void BuildCodeClass(TypeContext typeContext, CodeClass codeClass, CodeClass owner = null, bool forcedProcessing = false)
{
if (codeClass == null)
{
return;
}
CodeAttribute attribute;
InterfaceType interfaceType = null;
if (owner != null)
{
TypescriptType tsType = typeContext.GetTypeScriptType(owner.FullName);
if (tsType != null)
{
interfaceType = new InterfaceType(codeClass.Name);
}
}
if (forcedProcessing)
{
var values = new TypeScriptInterfaceAttributeValues
{
Name = codeClass.Name,
Module = Settings.DefaultModule ?? "T4TS",
NamePrefix = Settings.DefaultInterfaceNamePrefix ?? string.Empty
};
interfaceType = new InterfaceType(values);
}
if (TryGetAttribute(codeClass.Attributes, InterfaceAttributeFullName, out attribute))
{
TypeScriptInterfaceAttributeValues values = GetInterfaceValues(codeClass, attribute);
interfaceType = new InterfaceType(values);
}
else if (Settings.ProcessDataContracts && TryGetAttribute(codeClass.Attributes, "System.Runtime.Serialization.DataContractAttribute", out attribute))
{
var values = new TypeScriptInterfaceAttributeValues
{
Name = codeClass.Name,
Module = Settings.DefaultModule ?? "T4TS",
NamePrefix = Settings.DefaultInterfaceNamePrefix ?? string.Empty
};
interfaceType = new InterfaceType(values);
}
if (interfaceType != null)
{
// Process parent classes anyway if it has not TypeScriptAttribute or DataContractAttribute
if (Settings.ProcessParentClasses)
{
CodeClass parentClass = null;
if (codeClass.Bases.Count > 0)
{
parentClass = codeClass.Bases.Item(1) as CodeClass;
}
if (parentClass != null && parentClass.FullName != "System.Object")
{
BuildCodeClass(typeContext, parentClass, null, true);
}
}
if (!typeContext.ContainsInterfaceType(codeClass.FullName))
{
typeContext.AddInterfaceType(codeClass.FullName, interfaceType);
}
foreach (var subCodeElement in codeClass.Members)
{
var subCodeClass = subCodeElement as CodeClass;
if (subCodeClass != null && subCodeClass.Access == vsCMAccess.vsCMAccessPublic)
{
BuildCodeClass(typeContext, subCodeClass, codeClass);
}
var subCodeEnum = subCodeElement as CodeEnum;
if (subCodeEnum != null && subCodeEnum.Access == vsCMAccess.vsCMAccessPublic)
{
BuildCodeEnum(typeContext, subCodeEnum, codeClass);
}
}
}
}
private TypeScriptInterface BuildInterface(CodeClass codeClass,
TypeScriptInterfaceAttributeValues attributeValues, TypeContext typeContext)
{
var tsInterface = new TypeScriptInterface
{
FullName = codeClass.FullName,
Name = GetInterfaceName(attributeValues)
};
// Add sub-classes to the interface
foreach (var codeSubClass in codeClass.Members.OfType <CodeClass>().Where(cc => cc.Access == vsCMAccess.vsCMAccessPublic))
{
var subAttributeValues = new TypeScriptInterfaceAttributeValues {
Name = codeSubClass.Name
};
InterfaceType interfaceType;
if (typeContext.TryGetInterfaceType(codeSubClass.FullName, out interfaceType))
{
subAttributeValues = interfaceType.AttributeValues;
subAttributeValues.Module = attributeValues.Module + "." + tsInterface.Name;
}
TypeScriptInterface subInterface = BuildInterface(codeSubClass, subAttributeValues, typeContext);
subInterface.Owner = tsInterface;
tsInterface.SubClasses.Add(subInterface);
}
// Add sub-enums to the interface
foreach (CodeEnum codeSubEnum in codeClass.Members.OfType <CodeEnum>().Where(cc => cc.Access == vsCMAccess.vsCMAccessPublic))
{
var subAttributeValues = new TypeScriptEnumAttributeValues {
Name = codeSubEnum.Name
};
EnumType enumType;
if (typeContext.TryGetEnumType(codeSubEnum.FullName, out enumType))
{
subAttributeValues = enumType.AttributeValues;
subAttributeValues.Module = attributeValues.Module + "." + tsInterface.Name;
}
TypeScriptEnum subEnum = BuildEnum(codeSubEnum, subAttributeValues, typeContext);
subEnum.Owner = tsInterface;
tsInterface.SubEnums.Add(subEnum);
}
TypescriptType indexedType;
if (TryGetIndexedType(codeClass, typeContext, out indexedType))
{
tsInterface.IndexedType = indexedType;
}
new ClassTraverser(codeClass, property =>
{
TypeScriptInterfaceMember member;
if (TryGetMember(property, typeContext, out member))
{
tsInterface.Members.Add(member);
}
});
return(tsInterface);
}
public InterfaceType(TypeScriptInterfaceAttributeValues values)
{
AttributeValues = values;
}
private TypeScriptInterface BuildInterface(CodeClass codeClass, TypeScriptInterfaceAttributeValues attributeValues, TypeContext typeContext)
{
var tsInterface = new TypeScriptInterface
{
FullName = codeClass.FullName,
Name = GetInterfaceName(attributeValues),
Comment = codeClass.Comment,
DocComment = codeClass.DocComment
};
// Add sub-classes to the interface
foreach (var codeSubClass in codeClass.Members.OfType<CodeClass>().Where(cc => cc.Access == vsCMAccess.vsCMAccessPublic))
{
var subAttributeValues = new TypeScriptInterfaceAttributeValues { Name = codeSubClass.Name };
InterfaceType interfaceType;
if (typeContext.TryGetInterfaceType(codeSubClass.FullName, out interfaceType))
{
subAttributeValues = interfaceType.AttributeValues;
subAttributeValues.Module = attributeValues.Module + "." + tsInterface.Name;
}
var subInterface = BuildInterface(codeSubClass, subAttributeValues, typeContext);
subInterface.Owner = tsInterface;
tsInterface.SubClasses.Add(subInterface);
}
// Add sub-enums to the interface
foreach (CodeEnum codeSubEnum in codeClass.Members.OfType<CodeEnum>().Where(cc => cc.Access == vsCMAccess.vsCMAccessPublic))
{
var subAttributeValues = new TypeScriptEnumAttributeValues { Name = codeSubEnum.Name };
EnumType enumType;
if (typeContext.TryGetEnumType(codeSubEnum.FullName, out enumType))
{
subAttributeValues = enumType.AttributeValues;
subAttributeValues.Module = attributeValues.Module + "." + tsInterface.Name;
}
var subEnum = BuildEnum(codeSubEnum, subAttributeValues, typeContext);
subEnum.Owner = tsInterface;
tsInterface.SubEnums.Add(subEnum);
}
TypescriptType indexedType;
if (TryGetIndexedType(codeClass, typeContext, out indexedType))
tsInterface.IndexedType = indexedType;
new ClassTraverser(codeClass, property =>
{
TypeScriptInterfaceMember member;
if (TryGetMember(property, typeContext, out member))
tsInterface.Members.Add(member);
});
return tsInterface;
}
private void BuildCodeClass(TypeContext typeContext, CodeClass codeClass, CodeClass owner = null, bool forcedProcessing = false)
{
if (codeClass == null) return;
CodeAttribute attribute;
InterfaceType interfaceType = null;
if (owner != null)
{
var tsType = typeContext.GetTypeScriptType(owner.FullName);
if (tsType != null)
interfaceType = new InterfaceType(codeClass.Name);
}
if (forcedProcessing)
{
var values = new TypeScriptInterfaceAttributeValues
{
Name = codeClass.Name,
Module = Settings.DefaultModule ?? "T4TS",
NamePrefix = Settings.DefaultInterfaceNamePrefix ?? string.Empty
};
interfaceType = new InterfaceType(values);
}
if (TryGetAttribute(codeClass.Attributes, InterfaceAttributeFullName, out attribute))
{
var values = GetInterfaceValues(codeClass, attribute);
interfaceType = new InterfaceType(values);
}
else if (Settings.ProcessDataContracts && TryGetAttribute(codeClass.Attributes, "System.Runtime.Serialization.DataContractAttribute", out attribute))
{
var values = new TypeScriptInterfaceAttributeValues
{
Name = codeClass.Name,
Module = Settings.DefaultModule ?? "T4TS",
NamePrefix = Settings.DefaultInterfaceNamePrefix ?? string.Empty
};
interfaceType = new InterfaceType(values);
}
if (interfaceType != null)
{
// Process parent classes anyway if it has not TypeScriptAttribute or DataContractAttribute
if (Settings.ProcessParentClasses)
{
CodeClass parentClass = null;
if (codeClass.Bases.Count > 0)
parentClass = codeClass.Bases.Item(1) as CodeClass;
if (parentClass != null && parentClass.FullName != "System.Object")
{
BuildCodeClass(typeContext, parentClass, null, true);
}
}
if (!typeContext.ContainsInterfaceType(codeClass.FullName))
typeContext.AddInterfaceType(codeClass.FullName, interfaceType);
foreach (var subCodeElement in codeClass.Members)
{
var subCodeClass = subCodeElement as CodeClass;
if (subCodeClass != null && subCodeClass.Access == vsCMAccess.vsCMAccessPublic)
BuildCodeClass(typeContext, subCodeClass, codeClass);
var subCodeEnum = subCodeElement as CodeEnum;
if (subCodeEnum != null && subCodeEnum.Access == vsCMAccess.vsCMAccessPublic)
BuildCodeEnum(typeContext, subCodeEnum, codeClass);
}
}
}
public InterfaceType(TypeScriptInterfaceAttributeValues values)
{
AttributeValues = values;
}
