feat: add order to pack upg supported targets

upgrade/pack_builder/SupportedTargets.cpp

@@ -14,38 +14,60 @@ namespace application
         return *this;
     }
 
+    SupportedTargetsBuilder& SupportedTargetsBuilder::Order(uint8_t order)
+    {
+        this->order.Emplace(order);
+        return *this;
+    }
+
     SupportedTargetsBuilder& SupportedTargetsBuilder::AddCmd(const SupportedTargets::Target& target)
     {
         AddToMandatoryWhenNecessary(target);
+        AddInOrder(target);
         targets.cmd.emplace_back(target);
         return *this;
     }
 
     SupportedTargetsBuilder& SupportedTargetsBuilder::AddHex(const SupportedTargets::Target& target)
     {
         AddToMandatoryWhenNecessary(target);
+        AddInOrder(target);
         targets.hex.emplace_back(target);
         return *this;
     }
 
     SupportedTargetsBuilder& SupportedTargetsBuilder::AddElf(const SupportedTargets::Target& target, uint32_t offset)
     {
         AddToMandatoryWhenNecessary(target);
+        AddInOrder(target);
         targets.elf.emplace_back(target, offset);
         return *this;
     }
 
     SupportedTargetsBuilder& SupportedTargetsBuilder::AddBin(const SupportedTargets::Target& target, uint32_t offset)
     {
         AddToMandatoryWhenNecessary(target);
+        AddInOrder(target);
         targets.bin.emplace_back(target, offset);
         return *this;
     }
 
     void SupportedTargetsBuilder::AddToMandatoryWhenNecessary(const SupportedTargets::Target& target)
     {
         if (mandatory)
+        {
             targets.mandatory.emplace_back(target);
+            mandatory = false;
+        }
+    }
+
+    void SupportedTargetsBuilder::AddInOrder(const SupportedTargets::Target& target)
+    {
+        if (order)
+        {
+            targets.order[*order].emplace_back(target);
+            order = infra::none;
+        }
     }
 
     SupportedTargetsBuilder SupportedTargets::Create()

upgrade/pack_builder/SupportedTargets.hpp

@@ -1,6 +1,8 @@
 #ifndef UPGRADE_SUPPORTED_TARGETS_HPP
 #define UPGRADE_SUPPORTED_TARGETS_HPP
 
+#include "infra/util/Optional.hpp"
+#include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ -43,13 +45,19 @@ namespace application
             return mandatory;
         }
 
+        const auto& OrderOfTargets() const
+        {
+            return order;
+        }
+
     private:
         std::vector<Target> cmd;
         std::vector<Target> hex;
         std::vector<TargetWithOffset> elf;
         std::vector<TargetWithOffset> bin;
 
         std::vector<Target> mandatory;
+        std::map<uint8_t, std::vector<Target>> order;
     };
 
     class SupportedTargetsBuilder
@@ -62,6 +70,7 @@ namespace application
 
         SupportedTargetsBuilder& Mandatory();
         SupportedTargetsBuilder& Optional();
+        SupportedTargetsBuilder& Order(uint8_t order);
 
         SupportedTargetsBuilder& AddCmd(const SupportedTargets::Target& target);
         SupportedTargetsBuilder& AddHex(const SupportedTargets::Target& target);
@@ -70,10 +79,12 @@ namespace application
 
     private:
         void AddToMandatoryWhenNecessary(const SupportedTargets::Target& target);
+        void AddInOrder(const SupportedTargets::Target& target);
 
     private:
         SupportedTargets targets;
         bool mandatory{ false };
+        infra::Optional<uint8_t> order;
     };
 }
 

upgrade/pack_builder/test/TestSupportedTargets.cpp

@@ -35,3 +35,38 @@ TEST(SupportedTargetsTest, should_add_mandatory_targets)
     EXPECT_EQ(2, targets.HexTargets().size());
     EXPECT_EQ("application", targets.MandatoryTargets()[0]);
 }
