Arguments.h

Go to the documentation of this file.

#ifndef LINTEL_ARGUMENTS_H
#define LINTEL_ARGUMENTS_H
 
#include <map>
#include <ostream>
#include <string>
#include <vector>
 
#include "lintel/core/exceptions/SQLException.h"
#include "lintel/core/persistence/ConnectionType.h"
#include "lintel/core/persistence/Serialization.h"
#include "lintel/core/services/StringifyService.h"
 
namespace lintel {
namespace db {
  class Argument
  {
  private:
    std::string m_value;
    std::string m_name;
    db::ConnectionType m_connectionType;
 
  public:
    Argument(std::string value, std::string name);
 
    [[nodiscard]] const std::string &getValue() const;
 
    [[nodiscard]] const std::string &getName() const;
 
    void setConnectionType(ConnectionType connectionType);
 
    template<typename TYPE> TYPE getValue() const
    {
      switch (m_connectionType) {
      case ConnectionType::PostgreSQL:
        return postgresql::Serialization<TYPE>::deserialize(m_value);
      case ConnectionType::SQLite:
        return sqlite::Serialization<TYPE>::deserialize(m_value);
      case ConnectionType::UNDEFINED:
        return StringifyService<TYPE>::deserializeFromString(m_value);
      default:
        // Reached for an enumerator outside ConnectionType::Value, e.g. from a corrupt or
        // foreign configuration. Without this the function ran off its end (undefined
        // behaviour, CodeQL cpp/missing-return).
        throw db::SQLException("Unknown connection type " + std::to_string(static_cast<int>(m_connectionType)));
      }
    }
 
    friend std::ostream &operator<<(std::ostream &os, const db::Argument &argument);
  };
 
  class Arguments
  {
  private:
    // members
    std::vector<Argument> m_arguments;
    std::map<std::string, Argument> m_argumentsMap;
    ConnectionType m_connectionType;
 
    // iterator classes
    class Iterator
      : public std::iterator<std::random_access_iterator_tag, Argument, std::ptrdiff_t, Argument *, Argument &>
    {
    private:
      Arguments &m_arguments;
      std::size_t m_pos;
 
    public:
      explicit Iterator(Arguments &arguments, bool end = false)
        : m_arguments(arguments), m_pos(end ? static_cast<std::size_t>(m_arguments.size()) : 0)
      {}
 
      Iterator &operator++()
      {
        ++m_pos;
        return *this;
      }
 
      const Iterator operator++(int)
      {
        Iterator tmp = *this;
        ++m_pos;
        return tmp;
      }
 
      bool operator==(Iterator other) const { return m_pos == other.m_pos; }
 
      bool operator!=(Iterator other) const { return !(*this == other); }
 
      reference operator*() { return m_arguments.of(m_pos); }
    };
 
    class ConstIterator
      : public std::
          iterator<std::random_access_iterator_tag, Argument, std::ptrdiff_t, const Argument *, const Argument &>
    {
    private:
      const Arguments &m_arguments;
      std::size_t m_pos;
 
    public:
      explicit ConstIterator(const Arguments &arguments, bool end = false)
        : m_arguments(arguments), m_pos(end ? static_cast<std::size_t>(m_arguments.size()) : 0)
      {}
 
      ConstIterator &operator++()
      {
        ++m_pos;
        return *this;
      }
 
      const ConstIterator operator++(int)
      {
        ConstIterator tmp = *this;
        ++m_pos;
        return tmp;
      }
 
      bool operator==(ConstIterator other) const { return m_pos == other.m_pos; }
 
      bool operator!=(ConstIterator other) const { return !(*this == other); }
 
      reference operator*() const { return m_arguments.of(m_pos); }
    };
 
  public:
    explicit Arguments(ConnectionType connectionType);
 
    void add(Argument &argument);
 
    [[nodiscard]] std::size_t size() const;
 
    [[nodiscard]] bool empty() const;
 
    Argument &of(std::size_t iterator);
 
    [[nodiscard]] const Argument &of(std::size_t iterator) const;
 
    [[nodiscard]] const Argument &of(const std::string &name) const;
 
    Iterator begin() { return Iterator(*this); }
 
    Iterator end() { return Iterator(*this, true); }
 
    [[nodiscard]] ConstIterator begin() const { return ConstIterator(*this); }
 
    [[nodiscard]] ConstIterator end() const { return ConstIterator(*this, true); }
  };
};// namespace db
 
}// namespace lintel
#endif// LINTEL_ARGUMENTS_H