public TypescriptTypeCreator(ITypescriptTypeCreator classCreator, ITypescriptTypeCreator interfaceCreator, ITypescriptTypeCreator enumCreator)
{
this.classCreator = classCreator;
this.interfaceCreator = interfaceCreator;
this.enumCreator = enumCreator;
this.SetTypeCreatorRoot(this);
}
public static TypescriptGenericTypeArguments GetGenericTypeArgumentsFor(ITypescriptTypeCreator typeCreator, Type baseType, TypescriptModel model)
{
var result = new TypescriptGenericTypeArguments();
foreach (var genericTypeArgument in baseType.GetGenericArguments())
{
var tsType = typeCreator.GetTypeFor(genericTypeArgument, model);
tsType.Match(
primitive => result.Add(primitive),
tsClass => result.Add(tsClass),
tsInterface => result.Add(tsInterface),
tsEnumerable => { throw new Exception("enum cannot be a generic type parameter"); },
genericTypeParameter => result.Add(genericTypeParameter));
}
return(result);
}
public static TypescriptType ClassTypeToTypescriptClass(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
// TODO Check if type is indeed a class..
if (model.knownTypes.ContainsKey(type))
{
return(model.knownTypes[type]);
}
else
{
var newClass = new TypescriptClass
{
Name = type.NameWithoutGeneric()
};
model.knownTypes.Add(type, newClass.ToTypescriptType());
newClass.BaseClass = type.BaseType.ToTypescriptBaseClass(model);
newClass.Content = type.GetTypescriptProperties(typeCreator, model).ToClassContent();
newClass.GenricTypeParameters = TypescriptTypeCreatorBase.GetGenericTypeParametersFor(type);
return(newClass.ToTypescriptType());
}
}
public static TypescriptType ClassTypeToTypescriptInterface(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
// TODO validate parameters. the input hsould be a class type...
if (model.knownTypes.ContainsKey(type))
{
return(model.knownTypes[type]);
}
else
{
var newInterface = new TypescriptInterface
{
Name = type.NameWithoutGeneric()
};
model.knownTypes.Add(type, newInterface.ToTypescriptType());
// TODO: implement inherrited interfaces. newInterface. = GetBaseClassFor(type.BaseType, model);
newInterface.BaseType = type.ClassBaseClassAndInterfacesAsBaseInterfaces(typeCreator, model);
newInterface.Content = type.GetInterfaceContent(typeCreator, model);
newInterface.GenricTypeParameters = TypescriptTypeCreatorBase.GetGenericTypeParametersFor(type);
return(newInterface.ToTypescriptType());
}
}
public void SetTypeCreatorRoot(ITypescriptTypeCreator typescriptTypeCreatorRoot)
{
this.classCreator.SetTypeCreatorRoot(typescriptTypeCreatorRoot);
this.interfaceCreator.SetTypeCreatorRoot(typescriptTypeCreatorRoot);
this.enumCreator.SetTypeCreatorRoot(typescriptTypeCreatorRoot);
}
public void SetTypeCreatorRoot(ITypescriptTypeCreator typescriptTypeCreatorRoot)
{
this.typeCreator = typescriptTypeCreatorRoot;
}
public void Initialize(ITypescriptTypeCreator typeCreator)
{
this.typeCreator = typeCreator;
}
public static IEnumerable <TypescriptProperty> GetTypescriptProperties(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
return(type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public).Select(property => new TypescriptProperty
{
Name = property.Name,
Accesability = TypescriptAccesModifier.@public,
DefaultValue = new None <String>(),
Type = typeCreator.GetTypeFor(property.PropertyType, model)
}));
}
public void SetTypeCreatorRoot(ITypescriptTypeCreator typescriptTypeCreatorRoot)
{
throw new NotImplementedException();
}
public static TypescriptInterfaceContentList GetInterfaceContent(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
return(new TypescriptInterfaceContentList(type.GetTypescriptProperties(typeCreator, model).Select(x => x.ToTypescriptInterfaceContent())));
}
private static IOption <TypescriptInterfaceBaseType> ClassBaseClassToTypescriptInterfaceBase(this Type baseType, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
return(baseType.Match()
.With <IOption <TypescriptInterfaceBaseType> >(typeof(Object), new None <TypescriptInterfaceBaseType>())
.Else(NewTypescriptInterfaceBase));
}
private static TypescriptInterfaceBaseTypes ClassBaseClassAndInterfacesAsBaseInterfaces(this Type classType, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
var interfaceBaseInterfaces = classType.TypescriptImplementedInterfaces();
var classBaseClassAsInterface = classType.BaseType.ClassBaseClassToTypescriptInterfaceBase(typeCreator, model);
classBaseClassAsInterface.IfNotNullDo(x => interfaceBaseInterfaces.Add(x));
return(interfaceBaseInterfaces);
}
public static TypescriptType InterfaceTypeToTypescriptInterface(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model)
{
// TODO Check and refactor this and method below.
if (model.knownTypes.ContainsKey(type))
{
return(model.knownTypes[type]);
}
else
{
var newInterface = new TypescriptInterface
{
Name = type.NameWithoutGeneric()
};
model.knownTypes.Add(type, newInterface.ToTypescriptType());
// TODO: implement inherrited interfaces. newInterface. = GetBaseClassFor(type.BaseType, model);
newInterface.BaseType = type.TypescriptImplementedInterfaces();
newInterface.Content = type.GetInterfaceContent(typeCreator, model);
newInterface.GenricTypeParameters = TypescriptTypeCreatorBase.GetGenericTypeParametersFor(type);
return(newInterface.ToTypescriptType());
}
}
