partial refactor of argdialog using the new interface of task

changing task to include interface to provide args as strings

include/task/instagram_task.hpp

@@ -4,15 +4,26 @@
 #include <include/task/task.hpp>
 #include <type_traits>
 
+namespace Args {
+const QString HEADER_TYPE = "header";
+const QString DESCRIPTION_TYPE = "description";
+const QString HASHTAG_TYPE = "hashtag";
+const QString PROMOTE_TYPE = "promote/share";
+const QString LINK_BIO_TYPE = "link/bio";
+const QString REQUESTED_BY_TYPE = "requested by";
+}  // namespace Args
+
 class InstagramTask : public Scheduler::Task {
  public:
+  virtual void defineTaskArguments() override;
+  virtual const Scheduler::TaskArguments getTaskArguments() override;
+  virtual Scheduler::TypeVariant getTaskArgument(QString name) override;
+  virtual Scheduler::ArgumentValues getArgumentValues() override;
+  virtual void setArgument(QString name, Scheduler::TypeVariant arg) override;
   virtual bool isReady() override;
   virtual void clear() override;
-  virtual const Scheduler::TaskArguments getTaskArguments() override;
-  virtual void defineTaskArguments() override;
+  virtual void setDefaultValues() override;
   virtual ~InstagramTask() override;
-  template <typename T>
-  void setArgument(QString name, T arg);
 
  private:
   Scheduler::TaskArguments m_arguments;

include/task/task.hpp

@@ -3,6 +3,7 @@
 
 #include <QQueue>
 #include <QString>
+#include <QVector>
 #include <memory>
 #include <variant>
 #include <vector>
@@ -40,6 +41,16 @@ static constexpr const char* DATETIME = "DateTime";
 static constexpr const char* BOOLEAN = "Boolean";
 }  // namespace Type
 
+namespace VariantIndex {
+static const uint8_t BOOLEAN = 0;
+static const uint8_t INTEGER = 1;
+static const uint8_t QSTRING = 2;
+static const uint8_t STRVEC = 3;
+static const uint8_t FILEVEC = 4;
+}  // namespace VariantIndex
+
+inline bool isIndex(uint8_t v, uint8_t i) { return v == i; }
+
 /**
  * Forward Declarations
  */
@@ -50,18 +61,23 @@ class Task;
  * Aliases
  */
 using ArgumentType = const char*;
-using TypeVariant = std::variant<QString, bool, std::vector<std::string>, std::vector<KFileData>>;
+using TypeVariant = std::variant<bool, int, QString, QVector<QString>, std::vector<KFileData>>;
 using TaskIterator = std::vector<std::unique_ptr<TaskArgumentBase>>::iterator;
 using TaskArguments = std::vector<std::unique_ptr<TaskArgumentBase>>;
 using TaskQueue = QQueue<Task>;
+using ArgumentValues = QVector<const QString>;
 
 /**
  * The interface expected on our Task Arguments
  */
 class TaskArgumentBase {
  public:
-  virtual QString text() const = 0;
   virtual void setValue(TypeVariant v) = 0;
+  virtual TypeVariant getValue() = 0;
+  virtual const QString text() = 0;
+  virtual void clear() = 0;
+  virtual const QString getStringValue() = 0;
+  virtual bool isContainer() = 0;
 };
 
 /**
@@ -70,7 +86,7 @@ class TaskArgumentBase {
  * A templated class providing a generic way for handling arguments whose types can be one from the set defined
  * by our TypeVariant alias
  */
