protected override void Execute(List <Ent> entities)
{
foreach (var ent in entities)
{
if (!ent.Is <GenCompEntApiInterface_ForSingleContext>() &&
ent.Get_ <ContextNamesComp>().Values.Count < 2)
{
continue;
}
{
var template = ent.Has_ <PublicFieldsComp>() ? STANDARD_TEMPLATE : FLAG_TEMPLATE;
var filePath = "Components" + Path.DirectorySeparatorChar + "Interfaces" + Path.DirectorySeparatorChar + "I" + ent.ComponentName(_contexts) + "Entity.cs";
var contents = template.Replace(_contexts, ent, String.Empty);
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
var contextNames = ent.Get_ <ContextNamesComp>().Values;
foreach (var contextName in contextNames)
{
var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + ent.ComponentNameWithContext(contextName).AddComponentSuffix() + ".cs";
var contents = ENTITY_INTERFACE_TEMPLATE.Replace(_contexts, ent, contextName);
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
}
protected override void Execute(List <Ent> ents)
{
var settings = _contexts.Get <Settings>( );
_generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated");
_isDryRun = settings.Is <RunInDryMode>();
var stringBuilder = new StringBuilder( );
DeleteNonGenFiles(ents, stringBuilder);
foreach (var ent in ents)
{
WriteFile(ent, stringBuilder);
}
if (settings.Is <LogGeneratedPaths>())
{
var s = stringBuilder.ToString( );
if (String.IsNullOrEmpty(s))
{
Log("No changes found since previous run\n");
}
else
{
Log(s);
}
}
}
public static void ProvideEventCompNewEnts(Contexts contexts, Entity <Main> ent)
{
var mainContext = contexts.Get <Main>();
var settingsContext = contexts.Get <Settings>();
foreach (var contextName in ent.Get_ <ContextNamesComp>().Values)
{
foreach (var eventInfo in ent.Get_ <EventComp>().Values)
{
var componentName = ent.Get_ <Comp>().FullTypeName.ToComponentName(settingsContext.Is <IgnoreNamespaces>());
var optionalContextName = ent.Get_ <ContextNamesComp>().Values.Count > 1 ? contextName : string.Empty;
var eventTypeSuffix = ent.GetEventTypeSuffix(eventInfo);
var theAnySuffix = eventInfo.EventTarget == EventTarget.Any ? "Any" : "";
var listenerComponentName = optionalContextName + theAnySuffix + componentName + eventTypeSuffix + "Listener";
var eventCompFullTypeName = listenerComponentName.AddComponentSuffix();
var eventListenerCompEnt = mainContext.CreateEntity( );
eventListenerCompEnt.Flag <EventListenerComp>(true);
eventListenerCompEnt.Add_(new Comp(listenerComponentName, eventCompFullTypeName));
eventListenerCompEnt.Add_(new ContextNamesComp(new List <String> {
contextName
}));
eventListenerCompEnt.Add_(new PublicFieldsComp(new List <FieldInfo>
{
new FieldInfo("System.Collections.Generic.List<I" + listenerComponentName + ">", "value")
}));
}
}
}
public static string WrapInNamespace(this string s, Contexts contexts)
{
var value = contexts.Get <Settings>().Has_ <GeneratedNamespace>()
? contexts.Get <Settings>().Get_ <GeneratedNamespace>().Value
: null;
return(String.IsNullOrEmpty(value) ? s : $"namespace {value} {{\n{s}\n}}\n");
}
public PostProcWriteGenPathsToCsprojSystem(Contexts contexts) : base(contexts.Get <Settings>())
{
_contexts = contexts;
_generatedGroup = contexts.Get <Main>().GetGroup(Matcher <Entity <Main> >
.AllOf(
Matcher <Main, GeneratedFileComp> .I)
.NoneOf(
Matcher <Main, Destroy> .I));
}
protected override void Execute(List <Ent> entities)
{
var settingsGrammar = Hub.SettingsGrammar;
var settingsContext = _contexts.Get <Settings>( );
var d = _contexts
.Get <Settings>( )
.Get_ <SettingsDict>( )
.Dict;
if (d.ContainsKey(nameof(LogGeneratedPaths)))
{
settingsContext.Flag <LogGeneratedPaths>(settingsGrammar.BoolFromStr(d[nameof(LogGeneratedPaths)].FirstOrDefault( )));
}
else
{
settingsContext.Flag <LogGeneratedPaths>(true);
}
if (d.ContainsKey(nameof(IgnoreNamespaces)))
{
settingsContext.Flag <IgnoreNamespaces>(settingsGrammar.BoolFromStr(d[nameof(IgnoreNamespaces)].FirstOrDefault( )));
}
else
{
settingsContext.Flag <IgnoreNamespaces>(false);
}
if (d.ContainsKey(nameof(RunInDryMode)))
{
settingsContext.Flag <RunInDryMode>(settingsGrammar.BoolFromStr(d[nameof(RunInDryMode)].FirstOrDefault( )));
}
else
{
settingsContext.Flag <RunInDryMode>(false);
}
settingsContext.Replace_(d.ContainsKey(nameof(GeneratedNamespace))
? new GeneratedNamespace(d[nameof(GeneratedNamespace)].FirstOrDefault( ))
: new GeneratedNamespace(""));
settingsContext.Replace_(d.ContainsKey(nameof(GeneratePath))
? new GeneratePath(d[nameof(GeneratePath)].FirstOrDefault( ))
: new GeneratePath(""));
settingsContext.Replace_(d.ContainsKey(nameof(WriteGeneratedPathsToCsProj))
? new WriteGeneratedPathsToCsProj(d[nameof(WriteGeneratedPathsToCsProj)].FirstOrDefault( ))
: new WriteGeneratedPathsToCsProj(""));
if (!Directory.Exists(settingsContext.Get_ <GeneratePath>( ).Value))
{
throw new DirectoryNotFoundException($"Generate path does not exist: '{settingsContext.Get_<GeneratePath>( ).Value}'");
}
}
protected override void Execute(List <Ent> entities)
{
var settings = _contexts.Get <Settings>();
if (settings.Is <RunInDryMode>())
{
return;
}
var generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated");
var dirInfo = new DirectoryInfo(generatePath);
if (!dirInfo.Exists)
{
return;
}
foreach (var file in dirInfo.GetFiles( ))
{
file.Delete( );
}
foreach (var dir in dirInfo.GetDirectories( ))
{
dir.Delete(true);
}
}
protected override void Execute(List <Ent> entities)
{
var path = entities[0].Get_ <WriteGeneratedPathsToCsProj>().Value;
if (String.IsNullOrEmpty(path))
{
return;
}
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
var settings = _contexts.Get <Settings>();
_generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated");
var contents = File.ReadAllText(path);
contents = RemoveExistingGeneratedEntires(contents);
contents = AddGeneratedEntires(contents);
File.WriteAllText(path, contents);
}
protected override void Execute(List <Ent> entities)
{
foreach (var ent in entities)
{
var contextNames = ent.Get_ <ContextNamesComp>().Values;
foreach (var contextName in contextNames)
{
var template = ent.Has_ <PublicFieldsComp>() ? STANDARD_TEMPLATE : FLAG_TEMPLATE;
var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + contextName + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs";
var contents = template
.Replace(_contexts, ent, contextName);
if (ent.Has_ <PublicFieldsComp>())
{
contents = contents
.Replace("${memberAssignmentList}", GenerateMemberAssignmentList(ent.Get_ <PublicFieldsComp>().Values.ToArray( )));
}
var generatedBy = GetType().FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
}
protected override void Execute(List <Ent> entities)
{
foreach (var ent in entities)
{
var contextNames = ent.Get_ <ContextNamesComp>().Values;
foreach (var contextName in contextNames)
{
var eventInfos = ent.Get_ <EventComp>().Values;
foreach (var eventInfo in eventInfos)
{
var filePath = "Events" + Path.DirectorySeparatorChar + "Interfaces" + Path.DirectorySeparatorChar + "I" + ent.EventListener(_contexts, contextName, eventInfo) + ".cs";
var contents = TEMPLATE
.Replace("${methodParameters}", ent.GetEventMethodArgs(eventInfo
, ent.Has_ <PublicFieldsComp>()
? ", " + ent.Get_ <PublicFieldsComp>().Values.GetMethodParameters(false)
: ""))
.Replace(_contexts, ent, contextName, eventInfo);
var generatedBy = GetType().FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
}
}
protected override void Execute(List <Ent> entities)
{
var d = entities[0].Get_ <SettingsDict>().Dict;
_contexts.Get <Settings>().Replace_(new RoslynPathToSolution(d.ContainsKey(nameof(RoslynPathToSolution))
? d[nameof(RoslynPathToSolution)].FirstOrDefault( )
: ""));
}
protected override void Execute(List <Ent> entities)
{
for (var i = 0; i < entities.Count; i++)
{
var ent = entities[i];
var contextName = ent.Get_ <ContextComp>().Name;
var filePath = contextName + Path.DirectorySeparatorChar + contextName.AddMatcherSuffix( ) + ".cs";
var contents = TEMPLATE.Replace(contextName);
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
public void Execute( )
{
var entities = _contexts.Get <Main>().GetGroup(Matcher <Ent>
.AllOf(
Matcher <Main, Comp> .I,
Matcher <Main, PublicFieldsComp> .I))
.GetEntities( );
var entityIndexData = new List <EntityIndexData>( );
foreach (var ent in entities)
{
foreach (var field in ent.Get_ <PublicFieldsComp>().Values)
{
if (field.EntityIndexInfo == null)
{
continue;
}
entityIndexData.Add(field.EntityIndexInfo.EntityIndexData);
}
}
var entsCustomIndex = _contexts.Get <Main>().GetGroup(Matcher <Main, CustomEntityIndexComp> .I).GetEntities( );
foreach (var ent in entsCustomIndex)
{
entityIndexData.Add(ent.Get_ <CustomEntityIndexComp>().EntityIndexData);
}
if (entityIndexData.Count == 0)
{
return;
}
entityIndexData.Sort((a, b) => a.GetEntityIndexName( ).CompareTo(b.GetEntityIndexName( )));
generateEntityIndices(entityIndexData.ToArray( ));
}
protected override void Execute(List <Ent> entities)
{
var contextNames = new List <String>( );
for (var i = 0; i < entities.Count; i++)
{
var ent = entities[i];
contextNames.Add(ent.Get_ <ContextComp>().Name);
}
contextNames.Sort((a, b) => String.Compare(a, b, StringComparison.Ordinal));
var fileEnt = _contexts.Get <Main>().CreateEntity( );
var contents = Generate(contextNames.ToArray( ));
fileEnt.Add_(new GeneratedFileComp("Contexts.cs", contents.WrapInNamespace(_contexts), GetType( ).FullName));
}
protected override void Execute(List <Ent> entities)
{
for (var i = 0; i < entities.Count; i++)
{
var ent = entities[i];
var nonIComp = ent.Get_ <NonIComp>();
var filePath = "Components" + Path.DirectorySeparatorChar + nonIComp.FullCompName + ".cs";
var contents = Generate(nonIComp.FullCompName, nonIComp.FieldTypeName);
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
protected override void Execute(List <Ent> entities)
{
var contextNames = new HashSet <String>( );
foreach (var ent in entities)
{
contextNames.UnionWith(ent.Get_ <ContextNamesComp>().Values);
}
foreach (var name in contextNames)
{
var ent = _contexts.Get <Main>().CreateEntity( );
ent.Add_(new ContextComp(name));
}
}
protected override void Execute(List <Ent> entities)
{
var contextEnts = new Dictionary <String, List <Ent> >( );
foreach (var ent in entities)
{
foreach (var contextName in ent.Get_ <ContextNamesComp>().Values)
{
if (!contextEnts.ContainsKey(contextName))
{
contextEnts[contextName] = new List <Ent>( );
}
contextEnts[contextName].Add(ent);
}
}
foreach (var contextName in contextEnts.Keys.ToArray())
{
contextEnts[contextName] = contextEnts[contextName]
.OrderBy(ent => ent.Get_ <Comp>().FullTypeName)
.ToList();
}
foreach (var kv in contextEnts)
{
var ents = kv.Value;
var componentConstantsList = string.Join("\n", ents.ToArray()
.Select((ent, index) => K_TYPE_V_INDEX
.Replace("${ComponentType}", ent.Get_ <Comp>().FullTypeName)
.Replace("${Index}", index.ToString())).ToArray());
var contextName = kv.Key;
var filePath = contextName + Path.DirectorySeparatorChar + contextName + "ComponentsLookupDicts.cs";
var generatedBy = GetType().FullName;
var contents = TEMPLATE
.Replace("${Lookup}", contextName + CodeGeneratorExtentions.LOOKUP)
.Replace("${kTypeVIndexList}", componentConstantsList);
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
protected override void Execute(List <Ent> entities)
{
foreach (var ent in entities)
{
var contextNames = ent.Get_ <ContextNamesComp>().Values;
foreach (var contextName in contextNames)
{
var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + contextName + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs";
var contents = TEMPLATE
.Replace("${componentNames}", contextName + CodeGeneratorExtentions.LOOKUP + ".componentNames")
.Replace(_contexts, ent, contextName);
var generatedBy = GetType().FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
}
protected override void Execute(List <Ent> entities)
{
foreach (var ent in entities)
{
var contextNames = ent.Get_ <ContextNamesComp>().Values;
foreach (var contextName in contextNames)
{
var eventInfos = ent.Get_ <EventComp>().Values;
foreach (var eventInfo in eventInfos)
{
var filePath = "Events" + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + ent.EventListener(_contexts, contextName, eventInfo).AddComponentSuffix() + ".cs";
var contents = TEMPLATE.Replace(_contexts, ent, contextName, eventInfo);
var generatedBy = GetType().FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
}
}
protected override void Execute(List <Ent> entities)
{
var settings = _contexts.Get <Settings>();
var generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated");
var stringBuilder = new StringBuilder( );
foreach (var ent in entities)
{
var targetPath = Path.Combine(generatePath, ent.Get_ <GeneratedFileComp>().FilePath);
if (settings.Is <LogGeneratedPaths>())
{
stringBuilder.Append(targetPath);
stringBuilder.Append(" - ");
stringBuilder.Append(ent.Get_ <GeneratedFileComp>().GeneratedBy);
stringBuilder.Append("\n");
}
if (settings.Is <RunInDryMode>())
{
continue;
}
var dirPath = Path.GetDirectoryName(targetPath);
if (dirPath != null && !Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
File.WriteAllText(targetPath, ent.Get_ <GeneratedFileComp>().Contents);
}
if (settings.Is <LogGeneratedPaths>())
{
var s = stringBuilder.ToString( );
Console.Write(s);
#if UNITY_EDITOR
UnityEngine.Debug.Log(s);
#endif
}
}
protected override void Execute(List <Ent> entities)
{
for (var i = 0; i < entities.Count; i++)
{
var ent = entities[i];
var contents = COMPONENT_TEMPLATE
.Replace("${FullComponentName}", ent.Get_ <Comp>().Name);
contents = contents
.Replace(
"${memberList}",
ent.Has_ <PublicFieldsComp>()
? GenerateMemberAssignmentList(ent.Get_ <PublicFieldsComp>().Values)
: ""
);
var filePath = "Components" + Path.DirectorySeparatorChar + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs";
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
}
protected override void Execute(List <Ent> entities)
{
var contextNamesWithEvents = new HashSet <String>( );
foreach (var ent in entities)
{
contextNamesWithEvents.UnionWith(ent.Get_ <ContextNamesComp>().Values);
}
var contextNames = contextNamesWithEvents.ToList( );
contextNames.Sort( );
var generatedBy = GetType( ).FullName;
var filePath = "Events" + Path.DirectorySeparatorChar + "EventSystems.cs";
var contents = TEMPLATE
.Replace("${systemsList}", GenerateSystemList(contextNames));
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
private void CreateFileEnt(Ent ent, EventInfo eventInfo, string contextName)
{
var methodArgs = ent.GetEventMethodArgs(eventInfo, ", " + (!ent.Has_ <PublicFieldsComp>()
? ent.PrefixedComponentName(_contexts)
: GetMethodArgs(ent.Get_ <PublicFieldsComp>().Values.ToArray( ))));
var filePath = "Events" + Path.DirectorySeparatorChar + "Systems" + Path.DirectorySeparatorChar +
ent.Event(_contexts, contextName, eventInfo) + "EventSystem.cs";
var template = eventInfo.EventTarget == EventTarget.Self
? TEMPLATE_SELF
: TEMPLATE_ANY;
var cachedAccess = !ent.Has_ <PublicFieldsComp>()
? string.Empty
: "var component = e." + ent.ComponentName(_contexts).LowercaseFirst( ) + ";";
if (eventInfo.EventType == EventType.Removed)
{
methodArgs = string.Empty;
cachedAccess = string.Empty;
}
var contents = template
.Replace("${GroupEvent}", eventInfo.EventType.ToString( ))
.Replace("${filter}", GetFilter(ent, contextName, eventInfo))
.Replace("${cachedAccess}", cachedAccess)
.Replace("${methodArgs}", methodArgs)
.Replace(_contexts, ent, contextName, eventInfo);
var generatedBy = GetType( ).FullName;
var fileEnt = _contexts.Get <Main>().CreateEntity( );
fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy));
}
public GenComponentSystem(Contexts contexts) : base(contexts.Get <Main>())
{
_contexts = contexts;
}
public static string ComponentName(this Entity <Main> ent, Contexts contexts)
{
return(ent.Get_ <Comp>().FullTypeName.ToComponentName(contexts.Get <Settings>().Is <IgnoreNamespaces>()));
}
public PostProcApplyDiffToDiskSystem(Contexts contexts) : base(contexts.Get <Main>())
{
_contexts = contexts;
}
public Gen_AllEventSystems_System(Contexts contexts) : base(contexts.Get <Main>())
{
_contexts = contexts;
}
public GenEventListenerCompSystem(Contexts contexts) : base(contexts.Get <Main>())
{
_contexts = contexts;
}
public SettingsSetCoreSettingsSystem(Contexts contexts) : base(contexts.Get <Settings>())
{
_contexts = contexts;
}
public GenCompEntityApiSystem(Contexts contexts) : base(contexts.Get <Main>())
{
_contexts = contexts;
}
