protected virtual void GenerateProperties(Type type, DeclarationBase result, bool skipImplementedByInterfaces)
{
//properties
if (GenerationStrategy.ShouldGenerateProperties(result, type))
{
var allProps = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static);
foreach (var pi in allProps)
{
if (!GenerationStrategy.ShouldGenerateProperty(result, pi))
{
result.Members.Add(new RawDeclarationMember(new RawStatements(string.Format("/* GenerationStrategy skipped property {0} */", pi.Name))));
continue;
}
if (skipImplementedByInterfaces)
{
var intf = IsPropertyImplementedByAnyInterface(pi, type);
if (intf != null)
{
result.Members.Add(new RawDeclarationMember(new RawStatements(string.Format("/* Property {0} skipped, because it is already implemented by interface {1}*/", pi.Name, intf.Name))));
continue;
}
}
var p = GenerateProperty(pi);
result.Members.Add(p);
}
}
}
public virtual void VisitMembers(DeclarationBase decl)
{
foreach (var m in decl.Members.ToArray())
{
Visit(m);
}
}
private void GenerateDeclarationBase(DeclarationBase result, Type type)
{
result.ExtraData[SOURCETYPE_KEY] = type;
_typeMap[type] = result;
GenerationStrategy.AddDeclaration(result);
//generics
if (type.IsGenericType)
{
var suffix = new List <string>();
foreach (var garg in type.GetGenericArguments())
{
if (garg.IsGenericParameter)
{
result.GenericParameters.Add(new GenericParameter(NamingStrategy.GetGenericArgumentName(garg))
{
ExtraData = { { SOURCETYPE_KEY, garg } }
});
}
else
{
suffix.Add(NamingStrategy.GetGenericArgumentName(garg));
}
}
if (suffix.Count > 0)
{
result.Name += "_" + String.Join("_", suffix);
}
}
}
public virtual void AddDeclaration(DeclarationBase decl)
{
var m = new DeclarationModuleElement(decl);
//m.Comment = "generated from " + decl.ExtraData[ReflectionGeneratorBase.SOURCETYPE_KEY];
TargetModule.Members.Add(m);
}
private DeclarationBase MapDeclaration(DeclarationBase declarationBase, bool createMap = true)
{
MapItem mapItem;
if (!_map.TryGetValue(declarationBase, out mapItem) && !createMap)
{
return(declarationBase);
}
if (mapItem == null)
{
mapItem = new MapItem();
_map[declarationBase] = mapItem;
}
if (_interfaceMapping.Peek())
{
if (mapItem.Interface == null)
{
mapItem.Interface = new InterfaceType(Options.GetInterfaceName(declarationBase));
_target.Members.Add(mapItem.Interface);
GenerateObservableInterface(declarationBase, mapItem.Interface);
}
return(mapItem.Interface);
}
else
{
if (mapItem.Class == null)
{
mapItem.Class = new ClassType(Options.GetClassName(declarationBase));
_target.Members.Add(mapItem.Class);
GenerateObservableClass(declarationBase, mapItem.Class);
}
return(mapItem.Class);
}
}
public virtual bool ShouldGenerateBaseClass(DeclarationBase decl, Type type, Type baseType)
{
if (IsSystemType(baseType))
{
return(false);
}
return(true);
}
public virtual bool ShouldGenerateProperty(DeclarationBase decl, PropertyInfo propertyInfo)
{
if (propertyInfo.GetGetMethod().IsStatic)
{
return(false);
}
return(true);
}
private bool IsEmptyDeclaration(DeclarationBase e)
{
if (Exceptions.Contains(e))
{
return(false);
}
return(e.Members.Count == 0 && e.GetExtends().Count() <= 1);
}
private void AddFromJsFunction(DeclarationBase src, ClassType target)
{
var fromJS = new RawStatements();
if (target.Extends != null)
{
fromJS.Add("super.fromJS(obj);\n");
}
foreach (var targetItem in target.Members.OfType <PropertyMember>())
{
var srcItem = src.Members.OfType <PropertyMember>().First(x => x.Name == targetItem.Name);
TypescriptTypeBase itemType = null;
if (srcItem.MemberType != null && srcItem.MemberType.ReferencedType != null)
{
itemType = srcItem.MemberType.ReferencedType;
}
if (Options.JsConversion_Function_PropertyExistenceCheck)
{
fromJS.Add("if (obj." + srcItem.Name + ") { ");
}
if (itemType is ArrayType)
{
var elementType = srcItem.MemberType.ExtractArrayElement();
if (elementType != null && elementType.ReferencedType != null && elementType.ReferencedType is DeclarationBase)
{
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ".map(item=>new ", elementType, "().fromJS(item)))");
}
else
{
//todo:conversions
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ")");
}
}
else
{
if (itemType == PrimitiveType.Date)
{
fromJS.Add("this." + srcItem.Name + "(new Date(obj." + srcItem.Name + "))");
}
else
{
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ")");
}
}
if (Options.JsConversion_Function_PropertyExistenceCheck)
{
fromJS.Add("};");
}
fromJS.Add("\n");
}
fromJS.Add("return this;");
target.Members.Add(new FunctionMember("fromJS", fromJS)
{
Parameters = { new FunctionParameter("obj") }
});
}
public virtual void VisitGenericParameters(DeclarationBase decl)
{
if (decl.IsGeneric)
{
foreach (var item in decl.GenericParameters.ToArray())
{
VisitGenericParameter(item);
}
}
}
public virtual string GetClassName(DeclarationBase source)
{
var name = source.Name;
if (source is InterfaceType)
{
name = NamingHelper.RemovePrefix("I", name, LetterCasing.Upper);
}
name = NamingHelper.FirstLetter(LetterCasing.Lower, name);
return(name);
}
public virtual bool ShouldGenerateProperty(DeclarationBase decl, PropertyInfo propertyInfo)
{
if (propertyInfo.GetGetMethod().IsStatic)
{
return(false);
}
if (propertyInfo.GetCustomAttributes().Count(at => at.GetType().IsTypeBaseOrSelf("Newtonsoft.Json.JsonIgnoreAttribute")) > 0)
{
return(false);
}
return(true);
}
private PropertyMember GenerateObservableProperty(DeclarationBase target, PropertyMember source)
{
var property = new PropertyMember(source.Name);
property.Accessibility = source.Accessibility;
property.Initialization = MapRaw(source.Initialization);
//property.IsOptional = item.IsOptional;
property.MemberType = MapType(source.MemberType);
MakeObservableProperty(property);
target.Members.Add(property);
return(property);
}
private void GenerateObservableClass(DeclarationBase source, ClassType target)
{
if (source is ClassType)
{
GenerateObservableClassFromClass((ClassType)source, target);
}
else if (source is InterfaceType)
{
GenerateObservableClassFromInterface((InterfaceType)source, target);
}
else
{
throw new NotImplementedException("Generating observable class from " + source);
}
}
private void GenerateObservableBase(DeclarationBase src, DeclarationBase target)
{
foreach (var item in src.GenericParameters)
{
target.GenericParameters.Add(new GenericParameter(item.Name)
{
Constraint = MapType(item.Constraint)
});
}
foreach (var srcItem in src.Members.OfType <PropertyMember>())
{
GenerateObservableProperty(target, srcItem);
}
}
public virtual void Visit(DeclarationBase decl)
{
if (decl is ClassType)
{
VisitClassType((ClassType)decl);
}
else if (decl is InterfaceType)
{
VisitInterfaceType((InterfaceType)decl);
}
else
{
NonVisitable(decl, "declaration {0}");
}
}
public virtual DeclarationBase RewriteDeclaration(DeclarationBase decl)
{
if (decl is ClassType)
{
return(RewriteClassType((ClassType)decl));
}
else if (decl is InterfaceType)
{
return(RewriteInterfaceType((InterfaceType)decl));
}
else
{
throw NonVisitable(decl, "declaration {0}");
}
}
private void GenerateObservableInterface(DeclarationBase source, InterfaceType target)
{
foreach (var extends in source.GetExtends().OrderBy(x => x.ToString()))
{
target.ExtendsTypes.Add(MapType(extends));
}
if (source is ClassType)
{
foreach (var implements in ((ClassType)source).Implementations.OrderBy(x => x.ToString()))
{
target.ExtendsTypes.Add(MapType(implements));
}
}
GenerateObservableBase(source, target);
}
protected virtual void GenerateMethodDeclarations(Type type, DeclarationBase declaration)
{
//method declarations
if (GenerationStrategy.ShouldGenerateMethods(declaration, type))
{
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static);
foreach (var method in methods)
{
if (!GenerationStrategy.ShouldGenerateMethod(declaration, method))
{
continue;
}
declaration.Members.Add(GenerateMethodDeclaration(method));
}
}
}
public override DeclarationBase RewriteObjectReference(DeclarationBase type)
{
DeclarationBase result;
if (_map.TryGetValue(type, out result))
{
return(result); // some recursion needed?
}
result = base.RewriteObjectReference(type);
if (IsEmptyDeclaration(result))
{
var newType = result.GetExtends().Select(x => x.ReferencedType).OfType <DeclarationBase>().FirstOrDefault();
_map[result] = newType;
return(newType);
}
return(result);
}
public virtual string GetInterfaceName(DeclarationBase source)
{
var name = source.Name;
if (source is InterfaceType)
{
if (name.StartsWith("I") && name.Substring(1, 1) == name.Substring(1, 1).ToUpper())
{
//interface name like "IMyInterface" -> "IObservableMyInterface"
name = "IObservable" + name.Substring(1);
}
else if (name.StartsWith("i"))
{
//class as interface "iMyclass" -> "iObservableMyClass"
name = "iObservable" + NamingHelper.FirstLetter(LetterCasing.Upper, name.Substring(1));
}
}
else
{
name = "iObservable" + NamingHelper.FirstLetter(LetterCasing.Upper, name);
}
return(name);
}
public virtual void VisitReference(DeclarationBase type)
{
}
public virtual DeclarationBase RewriteObjectReference(DeclarationBase type)
{
//this should be overriden, if user rewrites classes or interfaces
return(type);
}
public virtual bool ShouldGenerateProperties(DeclarationBase decl, Type type)
{
return(true);
}
public bool ShouldGenerateImplementedInterface(DeclarationBase decl, Type interfaceType)
{
return(!IsSystemType(interfaceType));
}
public virtual bool ShouldGenerateImplementedInterfaces(DeclarationBase decl, Type type)
{
return(!IsSystemType(type));
}
public virtual bool ShouldGenerateMethod(DeclarationBase decl, MethodInfo method)
{
return(false);
}
public virtual bool ShouldGenerateMethods(DeclarationBase decl, Type type)
{
return(false);
}
