feat: add order to pack upg supported targets

upgrade/pack_builder/SupportedTargets.cpp

@@ -14,38 +14,63 @@ namespace application
         return *this;
     }
 
+    SupportedTargetsBuilder& SupportedTargetsBuilder::Order(uint8_t order)
+    {
+        this->order = 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 != 0)
+        {
+            if (targets.order.size() < order)
+                targets.order.resize(order);
+
+            targets.order[order - 1].emplace_back(target);
+            order = 0;
+        }
     }
 
     SupportedTargetsBuilder SupportedTargets::Create()

upgrade/pack_builder/SupportedTargets.hpp

@@ -43,13 +43,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::vector<std::vector<Target>> order;
     };
 
     class SupportedTargetsBuilder
@@ -62,6 +68,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 +77,12 @@ namespace application
 
     private:
         void AddToMandatoryWhenNecessary(const SupportedTargets::Target& target);
+        void AddInOrder(const SupportedTargets::Target& target);
 
     private:
         SupportedTargets targets;
         bool mandatory{ false };
+        uint8_t order{ 0 };
     };
 }
 

upgrade/pack_builder/test/TestSupportedTargets.cpp

@@ -35,3 +35,35 @@ TEST(SupportedTargetsTest, should_add_mandatory_targets)
     EXPECT_EQ(2, targets.HexTargets().size());
     EXPECT_EQ("application", targets.MandatoryTargets()[0]);
 }
+
+TEST(SupportedTargetsTest, should_add_targte_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("\nIncorrect order of target : " + target)
+        {}
+    };
+
     UpgradePackBuilderFacade::UpgradePackBuilderFacade(const application::UpgradePackBuilder::HeaderInfo& headerInfo)
         : headerInfo(headerInfo)
     {}
@@ -51,12 +59,40 @@ namespace main_
         builder.WriteUpgradePack(outputFilename, fileSystem);
     }
 
+    uint8_t UpgradePackBuilderFacade::GetOrder(const std::string& targetName, const std::vector<std::vector<std::string>>& orderedTargets)
+    {
+        uint8_t order = 1;
+        for ( auto targets : orderedTargets)
+        {
+            auto pos = std::find(targets.begin(), targets.end(), targetName);
+
+            if ( pos != targets.end())
+                return order;
+            else 
+                ++order;
+        }
+        return 0;
+    }
+
     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;
 
+        uint8_t currentOrderOfTarget = 1;
+        auto orderedTargets = supportedTargets.OrderOfTargets();
+
         for (const auto& [target, file, address] : requestedTargets)
+        {
+            uint8_t orderToAdd = GetOrder(target, orderedTargets);
+            if (orderToAdd != 0)
+            {
+                if (currentOrderOfTarget > orderToAdd)
+                    throw IncorrectOrderOfTargetException(target);
+                else
+                    currentOrderOfTarget = orderToAdd;
+            }
             inputs.push_back(factory.CreateInput(target, file, address));
+        }
 
         for (const auto& mandatoryTarget : supportedTargets.MandatoryTargets())
         {

upgrade/pack_builder_instantiations/UpgradePackBuilderFacade.hpp

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