public TypeScriptEnum GetOrCreateEnum(
string moduleName,
TypeName sourceType,
string outputName,
out bool created)
{
TypeScriptEnum result;
if (!this.sourceToEnumMap.TryGetValue(
sourceType.UniversalName,
out result))
{
result = new TypeScriptEnum(
sourceType,
this.GetTypeArgumentReferences(
sourceType.TypeArguments,
contextTypeReference: null),
contextTypeReference: null);
this.sourceToEnumMap.Add(
sourceType.UniversalName,
result);
this.sourceNamesToOutputTypeMap.Add(
sourceType.UniversalName,
this.GenerateOutputName(
moduleName,
outputName,
(sourceType.TypeArguments != null)
? sourceType.TypeArguments.Count
: 0));
created = true;
}
else
{
created = false;
}
bool moduleCreated;
TypeScriptModule module = this.GetOrCreateModule(
moduleName,
out moduleCreated);
module.Enums.Add(result);
return(result);
}
private TypeScriptEnum BuildEnum(CodeEnum codeEnum, TypeScriptEnumAttributeValues attributeValues,
TypeContext typeContext)
{
var tsEnum = new TypeScriptEnum
{
FullName = codeEnum.FullName,
Name = GetEnumName(attributeValues)
};
new EnumTraverser(codeEnum, (variable, index) =>
{
TypeScriptEnumMember member;
if (TryGetEnumMember(variable, typeContext, index, out member))
{
tsEnum.Members.Add(member);
}
});
return(tsEnum);
}
private void ProcessCodeEnum(TypeContext typeContext, IDictionary <CodeEnum, TypeScriptEnum> tsEnumMap,
IDictionary <string, TypeScriptModule> byModuleName, CodeEnum codeEnum)
{
EnumType enumType;
if (typeContext.TryGetEnumType(codeEnum.FullName, out enumType))
{
TypeScriptEnumAttributeValues values = enumType.AttributeValues;
TypeScriptModule module;
if (!byModuleName.TryGetValue(values.Module, out module))
{
module = new TypeScriptModule {
QualifiedName = values.Module
};
byModuleName.Add(values.Module, module);
}
TypeScriptEnum tsEnum = BuildEnum(codeEnum, values, typeContext);
tsEnumMap.Add(codeEnum, tsEnum);
tsEnum.Module = module;
module.Enums.Add(tsEnum);
}
}
private void AppendOutputSubEnum(TypeScriptEnum tsEnum, TypeScriptInterface owner)
{
var enumAppender = new EnumOutputAppender(Output, BaseIndentation, Settings);
enumAppender.AppendOutputSubEnum(tsEnum, owner);
}
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);
}
private TypeScriptEnum BuildEnum(CodeEnum codeEnum, TypeScriptEnumAttributeValues attributeValues, TypeContext typeContext)
{
var tsEnum = new TypeScriptEnum
{
FullName = codeEnum.FullName,
Name = GetEnumName(attributeValues),
Comment = codeEnum.Comment,
DocComment = codeEnum.DocComment
};
new EnumTraverser(codeEnum, (variable, index) =>
{
TypeScriptEnumMember member;
if (TryGetEnumMember(variable, typeContext, index, out member))
tsEnum.Members.Add(member);
});
return tsEnum;
}