-template <typename T>
+template <typename T = TypeVariant>
 class TaskArgument : TaskArgumentBase {
  public:
   TaskArgument(QString n, ArgumentType t, T _value) {
@@ -89,7 +105,7 @@ class TaskArgument : TaskArgumentBase {
    * text
    * @returns {QString} The name of the argument
    */
-  virtual QString text() const { return name; }
+  virtual const QString text() { return name; }
 
   /**
    * setValue
@@ -97,10 +113,40 @@ class TaskArgument : TaskArgumentBase {
    */
   virtual void setValue(TypeVariant new_value) override { value = new_value; }
 
+  virtual const QString getStringValue() override {
+    if (isIndex(value.index(), VariantIndex::QSTRING)) {
+      return value;
+    } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
+      return QString::number(value);
+    } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
+      return QString::number(value);
+    }
+  }
+
+  virtual TypeVariant getValue() override { return std::get<value.index()>(value); }
+
+  virtual void clear() override {
+    if (isIndex(value.index(), VariantIndex::STRVEC)) {
+      std::get<VariantIndex::STRVEC>(value).clear();
+    } else if (isIndex(value.index(), VariantIndex::FILEVEC)) {
+      std::get<VariantIndex::FILEVEC>(value).clear();
+    } else if (isIndex(value.index(), VariantIndex::QSTRING)) {
+      std::get<VariantIndex::QSTRING>(value).clear();
+    } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
+      std::get<VariantIndex::INTEGER>(value) = 0;
+    } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
+      std::get<VariantIndex::STRVEC>(value) = false;
+    }
+  }
+
+  virtual bool isContainer() override {
+    return (isIndex(value.index(), VariantIndex::STRVEC) || isIndex(value.index(), VariantIndex::FILEVEC));
+  }
+
  private:
   QString name;
   ArgumentType type;
-  T value;
+  TypeVariant value;
 };
 
 /**
@@ -108,8 +154,12 @@ class TaskArgument : TaskArgumentBase {
  */
 class Task {
  public:
-  virtual void defineTaskArguments() = 0;
+  virtual void setArgument(QString name, TypeVariant arg) = 0;
   virtual const TaskArguments getTaskArguments() = 0;
+  virtual TypeVariant getTaskArgument(QString name) = 0;
+  virtual ArgumentValues getArgumentValues() = 0;
+  virtual void defineTaskArguments() = 0;
+  virtual void setDefaultValues() = 0;
   virtual bool isReady() = 0;
   virtual void clear() = 0;
   virtual ~Task(){};

src/argdialog.cpp

@@ -133,30 +133,20 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
 }
 
 void ArgDialog::setTaskArguments() {
-  m_task->clear();
-  std::string hashtags{};
-  for (const auto &tag : m_ig_post.hashtags) {
+  QString hashtags{};
+  for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("hashtags"))) {
     hashtags += "#" + tag + " ";
   }
-  hashtags.pop_back();
-  std::string requested_by{};
-  for (const auto &name : m_ig_post.requested_by) {
+  hashtags.chop(1);
+  QString requested_by{};
+  for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("requested_by"))) {
     requested_by += "@" + name + "";
   }
   if (m_ig_post.requested_by.size() > 1) {
-    requested_by.pop_back();
+    requested_by.chop(1);
   }
-
-  m_task->setArgument<QString>("datetime", m_ig_post.datetime);
-  m_task->setArgument<QString>("description", m_ig_post.description);
-  m_task->setArgument<QString>("hashtags", hashtags);
-  m_task->setArgument<QString>("requested_by", requested_by);
-  m_task->setArgument<QString>("requested_by_phrase", m_ig_post.requested_by_phrase);
-  m_task->setArgument<QString>("promote_share", m_ig_post.promote_share);
-  m_task->setArgument<QString>("link_in_bio", m_ig_post.link_in_bio);
-  m_task->setArgument<QString>("is_video", std::to_string(m_ig_post.is_video));
-  m_task->setArgument<QString>("header", m_ig_post.header);
-  m_task->setArgument<QString>("user", m_ig_post.user);
+  m_task->setArgument("hashtags", hashtags);
+  m_task->setArgument("requested_by", requested_by);
 }
 
 void ArgDialog::addItem(QString value, QString type) {
@@ -202,19 +192,12 @@ void ArgDialog::addFile(QString path) {
 }
 
 void ArgDialog::clearPost() {
-  m_ig_post.files.clear();
-  m_ig_post.header = "Learn to speak like native Korean speakers 🙆‍♀️🇰🇷";
   QDateTime date_time = QDateTime::currentDateTime();
   ui->dateTime->setDateTime(date_time);
-  m_ig_post.datetime = date_time.toTime_t();
-  m_ig_post.hashtags.clear();
-  m_ig_post.description = "";
-  m_ig_post.link_in_bio = "Subscribe to my YouTube channel (link 🔗in bio) to learn more about "
-                          "Korean language and culture ❤";
-  m_ig_post.requested_by.clear();
-  m_ig_post.promote_share = "Share the post through IG story if you enjoy the phrase 🙋‍♀️";
-  m_ig_post.requested_by_phrase = "The phrase was requested by ";
-  m_ig_post.user = ui->user->currentText().toUtf8().constData();
+  m_task->clear();
+  m_task->setDefaultValues();
+  m_task->setArgument("datetime", date_time.toString());
+  m_task->setArgument("user", ui->user->currentText());
   ui->argType->setCurrentIndex(0);
   ui->argList->setRowCount(0);
 }

src/instagram_task.cpp

@@ -2,6 +2,20 @@
 
 using namespace Scheduler;
 
+namespace TaskIndex {
+static const uint8_t HEADER = 0;
+static const uint8_t DESCRIPTION = 1;
+static const uint8_t DATETIME = 2;
+static const uint8_t PROMOTE_SHARE = 3;
+static const uint8_t LINK_IN_BIO = 4;
+static const uint8_t HASHTAGS = 5;
+static const uint8_t REQUESTED_BY = 6;
+static const uint8_t REQUESTED_BY_PHRASE = 7;
+static const uint8_t FILES = 8;
+static const uint8_t USER = 9;
+static const uint8_t IS_VIDEO = 10;
+}  // namespace TaskIndex
+
 void InstagramTask::defineTaskArguments() {
   std::vector<std::unique_ptr<TaskArgumentBase>> args{};
   args.emplace_back(std::make_unique<TaskArgument<QString>>("header", Type::TEXT, QString{}));
@@ -23,17 +37,55 @@ void InstagramTask::defineTaskArguments() {
 
 const TaskArguments InstagramTask::getTaskArguments() { return m_arguments; }
 
-template <typename T>
-void InstagramTask::setArgument(QString name, T value) {
-  if constexpr (std::is_same_v<T, QString>) {
-    TaskIterator it =
-        std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
-    it->get()->setValue(value);
+void InstagramTask::setArgument(QString name, TypeVariant value) {
+  TaskIterator it =
+      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
+  if (it != m_arguments.end()) {
+    if (isIndex(value.index(), VariantIndex::QSTRING)) {
+      it->get()->setValue(value);
+    } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
+      it->get()->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
+    } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
+      it->get()->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
+    } else {
+      // Could not set argument value
+      // TODO: Log here
+    }
+  }
+}
+
+TypeVariant InstagramTask::getTaskArgument(QString name) {
+  TaskIterator it =
+      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
+  if (it != m_arguments.end()) {
+    return it->get()->getValue();
+  }
+  return "";  // Perhaps we should throw
+}
+
+ArgumentValues InstagramTask::getArgumentValues() {
+  ArgumentValues values{static_cast<int>(m_arguments.size())};
+  for (const auto& argument : m_arguments) {
+    if (!argument->isContainer()) {
+      values.push_back(argument->getStringValue());
+    }
   }
+  return values;
+}
+
+void InstagramTask::setDefaultValues() {
+  m_arguments.at(TaskIndex::HEADER)->setValue("Learn to speak like native Korean speakers 🙆‍♀️🇰🇷");
+  m_arguments.at(TaskIndex::PROMOTE_SHARE)
+      ->setValue("Share the post through IG story if you enjoy the phrase 🙋‍♀️");
+  m_arguments.at(TaskIndex::LINK_IN_BIO)
+      ->setValue("Subscribe to my YouTube channel (link 🔗in bio) to learn more about Korean language and culture ❤");
+  m_arguments.at(TaskIndex::REQUESTED_BY_PHRASE)->setValue("The phrase was requested by ");
 }
 
 void InstagramTask::clear() {
-  // remove all arg values
+  for (const auto& argument : m_arguments) {
+    argument->clear();
+  }
 }
 
 InstagramTask::~InstagramTask() {}