EntityIndexData createCustomEntityIndexData(Type type)
{
var data = new EntityIndexData();
var attribute = (CustomEntityIndexAttribute)type.GetCustomAttributes(typeof(CustomEntityIndexAttribute), false)[0];
data.SetEntityIndexType(type.ToCompilableString());
data.IsCustom(true);
data.SetEntityIndexName(type.ToCompilableString().RemoveDots());
data.SetHasMultiple(false);
data.SetContextNames(new[] { attribute.contextType.ToCompilableString().ShortTypeName().RemoveContextSuffix() });
var getMethods = type
.GetMethods(BindingFlags.Public | BindingFlags.Instance)
.Where(method => Attribute.IsDefined(method, typeof(EntityIndexGetMethodAttribute)))
.Select(method => new MethodData(
method.ReturnType.ToCompilableString(),
method.Name,
method.GetParameters()
.Select(p => new MemberData(p.ParameterType.ToCompilableString(), p.Name))
.ToArray()
)).ToArray();
data.SetCustomMethods(getMethods);
return(data);
}
string generateCustomMethods(EntityIndexData data)
{
return(ADD_CUSTOMINDEX_TEMPLATE
.Replace("${context}", data.GetContextNames()[0].LowercaseFirst())
.Replace("${Name}", data.GetEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType()));
}
private EntityIndexData createCustomEntityIndexData(INamedTypeSymbol type)
{
var data = new EntityIndexData();
var attribute = type.GetAttributes( ).First(attr => attr.AttributeClass.ToString( ) == typeof(CustomEntityIndexAttribute).FullName);
var attrArg0 = attribute.ConstructorArguments[0].Value as INamedTypeSymbol; // FIXME: get string contextName
data.SetEntityIndexType(type.ToString( ));
data.IsCustom(true);
data.SetEntityIndexName(type.ToString( ).RemoveDots( ));
data.SetHasMultiple(false);
data.SetContextNames(new[] { attrArg0.Name.ShortTypeName( ).RemoveContextSuffix( ) });
var getMethods = type
.GetMembers( )
.Where(m => m.Kind == SymbolKind.Method &&
m is IMethodSymbol &&
m.DeclaredAccessibility == Accessibility.Public &&
m.HasAttribute(typeof(EntityIndexGetMethodAttribute)))
.Select(m => new MethodData(
(m as IMethodSymbol).ReturnType.ToDisplayString( ),
(m as IMethodSymbol).Name,
(m as IMethodSymbol).Parameters
.Select(p => new MemberData(p.Type.ToString( ), p.Name))
.ToArray( )))
.ToArray();
data.SetCustomMethods(getMethods);
return(data);
}
private string GenerateGetMethod(EntityIndexData data, string contextName)
{
var template = "";
if (data.GetEntityIndexType() == "JCMG.EntitasRedux.EntityIndex")
{
template = GET_INDEX_TEMPLATE;
}
else if (data.GetEntityIndexType() == "JCMG.EntitasRedux.PrimaryEntityIndex")
{
template = GET_PRIMARY_INDEX_TEMPLATE;
}
else
{
return(GetCustomMethods(data));
}
return(template
.Replace("${ContextName}", contextName)
.Replace(
"${IndexName}", data.GetMemberEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${KeyType}", data.GetKeyType())
.Replace("${MemberName}", data.GetMemberName()));
}
private EntityIndexData[] CreateEntityIndexData(ICachedNamedTypeSymbol cachedNamedTypeSymbol, IEnumerable <MemberData> memberData)
{
var hasMultiple = memberData
.Count(i => i.memberFieldSymbol.GetAttributes()
.HasAttribute(nameof(AbstractEntityIndexAttribute), canInherit: true)) > 1;
return(memberData
.Where(i => i.memberFieldSymbol.GetAttributes()
.HasAttribute(nameof(AbstractEntityIndexAttribute), canInherit: true))
.Select(
info =>
{
var data = new EntityIndexData();
var attribute = info.memberFieldSymbol.GetAttributes()
.GetAttributes(nameof(AbstractEntityIndexAttribute), canInherit: true)
.Single();
data.SetEntityIndexType(GetEntityIndexType(attribute));
data.IsCustom(false);
data.SetEntityIndexName(cachedNamedTypeSymbol.FullTypeName.ToComponentName());
data.SetKeyType(info.compilableTypeString);
data.SetComponentType(cachedNamedTypeSymbol.FullTypeName);
data.SetMemberName(info.name);
data.SetHasMultiple(hasMultiple);
data.SetContextNames(_contextsComponentDataProvider.GetContextNamesOrDefault(cachedNamedTypeSymbol));
return data;
})
.ToArray());
}
EntityIndexData createEntityIndexData(Type type, List <PublicMemberInfo> infos)
{
var data = new EntityIndexData();
var info = infos.Single(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1);
var attribute = (AbstractEntityIndexAttribute)info.attributes.Single(attr => attr.attribute is AbstractEntityIndexAttribute).attribute;
data.SetEntityIndexType(getEntityIndexType(attribute));
data.IsCustom(false);
data.SetEntityIndexName(type.ToCompilableString().RemoveComponentSuffix().RemoveDots());
data.SetKeyType(info.type.ToCompilableString());
data.SetComponentType(type.ToCompilableString());
data.SetComponentName(type.ToCompilableString().ShortTypeName().RemoveComponentSuffix());
data.SetMemberName(info.name);
var contextNames = ContextsComponentDataProvider.GetContextNames(type);
if (contextNames.Length == 0)
{
contextNames = new [] { _defaultContextName };
}
data.SetContextNames(contextNames);
return(data);
}
private EntityIndexData CreateCustomEntityIndexData(ICachedNamedTypeSymbol cachedNamedTypeSymbol)
{
var data = new EntityIndexData();
var attribute = cachedNamedTypeSymbol.GetAttributes(nameof(CustomEntityIndexAttribute)).Single();
var contextType = (ITypeSymbol)attribute.ConstructorArguments[0].Value;
var fullTypeName = cachedNamedTypeSymbol.FullTypeName;
data.SetEntityIndexType(fullTypeName);
data.IsCustom(true);
data.SetEntityIndexName(fullTypeName.RemoveDots());
data.SetHasMultiple(false);
data.SetContextNames(
new[]
{
contextType.GetFullTypeName().ShortTypeName().RemoveContextSuffix()
});
var getMethods = cachedNamedTypeSymbol
.NamedTypeSymbol
.GetAllMembers()
.Where(method => method.HasAttribute <EntityIndexGetMethodAttribute>())
.Select(
method => new MethodData(
method.GetReturnType().GetFullTypeName(),
method.Name,
method.GetParameters()
.Select(p => new MemberData(p.Type.GetFullTypeName(), p.Name))
.ToArray()))
.ToArray();
data.SetCustomMethods(getMethods);
return(data);
}
private EntityIndexData[] CreateEntityIndexData(Type type, List <PublicMemberInfo> infos)
{
var hasMultiple = infos.Count(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1) >
1;
return(infos
.Where(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1)
.Select(
info =>
{
var data = new EntityIndexData();
var attribute = (AbstractEntityIndexAttribute)info.attributes
.Single(attr => attr.attribute is AbstractEntityIndexAttribute)
.attribute;
data.SetEntityIndexType(GetEntityIndexType(attribute));
data.IsCustom(false);
data.SetEntityIndexName(type.ToCompilableString().ToComponentName());
data.SetKeyType(info.type.ToCompilableString());
data.SetComponentType(type.ToCompilableString());
data.SetMemberName(info.name);
data.SetHasMultiple(hasMultiple);
data.SetContextNames(_contextsComponentDataProvider.GetContextNamesOrDefault(type));
return data;
})
.ToArray());
}
private EntityIndexData[] createEntityIndexData(INamedTypeSymbol type, List <ISymbol> infos)
{
var hasMultiple = infos.Count(i => i.CountAttribute(typeof(AbstractEntityIndexAttribute)) == 1) > 1;
return(infos
.Where(i => i.CountAttribute(typeof(AbstractEntityIndexAttribute)) == 1)
.Select(info => {
var data = new EntityIndexData();
var attribute = info.GetAttribute(typeof(AbstractEntityIndexAttribute));
var entityIndexType = GetEntityIndexType(attribute.AttributeClass);
var typeName = (info is IFieldSymbol fieldSymbol)
? fieldSymbol.Type.ToDisplayString( )
: (info is IPropertySymbol symbol)
? symbol.Type.ToDisplayString( )
: null;
data.SetEntityIndexType(entityIndexType.ToString( ));
data.IsCustom(false);
data.SetEntityIndexName(type.ToString().ToComponentName(_contexts.Get <Settings>().Is <IgnoreNamespaces>()));
data.SetKeyType(typeName);
data.SetComponentType(type.ToString( ));
data.SetMemberName(info.Name);
data.SetHasMultiple(hasMultiple);
data.SetContextNames(type.GetContextNames( ).ToArray( ));
return data;
}).ToArray());
}
string generateGetMethod(EntityIndexData data, string contextName)
{
var template = "";
if (data.GetEntityIndexType() == "Entitas.EntityIndex")
{
template = GET_INDEX_TEMPLATE;
}
else if (data.GetEntityIndexType() == "Entitas.PrimaryEntityIndex")
{
template = GET_PRIMARY_INDEX_TEMPLATE;
}
else
{
return(getCustomMethods(data));
}
return(template
.Replace("${ContextName}", contextName)
.Replace("${IndexName}", data.GetHasMultiple()
? data.GetEntityIndexName() + data.GetMemberName().UppercaseFirst()
: data.GetEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${KeyType}", data.GetKeyType())
.Replace("${MemberName}", data.GetMemberName()));
}
string generateGetMethods(EntityIndexData data)
{
return(string.Join("\n\n", data.GetContextNames()
.Aggregate(new List <string>(), (getMethods, contextName) => {
getMethods.Add(generateGetMethod(data, contextName));
return getMethods;
}).ToArray()));
}
string getCustomMethods(EntityIndexData data)
{
return(string.Join("\n", data.GetCustomMethods()
.Select(m => CUSTOM_METHOD_TEMPLATE
.Replace("${ReturnType}", m.ReturnType.ToCompilableString())
.Replace("${MethodName}", m.Name)
.Replace("${Context}", data.GetContextNames()[0])
.Replace("${methodArgs}", string.Join(", ", m.GetParameters().Select(p => p.ParameterType.ToCompilableString() + " " + p.Name).ToArray()))
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${Name}", data.GetEntityIndexName())
.Replace("${args}", string.Join(", ", m.GetParameters().Select(p => p.Name).ToArray()))).ToArray()));
}
string getCustomMethods(EntityIndexData data)
{
return(string.Join("\n", data.GetCustomMethods()
.Select(m => CUSTOM_METHOD_TEMPLATE
.Replace("${ReturnType}", m.returnType)
.Replace("${MethodName}", m.methodName)
.Replace("${ContextName}", data.GetContextNames()[0])
.Replace("${methodArgs}", string.Join(", ", m.parameters.Select(p => p.type + " " + p.name).ToArray()))
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${IndexName}", data.GetEntityIndexName())
.Replace("${args}", string.Join(", ", m.parameters.Select(p => p.name).ToArray()))).ToArray()));
}
string generateMethods(EntityIndexData data, string contextName)
{
return(ADD_INDEX_TEMPLATE
.Replace("${contextName}", contextName.LowercaseFirst())
.Replace("${ContextName}", contextName)
.Replace("${IndexName}", data.GetEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${KeyType}", data.GetKeyType())
.Replace("${ComponentType}", data.GetComponentType())
.Replace("${MemberName}", data.GetMemberName())
.Replace("${componentName}", data.GetComponentType().ToComponentName(_ignoreNamespacesConfig.ignoreNamespaces).LowercaseFirst()));
}
private string GenerateAddMethods(EntityIndexData data)
{
return(string.Join(
"\n",
data.GetContextNames()
.Aggregate(
new List <string>(),
(addMethods, contextName) =>
{
addMethods.Add(GenerateAddMethod(data, contextName));
return addMethods;
})
.ToArray()));
}
string generateMethods(EntityIndexData data, string contextName)
{
return(ADD_INDEX_TEMPLATE
.Replace("${contextName}", contextName.LowercaseFirst())
.Replace("${ContextName}", contextName)
.Replace("${IndexName}", data.GetHasMultiple()
? data.GetEntityIndexName() + data.GetMemberName().UppercaseFirst()
: data.GetEntityIndexName())
.Replace("${Matcher}", data.GetEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${KeyType}", data.GetKeyType())
.Replace("${ComponentType}", data.GetComponentType())
.Replace("${MemberName}", data.GetMemberName())
.Replace("${componentName}", data.GetComponentType().ToComponentName(_contexts.settings.isIgnoreNamespaces).LowercaseFirst()));
}
EntityIndexData createEntityIndexData(Type type, List <PublicMemberInfo> infos)
{
var data = new EntityIndexData();
var info = infos.Single(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1);
var attribute = (AbstractEntityIndexAttribute)info.attributes.Single(attr => attr.attribute is AbstractEntityIndexAttribute).attribute;
data.SetEntityIndexType(getEntityIndexType(attribute));
data.IsCustom(false);
data.SetEntityIndexName(type.ToCompilableString().ToComponentName(_ignoreNamespacesConfig.ignoreNamespaces));
data.SetKeyType(info.type.ToCompilableString());
data.SetComponentType(type.ToCompilableString());
data.SetMemberName(info.name);
data.SetContextNames(_contextsComponentDataProvider.GetContextNamesOrDefault(type));
return(data);
}
private string GenerateMethods(EntityIndexData data, string contextName)
{
return(ADD_INDEX_TEMPLATE
.Replace("${contextName}", contextName)
.Replace("${ContextName}", contextName)
.Replace(
"${IndexName}", data.GetMemberEntityIndexName())
.Replace("${Matcher}", data.GetEntityIndexName())
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace("${KeyType}", data.GetKeyType())
.Replace("${ComponentType}", data.GetComponentType())
.Replace("${MemberName}", data.GetMemberName())
.Replace(
"${componentName}",
data.GetComponentType()
.ToComponentName()
.LowercaseFirst()
.AddPrefixIfIsKeyword()));
}
private string GetCustomMethods(EntityIndexData data)
{
return(string.Join(
"\n",
data.GetCustomMethods()
.Select(
m => CUSTOM_METHOD_TEMPLATE
.Replace("${ReturnType}", m.returnType)
.Replace("${MethodName}", m.methodName)
.Replace("${ContextName}", data.GetContextNames()[0])
.Replace(
"${methodArgs}",
string.Join(", ", m.parameters.Select(p => p.type + " " + p.name).ToArray()))
.Replace("${IndexType}", data.GetEntityIndexType())
.Replace(
"${IndexName}",
data.GetHasMultiple()
? data.GetEntityIndexName() + data.GetMemberName().UppercaseFirst()
: data.GetEntityIndexName())
.Replace("${args}", string.Join(", ", m.parameters.Select(p => p.name).ToArray())))
.ToArray()));
}
private EntityIndexData[] createEntityIndexData(Type type, List <PublicMemberInfo> infos)
{
var hasMultiple = infos.Count(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1) > 1;
return(infos
.Where(i => i.attributes.Count(attr => attr.attribute is AbstractEntityIndexAttribute) == 1)
.Select(info => {
var data = new EntityIndexData();
var attribute = (AbstractEntityIndexAttribute)info.attributes.Single(attr => attr.attribute is AbstractEntityIndexAttribute).attribute;
data.SetEntityIndexType(getEntityIndexType(attribute));
data.IsCustom(false);
data.SetEntityIndexName(type.ToCompilableString().ToComponentName(_contexts.settings.isIgnoreNamespaces));
data.SetKeyType(info.type.ToCompilableString());
data.SetComponentType(type.ToCompilableString());
data.SetMemberName(info.name);
data.SetHasMultiple(hasMultiple);
data.SetContextNames(ReflectionToCompsSystem.TypeToContextNames[type].ToArray( ));
return data;
}).ToArray());
}
public static void SetHasMultiple(this EntityIndexData data, bool hasMultiple)
{
data[ENTITY_INDEX_HAS_MULTIPLE] = hasMultiple;
}
public static void SetMemberName(this EntityIndexData data, string memberName)
{
data[ENTITY_INDEX_MEMBER_NAME] = memberName;
}
public static bool GetHasMultiple(this EntityIndexData data)
{
return((bool)data[ENTITY_INDEX_HAS_MULTIPLE]);
}
public static void SetComponentType(this EntityIndexData data, string type)
{
data[ENTITY_INDEX_COMPONENT_TYPE] = type;
}
public static string GetMemberName(this EntityIndexData data)
{
return((string)data[ENTITY_INDEX_MEMBER_NAME]);
}
public static string GetComponentType(this EntityIndexData data)
{
return((string)data[ENTITY_INDEX_COMPONENT_TYPE]);
}
public static void SetKeyType(this EntityIndexData data, string type)
{
data[ENTITY_INDEX_KEY_TYPE] = type;
}
public static string GetKeyType(this EntityIndexData data)
{
return((string)data[ENTITY_INDEX_KEY_TYPE]);
}
public static void SetContextNames(this EntityIndexData data, string[] contextNames)
{
data[ENTITY_INDEX_CONTEXT_NAMES] = contextNames;
}
public static string[] GetContextNames(this EntityIndexData data)
{
return((string[])data[ENTITY_INDEX_CONTEXT_NAMES]);
}