//cannot create a new ITypeMember and add the Type to it
public void GenerateMembers <T>(TypeResolver resolver, ITypeMember typeMember, IEnumerable <T> members, GeneratorManager Generators) where T : MemberInfo
{
foreach (var m in members)
{
var generator = Generators.GeneratorFor(m);
var member = generator.Generate(m, resolver);
if (member != null)
{
RtNode wrapperNode = null;
switch (m.MemberType)
{
case MemberTypes.Field:
wrapperNode = new ReflectionAttachedRtField(member as RtField, m as FieldInfo);
break;
case MemberTypes.Property:
wrapperNode = new ReflectionAttachedRtField(member as RtField, m as PropertyInfo);
break;
case MemberTypes.Method:
wrapperNode = new ReflectionAttachedRtFunction(member as RtFunction, m as MethodInfo);
break;
case MemberTypes.Constructor:
wrapperNode = new ReflectionAttachedRtConstructor(member as RtConstructor, m as ConstructorInfo);
break;
}
typeMember.Members.Add(wrapperNode);
}
}
}
/// <summary>
/// Sets current location
/// </summary>
/// <param name="location"></param>
public void SetLocation(RtNode location)
{
if (location is RtClass) CurrentClass = (RtClass) location;
if (location is RtInterface) CurrentInterface = (RtInterface)location;
if (location is RtEnum) CurrentEnum = (RtEnum)location;
if (location is RtModule) CurrentModule = (RtModule)location;
}
protected void AddMember(RtNode member)
{
if (member != null)
{
typeMember.Members.Add(member);
}
}
/// <summary>
/// Sets current location
/// </summary>
/// <param name="location"></param>
public void ResetLocation(RtNode location)
{
if (location is RtClass) CurrentClass = null;
if (location is RtInterface) CurrentInterface = null;
if (location is RtEnum) CurrentEnum = null;
if (location is RtModule) CurrentModule = null;
}
public RtNode GeneratedConstructor(RtNode node, ConstructorInfo constructorInfo)
{
if (node is RtConstructor)
{
return(new ReflectionAttachedRtConstructor(node as RtConstructor, constructorInfo));
}
return(node);
}
public ReverseTrie()
{
_store = new List <RtNode>();
_fwdCache = new Map <int, Map <char, int> >(() => new Map <char, int>());
_valueCache = new Dictionary <TValue, HashSet <int> >();
RtNode.AddNewNode(RootValue, RootParent, _store);
}
public RtNode GeneratedMethod(RtNode node, MethodInfo methodInfo)
{
if (node is RtFunction)
{
return(new ReflectionAttachedRtFunction(node as RtFunction, methodInfo));
}
return(node);
}
public RtNode GeneratedProperty(RtNode node, PropertyInfo propertyInfo)
{
if (node is RtField)
{
return(new ReflectionAttachedRtField(node as RtField, propertyInfo));
}
return(node);
}
public RtNode GeneratedField(RtNode node, FieldInfo fieldInfo)
{
if (node is RtField)
{
return(new ReflectionAttachedRtField(node as RtField, fieldInfo));
}
return(node);
}
private bool IsKnownMember(RtNode n)
{
if (n is RtConstructor)
{
return(true);
}
if (n is RtField)
{
return(true);
}
if (n is RtFunction)
{
return(true);
}
return(false);
}
/// <summary>
/// Sets current location
/// </summary>
/// <param name="location"></param>
public void ResetLocation(RtNode location)
{
if (location is RtClass)
{
CurrentClass = null;
}
if (location is RtInterface)
{
CurrentInterface = null;
}
if (location is RtEnum)
{
CurrentEnum = null;
}
if (location is RtNamespace)
{
CurrentNamespace = null;
}
}
/// <summary>
/// Sets current location
/// </summary>
/// <param name="location"></param>
public void SetLocation(RtNode location)
{
if (location is RtClass)
{
CurrentClass = (RtClass)location;
}
if (location is RtInterface)
{
CurrentInterface = (RtInterface)location;
}
if (location is RtEnum)
{
CurrentEnum = (RtEnum)location;
}
if (location is RtNamespace)
{
CurrentNamespace = (RtNamespace)location;
}
}
public void Visit(RtNode node)
{
if (node == null)
{
return;
}
if (node is RtField)
{
Visit((RtField)node); return;
}
if (node is RtInterface)
{
Visit((RtInterface)node); return;
}
if (node is RtFuncion)
{
Visit((RtFuncion)node); return;
}
if (node is RtArgument)
{
Visit((RtArgument)node); return;
}
if (node is RtClass)
{
Visit((RtClass)node); return;
}
if (node is RtIdentifier)
{
Visit((RtIdentifier)node); return;
}
if (node is RtDelegateType)
{
Visit((RtDelegateType)node); return;
}
if (node is RtSimpleTypeName)
{
Visit((RtSimpleTypeName)node); return;
}
if (node is RtRaw)
{
Visit((RtRaw)node); return;
}
if (node is RtJsdocNode)
{
Visit((RtJsdocNode)node); return;
}
if (node is RtNamespace)
{
Visit((RtNamespace)node); return;
}
if (node is RtEnumValue)
{
Visit((RtEnumValue)node); return;
}
if (node is RtEnum)
{
Visit((RtEnum)node); return;
}
if (node is RtDictionaryType)
{
Visit((RtDictionaryType)node); return;
}
if (node is RtArrayType)
{
Visit((RtArrayType)node); return;
}
if (node is RtConstructor)
{
Visit((RtConstructor)node); return;
}
if (node is RtImport)
{
Visit((RtImport)node); return;
}
if (node is RtDecorator)
{
Visit((RtDecorator)node); return;
}
if (node is RtReference)
{
Visit((RtReference)node); return;
}
if (node is RtTuple)
{
Visit((RtTuple)node); return;
}
throw new Exception("Unknown node passed");
}
public RtNode GeneratedMethod(RtNode node, MethodInfo methodInfo)
{
return(node);
}
private void GeneratedConstructor(RtNode node, ConstructorInfo constructorInfo)
{
AddMember(generatedMemberHandler.GeneratedConstructor(node, constructorInfo));
}
private void GeneratedProperty(RtNode node, PropertyInfo propertyInfo)
{
AddMember(generatedMemberHandler.GeneratedProperty(node, propertyInfo));
}
private void GeneratedMethod(RtNode node, MethodInfo method)
{
AddMember(generatedMemberHandler.GeneratedMethod(node, method));
}
private void GeneratedField(RtNode node, FieldInfo field)
{
AddMember(generatedMemberHandler.GeneratedField(node, field));
}
public RtNode GeneratedProperty(RtNode node, PropertyInfo propertyInfo)
{
return(node);
}
public RtNode GeneratedConstructor(RtNode node, ConstructorInfo constructorInfo)
{
return(node);
}
public T Visit(RtNode node)
{
if (node is RtField)
{
return(Visit((RtField)node));
}
if (node is RtInterface)
{
return(Visit((RtInterface)node));
}
if (node is RtFuncion)
{
return(Visit((RtFuncion)node));
}
if (node is RtArgument)
{
return(Visit((RtArgument)node));
}
if (node is RtClass)
{
return(Visit((RtClass)node));
}
if (node is RtIdentifier)
{
return(Visit((RtIdentifier)node));
}
if (node is RtDelegateType)
{
return(Visit((RtDelegateType)node));
}
if (node is RtSimpleTypeName)
{
return(Visit((RtSimpleTypeName)node));
}
if (node is RtRaw)
{
return(Visit((RtRaw)node));
}
if (node is RtJsdocNode)
{
return(Visit((RtJsdocNode)node));
}
if (node is RtModule)
{
return(Visit((RtModule)node));
}
if (node is RtEnumValue)
{
return(Visit((RtEnumValue)node));
}
if (node is RtEnum)
{
return(Visit((RtEnum)node));
}
if (node is RtDictionaryType)
{
return(Visit((RtDictionaryType)node));
}
if (node is RtArrayType)
{
return(Visit((RtArrayType)node));
}
if (node is RtConstructor)
{
return(Visit((RtConstructor)node));
}
throw new Exception("Unknown node passed");
}
public RtNode GeneratedField(RtNode node, FieldInfo fieldInfo)
{
return(node);
}
