IAggregator.h

Go to the documentation of this file.

//
// Created by Nico Schäfer on 10/6/17.
//
 
#ifndef JODA_IAGGREGATOR_H
#define JODA_IAGGREGATOR_H
#include <joda/concurrency/Queue.h>
#include <joda/query/values/IValueProvider.h>
#include <rapidjson/allocators.h>
#include <rapidjson/fwd.h>
 
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include "joda/misc/infix_iterator.h"
 
namespace joda::query {
class IAggregator {
 public:
  IAggregator(const std::string &toPointer,
              std::vector<std::unique_ptr<IValueProvider>> &&params)
      : toPointer(toPointer), params(std::move(params)) {
    for (auto &param : this->params) {
      IValueProvider::replaceConstSubexpressions(param);
    }
  }
  IAggregator(IAggregator const &) = delete;
  void operator=(IAggregator const &x) = delete;
 
  virtual ~IAggregator() = default;
 
  virtual void accumulate(const RapidJsonDocument &json,
                          RJMemoryPoolAlloc &alloc) = 0;
 
  /*
   * Merge (Merges two instances)
   */
  virtual void merge(IAggregator *other) = 0;
 
  /*
   * Terminators (Terminate and collect data. Only called once)
   */
  virtual RJValue terminate(RJMemoryPoolAlloc &alloc) = 0;
 
  virtual std::unique_ptr<IAggregator> duplicate() const = 0;
 
  virtual 
      const std::string &
      getDestPointer() const {
    return toPointer;
  }
 
  virtual 
      const std::string
      getName() const = 0;
 
  virtual std::vector<std::string> getAttributes() const {
    std::vector<std::string> ret;
    for (const auto &param : params) {
      param->getAttributes(ret);
    }
    return ret;
  };
 
  std::string getParameterStringRepresentation() const {
    std::vector<std::string> pars;
    for (auto &&param : params) {
      pars.push_back(param->toString());
    }
    std::stringstream ss;
    std::move(std::begin(pars), std::end(pars),
              infix_ostream_iterator<std::string>(ss, ", "));
    return ss.str();
  }
 
  /*
   * Returns a string representation of the aggregator
   */
  virtual std::string toString() const {
    return "'" + toPointer + "':" + getName() + "(" +
           getParameterStringRepresentation() + ")";
  };
 
 protected:
  std::string toPointer;
  std::vector<std::unique_ptr<IValueProvider>> params;
 
  void checkParamSize(unsigned int expected) {
    if (params.size() != expected) {
      throw WrongParameterCountException(params.size(), expected, getName());
    }
  }
 
  void checkMinParamSize(unsigned int expected) {
    if (params.size() < expected) {
      throw WrongParameterCountException(params.size(), expected, getName(),
                                         true);
    }
  }
 
  void checkParamType(unsigned int i, IValueType expected) {
    if (!(params[i]->isAny() || params[i]->getReturnType() == expected)) {
      throw WrongParameterTypeException(i, expected, getName());
    }
  }
 
  void checkOptionalParamType(unsigned int i, IValueType expected) {
    if(params.size() < i+1) {
      return;
    }
    if (!(params[i]->isAny() || params[i]->getReturnType() == expected)) {
      throw WrongParameterTypeException(i, expected, getName());
    }
  }
 
  std::vector<std::unique_ptr<IValueProvider>> duplicateParameters() const {
    std::vector<std::unique_ptr<IValueProvider>> ret;
    for (auto &&param : params) {
      ret.push_back(param->duplicate());
    }
    return ret;
  }
};
 
// Aggregator Queue
struct JODA_AGGREGATOR_QUEUE {
  typedef std::unique_ptr<IAggregator> payload_t;
  typedef JODA_SHARED_QUEUE<payload_t> queue_t;
 
  static std::unique_ptr<queue_t> getQueue() {
    return std::make_unique<queue_t>();
  }
  static std::unique_ptr<queue_t> getQueue(size_t minCapacity,
                                           size_t maxProducers) {
    return std::make_unique<queue_t>(minCapacity, maxProducers);
  }
};
 
typedef JODA_AGGREGATOR_QUEUE AggregatorQueue;
}  // namespace joda::query
 
#endif  // JODA_IAGGREGATOR_H