fixed issue where arguments were being removed from a copy of the argument

include/task/instagram_task.hpp

@@ -8,7 +8,7 @@ namespace Scheduler {
 namespace Args {
 const QString HEADER_TYPE = "header";
 const QString DESCRIPTION_TYPE = "description";
-const QString HASHTAG_TYPE = "hashtag";
+const QString HASHTAG_TYPE = "hashtags";
 const QString PROMOTE_TYPE = "promote_share";
 const QString LINK_BIO_TYPE = "link_in_bio";
 const QString REQUESTED_BY_TYPE = "requested_by";
@@ -45,9 +45,16 @@ class InstagramTask : public Scheduler::Task {
   /**
    * Overrides @abstract Task::getTaskArgument
    *
+   * Easy access to an argument.
+   */
+  virtual Scheduler::TaskArgument getTaskArgument(QString name) override;
+
+  /**
+   * Overrides @abstract Task::getTaskArgumentValue
+   *
    * Easy access to an argument's value.
    */
-  virtual const Scheduler::TypeVariant getTaskArgument(QString name) override;
+  virtual const Scheduler::TypeVariant getTaskArgumentValue(QString name) override;
 
   /**
    * Overrides @abstract Task::getArgumentValues
@@ -98,6 +105,13 @@ class InstagramTask : public Scheduler::Task {
    */
   virtual void addArgument(QString name, QString string) override;
 
+  /**
+   * Overrides @abstract Task::removeArgument
+   *
+   * Remove a value from a container argument.
+   */
+  virtual void removeArgument(QString name, Scheduler::TypeVariant arg) override;
+
   /**
    * Overrides @abstract Task::hasFiles
    *

include/task/task.hpp

@@ -67,7 +67,7 @@ using TaskQueue = QQueue<Task*>;
 using ArgumentType = const char*;
 using ArgumentValues = QVector<QString>;
 using TypeVariant = std::variant<bool, int, QVector<QString>, QString, QVector<KFileData>>;
-using TaskIterator = std::vector<std::unique_ptr<TaskArgumentBase>>::iterator;
+using TaskIterator = std::vector<TaskArgumentBase*>::iterator;
 
 /**
  * The interface expected on our Task Arguments
@@ -80,6 +80,7 @@ class TaskArgumentBase {
   virtual TypeVariant getValue() = 0;
   virtual void insert(QString value) = 0;
   virtual void insert(KFileData file) = 0;
+  virtual void remove(TypeVariant value) = 0;
   virtual void setValue(TypeVariant v) = 0;
   virtual bool isContainer() = 0;
   virtual void clear() = 0;
@@ -107,7 +108,16 @@ class TaskArgument : TaskArgumentBase {
    * @param [in] {TaskArgument&&} a The R-value reference to a TaskArgument
    */
   TaskArgument(TaskArgument&& a) :
-    name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+                                   name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+
+  /**
+   * Copy Constructor
+   *
+   * @constructor
+   * @param [in] {TaskArgument&&} a The const reference to a TaskArgument
+   */
+  TaskArgument(const TaskArgument& a) :
+                                        name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
   /**
    * text
    * @returns {QString} The name of the argument
@@ -118,7 +128,9 @@ class TaskArgument : TaskArgumentBase {
    * setValue
    * @param [in] {TypeVariant} new_value The new value for this argument
    */
-  virtual void setValue(TypeVariant new_value) override { value = new_value; }
+  virtual void setValue(TypeVariant new_value) override {
+    value = new_value;
+  }
 
   /**
    * @brief getStringValue
@@ -203,6 +215,39 @@ class TaskArgument : TaskArgumentBase {
     }
   }
 
+  /**
+   * @brief remove
+   * @param value
+   */
+  virtual void remove(TypeVariant unwanted_value) override {
+    if (value.index() == VariantIndex::STRVEC && unwanted_value.index() == VariantIndex::QSTRING) {
+      auto&& container = std::get<VariantIndex::STRVEC>(value);
+      auto value_to_remove = std::get<VariantIndex::QSTRING>(unwanted_value);
+      auto it = std::find_if(container.begin(), container.end(), [&value_to_remove](QString s) {
+        return (s == value_to_remove);
+      });
+      if (it != container.end()) {
+        container.erase(it);
+        return;
+      } else {
+        throw std::out_of_range("Could not find value requested for removal");
+      }
+    } else if (value.index() == VariantIndex::STRVEC && unwanted_value.index() == VariantIndex::FILEVEC) {
+      auto&& container = std::get<VariantIndex::STRVEC>(value);
+      auto value_to_remove = std::get<VariantIndex::QSTRING>(unwanted_value);
+      auto it = std::find_if(container.begin(), container.end(), [&value_to_remove](QString s) {
+        return (s == value_to_remove);
+      });
+      if (it != container.end()) {
+        container.erase(it);
+        return;
+      } else {
+        throw std::out_of_range("Could not find value requested for removal");
+      }
+    }
+    throw std::invalid_argument("The value provided does not match any existing container");
+  }
+
   /**
    * @brief getTypeIndex
    * @return
@@ -217,7 +262,7 @@ class TaskArgument : TaskArgumentBase {
   TypeVariant value;
 };
 
-using TaskArguments = std::vector<std::unique_ptr<TaskArgument>>;
+using TaskArguments = std::vector<TaskArgument*>;
 
 /**
  * The interface expected to be implemented in all Task types
@@ -230,8 +275,10 @@ class Task {
   virtual void setArgument(QString name, TypeVariant arg) = 0;
   virtual void addArgument(QString name, Scheduler::KFileData file) = 0;
   virtual void addArgument(QString name, QString string) = 0;
+  virtual void removeArgument(QString name, TypeVariant arg) = 0;
   virtual const TaskArguments&& getTaskArguments() = 0;
-  virtual const TypeVariant getTaskArgument(QString name) = 0;
+  virtual TaskArgument getTaskArgument(QString name) = 0;
+  virtual const TypeVariant getTaskArgumentValue(QString name) = 0;
   virtual ArgumentValues getArgumentValues() = 0;
   virtual QVector<QString> getArgumentNames() = 0;
   virtual TaskType getType() = 0;

src/client.cpp

@@ -250,25 +250,35 @@ void Client::sendTaskEncoded(Scheduler::Task* task) {
             builder.CreateString(
 /*0*/           getTaskFileInfo(sent_files)),
             builder.CreateString(
-/*1*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("datetime")).toUtf8().constData()}),
+/*1*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("datetime")).toUtf8().constData()}),
             builder.CreateString(
-/*2*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description")).toUtf8().constData()}),
+/*2*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("description")).toUtf8().constData()}),
             builder.CreateString(
-/*3*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags_string")).toUtf8().constData()}),
+/*3*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
             builder.CreateString(
-/*4*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_string")).toUtf8().constData()}),
+/*4*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
             builder.CreateString(
-/*5*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase")).toUtf8().constData()}),
+/*5*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
             builder.CreateString(
-/*6*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("promote_share")).toUtf8().constData()}),
+/*6*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
             builder.CreateString(
-/*7*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("link_in_bio")).toUtf8().constData()}),
-/*8*/           std::get<Scheduler::VariantIndex::BOOLEAN>(task->getTaskArgument("is_video")),
+/*7*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("link_in_bio")).toUtf8().constData()}),
+/*8*/           std::get<Scheduler::VariantIndex::BOOLEAN>(
+                                      task->getTaskArgumentValue("is_video")),
 /*9*/           getSelectedApp(),
             builder.CreateString(
-/*10*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("header")).toUtf8().constData()}),
+/*10*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                       task->getTaskArgumentValue("header")).toUtf8().constData()}),
             builder.CreateString(
-/*11*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("user")).toUtf8().constData()}));
+/*11*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                       task->getTaskArgumentValue("user")).toUtf8().constData()}));
     builder.Finish(ig_task);
 
     uint8_t* encoded_message_buffer = builder.GetBufferPointer();

src/instagram_task.cpp

@@ -1,5 +1,5 @@
 #include <include/task/instagram_task.hpp>
-
+#include <QDebug>
 using namespace Scheduler;
 
 /**
@@ -34,19 +34,19 @@ InstagramTask::InstagramTask() {}
  */
 void InstagramTask::defineTaskArguments() {
   m_arguments.clear();
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("header", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("description", Type::TEXT, TypeVariant{QString{}}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("datetime", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("promote_share", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("link_in_bio", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("hashtags", Type::STRINGVECTOR, QVector<QString>{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("hashtags_string", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("requested_by", Type::STRINGVECTOR, QVector<QString>{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("requested_by_string", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("requested_by_phrase", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("files", Type::FILEVECTOR, QVector<KFileData>{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("user", Type::TEXT, QString{}));
-  m_arguments.emplace_back(std::make_unique<TaskArgument>("is_video", Type::BOOLEAN, bool{}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"header", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"description", Type::TEXT, TypeVariant{QString{}}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"datetime", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"promote_share", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"link_in_bio", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"hashtags", Type::STRINGVECTOR, QVector<QString>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"hashtags_string", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by", Type::STRINGVECTOR, QVector<QString>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by_string", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by_phrase", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"files", Type::FILEVECTOR, QVector<KFileData>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"user", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"is_video", Type::BOOLEAN, bool{}}));
 }
 
 /**
@@ -55,10 +55,12 @@ void InstagramTask::defineTaskArguments() {
  * @param [in] {TypeVariant}  value  The value of the argument
  */
 void InstagramTask::setArgument(QString name, TypeVariant value) {
-  for (const auto& argument : m_arguments) {
+  for (auto&& argument : m_arguments) {
     if (argument->text() == name) {
-      argument->setValue(value);
-      return;
+      if (isIndex(value.index(), VariantIndex::STRVEC)) {
+        argument->setValue(std::get<VariantIndex::STRVEC>(value));
+        return;
+      }
     }
   }
 }
@@ -82,6 +84,29 @@ void InstagramTask::addArgument(QString name, Scheduler::KFileData file) {
   }
 }
 
+/**
+ * @warning This method is used to remove a value to an argument, and can only be used on arguments whose type is a form of container.
+ *
+ * @brief InstagramTask::addArgument
+ *
+ * @param [in] {QString}      name  The name of the argument
+ * @param [in] {TypeVariant}  file  A data structure to be added to a container of files.
+ *                                The KFileData structure contains metadata about a file and
+ *                                its data as a byte array
+ */
+void InstagramTask::removeArgument(QString name, Scheduler::TypeVariant value) {
+  for (auto&& argument : m_arguments) {
+    if (argument->text() == name) {
+      if (argument->isContainer()) {
+        argument->remove(value);
+      } else {
+        argument->clear();
+      }
+      return;
+    }
+  }
+}
+
 /**
  * @warning This method is used to add values to an argument, and can only be used on arguments whose type is a form of container.
  *
@@ -99,13 +124,29 @@ void InstagramTask::addArgument(QString name, QString string) {
   }
 }
 
+
 /**
  * @brief InstagramTask::getTaskArgument
  *
  * @param [in] {QString} name   The name of the argument to retrieve
- * @return [out] {TypeVariant}  The value of the task
+ * @return [out] {TaskArgument}  The argument
+ */
+TaskArgument InstagramTask::getTaskArgument(QString name) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      return *argument;
+    }
+  }
+  return TaskArgument{"None", "None", ""};  // Perhaps we should throw
+}
+
+/**
+ * @brief InstagramTask::getTaskArgumentValue
+ *
+ * @param [in] {QString} name   The name of the argument to retrieve
+ * @return [out] {TypeVariant}  The value of the argument
  */
-const TypeVariant InstagramTask::getTaskArgument(QString name) {
+const TypeVariant InstagramTask::getTaskArgumentValue(QString name) {
   for (const auto& argument : m_arguments) {
     if (argument->text() == name) {
       return argument->getValue();
@@ -203,7 +244,7 @@ void InstagramTask::clear() {
  * @return [out] {bool} Indicates whether the task has files.
  */
 bool InstagramTask::hasFiles() {
-  return !std::get<VariantIndex::FILEVEC>(getTaskArgument("files")).empty();
+  return !std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files")).empty();
 }
 
 /**
@@ -212,7 +253,7 @@ bool InstagramTask::hasFiles() {
  * @return [out] {QVector<KFileData>} A vector of data structures representing file metadata and the file data as bytes.
  */
 const QVector<Scheduler::KFileData> InstagramTask::getFiles() {
-  return std::get<VariantIndex::FILEVEC>(getTaskArgument("files"));
+  return std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files"));
 }
 
 /**
@@ -222,15 +263,15 @@ const QVector<Scheduler::KFileData> InstagramTask::getFiles() {
  *                      perform the task have been met.
  */
 bool InstagramTask::isReady() {
-  auto header_size = std::get<VariantIndex::QSTRING>(getTaskArgument("header")).size();
-  auto description_size = std::get<VariantIndex::QSTRING>(getTaskArgument("description")).size();
-  auto datetime_size = std::get<VariantIndex::QSTRING>(getTaskArgument("datetime")).size();
-  auto promote_share_size = std::get<VariantIndex::QSTRING>(getTaskArgument("promote_share")).size();
-  auto link_in_bio_size = std::get<VariantIndex::QSTRING>(getTaskArgument("link_in_bio")).size();
-  auto hashtags_size = std::get<VariantIndex::QSTRING>(getTaskArgument("hashtags_string")).size();
-  auto requested_by_size = std::get<VariantIndex::QSTRING>(getTaskArgument("requested_by_string")).size();
-  auto hasFiles = std::get<VariantIndex::FILEVEC>(getTaskArgument("files")).size();
-  auto user_size = std::get<VariantIndex::QSTRING>(getTaskArgument("user")).size();
+  auto header_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("header")).size();
+  auto description_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("description")).size();
+  auto datetime_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("datetime")).size();
+  auto promote_share_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("promote_share")).size();
+  auto link_in_bio_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("link_in_bio")).size();
+  auto hashtags_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("hashtags_string")).size();
+  auto requested_by_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("requested_by_string")).size();
+  auto hasFiles = std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files")).size();
+  auto user_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("user")).size();
 
   return header_size > 0 && description_size > 0 && datetime_size > 0 &&
          promote_share_size > 0 && link_in_bio_size > 0 &&