+
+TEST(SupportedTargetsTest, should_add_target_to_mandatory_only_if_specified)
+{
+    application::SupportedTargets targets = application::SupportedTargets::Create()
+                                                .Mandatory()
+                                                .AddHex("application")
+                                                .AddHex("data");
+
+    EXPECT_EQ(1, targets.MandatoryTargets().size());
+    EXPECT_EQ("application", targets.MandatoryTargets()[0]);
+}
+
+TEST(SupportedTargetsTest, should_add_targets_in_order)
+{
+    application::SupportedTargets targets = application::SupportedTargets::Create()
+                                                .Order(2)
+                                                .AddHex("application")
+                                                .Order(1)
+                                                .AddHex("data");
+
+    EXPECT_EQ(2, targets.OrderOfTargets().size());
+    EXPECT_EQ("data", targets.OrderOfTargets()[0][0]);
+    EXPECT_EQ("application", targets.OrderOfTargets()[1][0]);
+}
+
+TEST(SupportedTargetsTest, should_add_target_to_order_only_if_specified)
+{
+    application::SupportedTargets targets = application::SupportedTargets::Create()
+                                                .Order(1)
+                                                .AddHex("data")
+                                                .AddHex("application");
+
+    EXPECT_EQ(1, targets.OrderOfTargets()[0].size());
+    EXPECT_EQ("data", targets.OrderOfTargets()[0][0]);
+}

upgrade/pack_builder_instantiations/UpgradePackBuilderFacade.cpp

@@ -20,6 +20,14 @@ namespace main_
         {}
     };
 
+    struct IncorrectOrderOfTargetException
+        : std::runtime_error
+    {
+        explicit IncorrectOrderOfTargetException(const std::string& target)
+            : std::runtime_error("Incorrect order of target: " + target)
+        {}
+    };
+
     UpgradePackBuilderFacade::UpgradePackBuilderFacade(const application::UpgradePackBuilder::HeaderInfo& headerInfo)
         : headerInfo(headerInfo)
     {}
@@ -51,12 +59,45 @@ namespace main_
         builder.WriteUpgradePack(outputFilename, fileSystem);
     }
 
+    infra::Optional<uint8_t> UpgradePackBuilderFacade::GetOrder(const std::string& targetName, const std::map<uint8_t, std::vector<std::string>>& orderedTargets) const
+    {
+        infra::Optional<uint8_t> order(infra::inPlace, 0);
+        for (const auto& targets : orderedTargets)
+        {
+            ++(*order);
+            const auto targetPos = std::find(targets.second.begin(), targets.second.end(), targetName);
+
+            if (targetPos != targets.second.end())
+                return order;
+        }
+        return infra::none;
+    }
+
+    bool UpgradePackBuilderFacade::CheckIfTargetIsInOrder(const std::string& target, const application::SupportedTargets& supportedTargets)
+    {
+        static uint8_t currentOrderOfTarget = 1;
+        static const auto& orderedTargets = supportedTargets.OrderOfTargets();
+        const auto orderToAdd = GetOrder(target, orderedTargets);
+        if (orderToAdd)
+        {
+            if (currentOrderOfTarget > *orderToAdd)
+                return false;
+            else
+                currentOrderOfTarget = *orderToAdd;
+        }
+        return true;
+    }
+
     std::vector<std::unique_ptr<application::Input>> UpgradePackBuilderFacade::CreateInputs(const application::SupportedTargets& supportedTargets, const TargetAndFiles& requestedTargets, application::InputFactory& factory)
     {
         std::vector<std::unique_ptr<application::Input>> inputs;
 
         for (const auto& [target, file, address] : requestedTargets)
+        {
+            if (!CheckIfTargetIsInOrder(target, supportedTargets))
+                throw IncorrectOrderOfTargetException(target);
             inputs.push_back(factory.CreateInput(target, file, address));
+        }
 
         for (const auto& mandatoryTarget : supportedTargets.MandatoryTargets())
         {

upgrade/pack_builder_instantiations/UpgradePackBuilderFacade.hpp

@@ -36,6 +36,8 @@ namespace main_
         virtual void PostBuilder(application::UpgradePackBuilder& builder, application::ImageSigner& signer, const BuildOptions& buildOptions);
 
     private:
+        infra::Optional<uint8_t> GetOrder(const std::string& targetName, const std::map<uint8_t, std::vector<std::string>>& orderedTargets) const;
+        bool CheckIfTargetIsInOrder(const std::string& target, const application::SupportedTargets& supportedTargets);
         std::vector<std::unique_ptr<application::Input>> CreateInputs(const application::SupportedTargets& supportedTargets, const TargetAndFiles& requestedTargets, application::InputFactory& factory);
 
     protected: