chore: add ability for zcg to generate files once per template

src/ZoneCodeGeneratorLib/Generating/CodeGenerator.cpp

@@ -28,9 +28,9 @@ void CodeGenerator::SetupTemplates()
     m_template_mapping["assetstructtests"] = std::make_unique<AssetStructTestsTemplate>();
 }
 
-bool CodeGenerator::GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const
+bool CodeGenerator::GenerateCodeOncePerTemplate(const OncePerTemplateRenderingContext& context, ICodeTemplate* codeTemplate) const
 {
-    for (const auto& codeFile : codeTemplate->GetFilesToRender(context))
+    for (const auto& codeFile : codeTemplate->GetFilesToRenderOncePerTemplate(context))
     {
         fs::path p(m_args->m_output_directory);
         p.append(codeFile.m_file_name);
@@ -47,7 +47,34 @@ bool CodeGenerator::GenerateCodeForTemplate(const RenderingContext& context, ICo
             return false;
         }
 
-        codeTemplate->RenderFile(stream, codeFile.m_tag, context);
+        codeTemplate->RenderOncePerTemplateFile(stream, codeFile.m_tag, context);
+
+        stream.close();
+    }
+
+    return true;
+}
+
+bool CodeGenerator::GenerateCodeOncePerAsset(const OncePerAssetRenderingContext& context, ICodeTemplate* codeTemplate) const
+{
+    for (const auto& codeFile : codeTemplate->GetFilesToRenderOncePerAsset(context))
+    {
+        fs::path p(m_args->m_output_directory);
+        p.append(codeFile.m_file_name);
+
+        auto parentFolder(p);
+        parentFolder.remove_filename();
+        create_directories(parentFolder);
+
+        std::ofstream stream(p, std::fstream::out | std::fstream::binary);
+
+        if (!stream.is_open())
+        {
+            con::error("Failed to open file '{}'", p.string());
+            return false;
+        }
+
+        codeTemplate->RenderOncePerAssetFile(stream, codeFile.m_tag, context);
 
         stream.close();
     }
@@ -101,14 +128,14 @@ bool CodeGenerator::GenerateCode(const IDataRepository* repository)
         const auto foundTemplate = m_template_mapping.find(lowerTemplateName);
         if (foundTemplate == m_template_mapping.end())
         {
-            con::error("Unknown template '{}'.", templateName);
+            con::error("Unknown template '{}'", templateName);
             return false;
         }
 
         for (auto* asset : assets)
         {
-            auto context = RenderingContext::BuildContext(repository, asset);
+            auto context = OncePerAssetRenderingContext::BuildContext(repository, asset);
-            if (!GenerateCodeForTemplate(*context, foundTemplate->second.get()))
+            if (!GenerateCodeOncePerAsset(*context, foundTemplate->second.get()))
             {
                 con::error("Failed to generate code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
                 return false;
@@ -116,6 +143,17 @@ bool CodeGenerator::GenerateCode(const IDataRepository* repository)
 
             con::info("Successfully generated code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
         }
+
+        {
+            auto context = OncePerTemplateRenderingContext::BuildContext(repository);
+            if (!GenerateCodeOncePerTemplate(*context, foundTemplate->second.get()))
+            {
+                con::error("Failed to generate code with preset '{}'", foundTemplate->first);
+                return false;
+            }
+
+            con::info("Successfully generated code with preset '{}'", foundTemplate->first);
+        }
     }
     const auto end = std::chrono::steady_clock::now();
     con::debug("Generating code took {}ms", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());

src/ZoneCodeGeneratorLib/Generating/CodeGenerator.h

@@ -17,7 +17,9 @@ public:
 private:
     void SetupTemplates();
 
-    bool GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const;
+    bool GenerateCodeOncePerTemplate(const OncePerTemplateRenderingContext& context, ICodeTemplate* codeTemplate) const;
+    bool GenerateCodeOncePerAsset(const OncePerAssetRenderingContext& context, ICodeTemplate* codeTemplate) const;
+
     static bool GetAssetWithName(const IDataRepository* repository, const std::string& name, StructureInformation*& asset);
 
     const ZoneCodeGeneratorArguments* m_args;

src/ZoneCodeGeneratorLib/Generating/ICodeTemplate.h

@@ -1,22 +1,25 @@
 #pragma once
 
-#include "RenderingContext.h"
+#include "OncePerAssetRenderingContext.h"
+#include "OncePerTemplateRenderingContext.h"
 
 #include <ostream>
 #include <string>
 #include <vector>
 
+typedef unsigned CodeTemplateFileTag;
+
 class CodeTemplateFile
 {
 public:
-    CodeTemplateFile(std::string fileName, const int tag)
+    CodeTemplateFile(std::string fileName, const CodeTemplateFileTag tag)
         : m_file_name(std::move(fileName)),
           m_tag(tag)
     {
     }
 
     std::string m_file_name;
-    int m_tag;
+    CodeTemplateFileTag m_tag;
 };
 
 class ICodeTemplate
@@ -29,6 +32,17 @@ public:
     ICodeTemplate& operator=(const ICodeTemplate& other) = default;
     ICodeTemplate& operator=(ICodeTemplate&& other) noexcept = default;
 
-    virtual std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) = 0;
+    virtual std::vector<CodeTemplateFile> GetFilesToRenderOncePerTemplate(const OncePerTemplateRenderingContext& context)
-    virtual void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) = 0;
+    {
+        return {};
+    }
+
+    virtual void RenderOncePerTemplateFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerTemplateRenderingContext& context) {}
+
+    virtual std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
+    {
+        return {};
+    }
+
+    virtual void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) {}
 };

