Result.h

Go to the documentation of this file.

#ifndef LINTEL_RESULT_H
#define LINTEL_RESULT_H
 
#include <iterator>
#include <string>
 
#include "lintel/core/persistence/Arguments.h"
#include "lintel/core/persistence/Connection.h"
#include "lintel/core/persistence/postgresql/Result.h"
#include "lintel/core/persistence/sqlite3/Result.h"
 
namespace lintel {
namespace db {
  class Result
  {
  private:
    std::shared_ptr<postgresql::Result> m_result = nullptr;
    std::shared_ptr<sqlite::Result> m_resultSQLite = nullptr;
 
  public:
    class Iterator
      : public std::iterator<std::random_access_iterator_tag, Arguments, std::ptrdiff_t, Arguments *, Arguments &>
    {
    private:
      Result &m_result;
      std::size_t m_pos;
 
    public:
      explicit Iterator(Result &result, bool end = false)
        : m_result(result), m_pos(end ? static_cast<std::size_t>(m_result.getSize()) : 0)
      {}
 
      Iterator &operator++()
      {
        ++m_pos;
        return *this;
      }
 
      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_result.of(m_pos); }
    };
 
    class ConstIterator
      : public std::
          iterator<std::random_access_iterator_tag, Arguments, std::ptrdiff_t, const Arguments *, const Arguments &>
    {
    private:
      const Result &m_result;
      std::size_t m_pos;
 
    public:
      explicit ConstIterator(const Result &result, bool end = false)
        : m_result(result), m_pos(end ? static_cast<std::size_t>(m_result.getSize()) : 0)
      {}
 
      ConstIterator &operator++()
      {
        ++m_pos;
        return *this;
      }
 
      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_result.of(m_pos); }
    };
 
    Iterator begin() { return Iterator(*this); }
 
    Iterator end() { return Iterator(*this, true); }
 
    ConstIterator begin() const { return ConstIterator(*this); }
 
    ConstIterator end() const { return ConstIterator(*this, true); }
 
    Result() = default;
 
    ~Result();
 
    explicit Result(std::shared_ptr<postgresql::Result> result);
 
    explicit Result(std::shared_ptr<sqlite::Result> result);
 
    [[nodiscard]] std::string getValue(int row, int attribute) const;
 
    [[nodiscard]] Arguments &of(std::size_t pos);
 
    [[nodiscard]] const Arguments &of(std::size_t pos) const;
 
    [[nodiscard]] int getNumOfAttributes() const;
 
    [[nodiscard]] int getSize() const;
  };
}// namespace db
 
}// namespace lintel
#endif// LINTEL_RESULT_H