src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.cpp

@@ -1,4 +1,4 @@
-#include "RenderingContext.h"
+#include "OncePerAssetRenderingContext.h"
 
 #include "Domain/Computations/MemberComputations.h"
 #include "Domain/Computations/StructureComputations.h"
@@ -18,7 +18,9 @@ RenderingUsedType::RenderingUsedType(const DataDefinition* type, StructureInform
 {
 }
 
-RenderingContext::RenderingContext(std::string game, const Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks)
+OncePerAssetRenderingContext::OncePerAssetRenderingContext(std::string game,
+                                                           const Architecture gameArchitecture,
+                                                           std::vector<const FastFileBlock*> fastFileBlocks)
     : m_game(std::move(game)),
       m_architecture_mismatch(gameArchitecture != OWN_ARCHITECTURE),
       m_pointer_size(GetPointerSizeForArchitecture(gameArchitecture)),
@@ -40,7 +42,7 @@ RenderingContext::RenderingContext(std::string game, const Architecture gameArch
     }
 }
 
-RenderingUsedType* RenderingContext::AddUsedType(std::unique_ptr<RenderingUsedType> usedType)
+RenderingUsedType* OncePerAssetRenderingContext::AddUsedType(std::unique_ptr<RenderingUsedType> usedType)
 {
     auto* result = usedType.get();
     m_used_types.push_back(usedType.get());
@@ -49,7 +51,7 @@ RenderingUsedType* RenderingContext::AddUsedType(std::unique_ptr<RenderingUsedTy
     return result;
 }
 
-RenderingUsedType* RenderingContext::GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
+RenderingUsedType* OncePerAssetRenderingContext::GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
 {
     if (usedType->m_type->GetType() == DataDefinitionType::TYPEDEF)
     {
@@ -77,7 +79,7 @@ RenderingUsedType* RenderingContext::GetBaseType(const IDataRepository* reposito
     return nullptr;
 }
 
-void RenderingContext::AddMembersToContext(const IDataRepository* repository, StructureInformation* info)
+void OncePerAssetRenderingContext::AddMembersToContext(const IDataRepository* repository, StructureInformation* info)
 {
     for (const auto& member : info->m_ordered_members)
     {
@@ -121,7 +123,7 @@ void RenderingContext::AddMembersToContext(const IDataRepository* repository, St
     }
 }
 
-void RenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
+void OncePerAssetRenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
 {
     if (usedType->m_info != nullptr && !StructureComputations(usedType->m_info).IsAsset() && !computations->IsInRuntimeBlock() && !usedType->m_members_loaded)
     {
@@ -130,7 +132,7 @@ void RenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, M
     }
 }
 
-void RenderingContext::MakeAsset(const IDataRepository* repository, StructureInformation* asset)
+void OncePerAssetRenderingContext::MakeAsset(const IDataRepository* repository, StructureInformation* asset)
 {
     m_asset = asset;
     AddUsedType(std::make_unique<RenderingUsedType>(asset->m_definition, asset));
@@ -138,7 +140,7 @@ void RenderingContext::MakeAsset(const IDataRepository* repository, StructureInf
     AddMembersToContext(repository, asset);
 }
 
-void RenderingContext::CreateUsedTypeCollections()
+void OncePerAssetRenderingContext::CreateUsedTypeCollections()
 {
     for (auto* usedType : m_used_types)
     {
@@ -165,7 +167,7 @@ void RenderingContext::CreateUsedTypeCollections()
     }
 }
 
-bool RenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) const
+bool OncePerAssetRenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) const
 {
     const StructureComputations computations(usedType->m_info);
 
@@ -190,10 +192,10 @@ bool RenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) con
     return false;
 }
 
-std::unique_ptr<RenderingContext> RenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset)
+std::unique_ptr<OncePerAssetRenderingContext> OncePerAssetRenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset)
 {
-    auto context =
+    auto context = std::make_unique<OncePerAssetRenderingContext>(
-        std::make_unique<RenderingContext>(RenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
+        OncePerAssetRenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
 
     context->MakeAsset(repository, asset);
     context->CreateUsedTypeCollections();

src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.h

@@ -24,10 +24,10 @@ public:
     bool m_pointer_array_reference_is_reusable;
 };
 
-class RenderingContext
+class OncePerAssetRenderingContext
 {
 public:
-    static std::unique_ptr<RenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
+    static std::unique_ptr<OncePerAssetRenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
 
     std::string m_game;
     bool m_architecture_mismatch;
@@ -45,7 +45,7 @@ public:
     const FastFileBlock* m_default_temp_block;
 
 private:
-    RenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
+    OncePerAssetRenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
 
     RenderingUsedType* AddUsedType(std::unique_ptr<RenderingUsedType> usedType);
     RenderingUsedType* GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);

src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.cpp

@@ -0,0 +1,31 @@
+#include "OncePerTemplateRenderingContext.h"
+
+#include <algorithm>
+
+OncePerTemplateRenderingContext::OncePerTemplateRenderingContext(std::string game,
+                                                                 const Architecture gameArchitecture,
+                                                                 std::vector<const FastFileBlock*> fastFileBlocks)
+    : m_game(std::move(game)),
+      m_architecture_mismatch(gameArchitecture != OWN_ARCHITECTURE),
+      m_pointer_size(GetPointerSizeForArchitecture(gameArchitecture)),
+      m_blocks(std::move(fastFileBlocks)),
+      m_default_normal_block(nullptr),
+      m_default_temp_block(nullptr)
+{
+    for (const auto* block : m_blocks)
+    {
+        if (block->m_is_default)
+        {
+            if (block->m_type == FastFileBlockType::NORMAL && m_default_normal_block == nullptr)
+                m_default_normal_block = block;
+            else if (block->m_type == FastFileBlockType::TEMP && m_default_temp_block == nullptr)
+                m_default_temp_block = block;
+        }
+    }
+}
+
+std::unique_ptr<OncePerTemplateRenderingContext> OncePerTemplateRenderingContext::BuildContext(const IDataRepository* repository)
+{
+    return std::make_unique<OncePerTemplateRenderingContext>(
+        OncePerTemplateRenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
+}

src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Persistence/IDataRepository.h"
+
+#include <string>
+
+class OncePerTemplateRenderingContext
+{
+public:
+    static std::unique_ptr<OncePerTemplateRenderingContext> BuildContext(const IDataRepository* repository);
+
+    std::string m_game;
+    bool m_architecture_mismatch;
+    unsigned m_pointer_size;
+    std::vector<const FastFileBlock*> m_blocks;
+
+    const FastFileBlock* m_default_normal_block;
+    const FastFileBlock* m_default_temp_block;
+
+private:
+    OncePerTemplateRenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
+};

src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.cpp

@@ -14,7 +14,7 @@ namespace
     class Template final : BaseTemplate
     {
     public:
-        Template(std::ostream& stream, const RenderingContext& context)
+        Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
             : BaseTemplate(stream, context)
         {
         }
@@ -81,7 +81,7 @@ namespace
     };
 } // namespace
 
-std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(const RenderingContext& context)
+std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
 {
     std::vector<CodeTemplateFile> files;
 
@@ -93,7 +93,7 @@ std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(const R
     return files;
 }
 
-void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
+void AssetStructTestsTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
 {
     Template t(stream, context);
 

src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.h

@@ -1,9 +1,10 @@
 #pragma once
+
 #include "Generating/ICodeTemplate.h"
 
 class AssetStructTestsTemplate final : public ICodeTemplate
 {
 public:
-    std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
+    std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
-    void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
+    void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
 };

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp

@@ -5,7 +5,7 @@
 
 #include <sstream>
 
-BaseTemplate::BaseTemplate(std::ostream& stream, const RenderingContext& context)
+BaseTemplate::BaseTemplate(std::ostream& stream, const OncePerAssetRenderingContext& context)
     : m_out(stream),
       m_env(context),
       m_intendation(0u)

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h

@@ -5,7 +5,7 @@
 #include "Domain/Evaluation/OperandDynamic.h"
 #include "Domain/Evaluation/OperandStatic.h"
 #include "Domain/Evaluation/Operation.h"
-#include "Generating/RenderingContext.h"
+#include "Generating/OncePerAssetRenderingContext.h"
 
 #include <format>
 #include <ostream>
@@ -15,7 +15,7 @@ class BaseTemplate
 protected:
     static constexpr auto INTENDATION = "    ";
 
-    BaseTemplate(std::ostream& stream, const RenderingContext& context);
+    BaseTemplate(std::ostream& stream, const OncePerAssetRenderingContext& context);
 
     void DoIntendation() const;
 
@@ -37,7 +37,7 @@ protected:
     static std::string MakeEvaluation(const IEvaluation* evaluation);
 
     std::ostream& m_out;
-    const RenderingContext& m_env;
+    const OncePerAssetRenderingContext& m_env;
     unsigned m_intendation;
 
 private:

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp

@@ -17,7 +17,7 @@ namespace
     class Template final : BaseTemplate
     {
     public:
-        Template(std::ostream& stream, const RenderingContext& context)
+        Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
             : BaseTemplate(stream, context)
         {
         }
@@ -2198,7 +2198,7 @@ namespace
     };
 } // namespace
 
-std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(const RenderingContext& context)
+std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
 {
     std::vector<CodeTemplateFile> files;
 
@@ -2211,7 +2211,7 @@ std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(const Rendering
     return files;
 }
 
-void ZoneLoadTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
+void ZoneLoadTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
 {
     Template t(stream, context);
 

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.h

@@ -1,9 +1,10 @@
 #pragma once
+
 #include "Generating/ICodeTemplate.h"
 
 class ZoneLoadTemplate final : public ICodeTemplate
 {
 public:
-    std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
+    std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
-    void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
+    void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
 };

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp

@@ -16,7 +16,7 @@ namespace
     class Template final : BaseTemplate
     {
     public:
-        Template(std::ostream& stream, const RenderingContext& context)
+        Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
             : BaseTemplate(stream, context)
         {
         }
@@ -764,7 +764,7 @@ namespace
     };
 } // namespace
 
-std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(const RenderingContext& context)
+std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
 {
     std::vector<CodeTemplateFile> files;
 
@@ -777,7 +777,7 @@ std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(const Rendering
     return files;
 }
 
-void ZoneMarkTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
+void ZoneMarkTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
 {
     Template t(stream, context);
 

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.h

@@ -1,9 +1,10 @@
 #pragma once
+
 #include "Generating/ICodeTemplate.h"
 
 class ZoneMarkTemplate final : public ICodeTemplate
 {
 public:
-    std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
+    std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
-    void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
+    void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
 };

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp

@@ -9,13 +9,13 @@
 
 namespace
 {
-    constexpr int TAG_HEADER = 1;
+    constexpr CodeTemplateFileTag TAG_HEADER = 1;
-    constexpr int TAG_SOURCE = 2;
+    constexpr CodeTemplateFileTag TAG_SOURCE = 2;
 
     class Template final : BaseTemplate
     {
     public:
-        Template(std::ostream& stream, const RenderingContext& context)
+        Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
             : BaseTemplate(stream, context)
         {
         }
@@ -1233,7 +1233,7 @@ namespace
     };
 } // namespace
 
-std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(const RenderingContext& context)
+std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
 {
     std::vector<CodeTemplateFile> files;
 
@@ -1247,7 +1247,7 @@ std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(const Renderin
     return files;
 }
 
-void ZoneWriteTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
+void ZoneWriteTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
 {
     Template t(stream, context);
 

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.h

@@ -1,9 +1,10 @@
 #pragma once
+
 #include "Generating/ICodeTemplate.h"
 
 class ZoneWriteTemplate final : public ICodeTemplate
 {
 public:
-    std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
+    std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
-    void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
+    void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
 };