Consider populations during requests

http_server.cpp

 #include "http_server.hpp"
-#include "data_storage.hpp"
 
+#include <algorithm>
+#include <iostream>
 #include <regex>
+#include <unordered_set>
+
+#include "data_storage.hpp"
 
 namespace insite {
 
-HttpServer::HttpServer(web::http::uri address, DataStorage* storage)
-    : http_listener_{address}, storage_(storage) {
+HttpServer::HttpServer(web::http::uri address, DataStorage* storage,
+                       pqxx::connection* database_connection)
+    : http_listener_{address},
+      storage_(storage),
+      database_connection_(database_connection) {
   http_listener_.support([this](web::http::http_request request) {
     if (request.method() == "GET" &&
         request.relative_uri().path() == "/spikes") {
@@ -40,18 +47,38 @@ web::http::http_response HttpServer::GetSpikes(
   const auto parameters = web::uri::split_query(request.request_uri().query());
 
   web::http::http_response response(web::http::status_codes::OK);
-  const auto spikes = storage_->GetSpikes();
-  auto spikes_begin = spikes.begin();
-  auto spikes_end = spikes.end();
+  auto spikes = storage_->GetSpikes();
 
   const auto from = parameters.find("from");
   const auto to = parameters.find("to");
+  const auto population = parameters.find("population");
+
+    std::unordered_set<uint64_t> population_node_ids;
+  if (population != parameters.end()) {
+    pqxx::work txn(*database_connection_);
+    const auto population_node_ids_result = txn.exec(
+        "SELECT id FROM nest_neuron WHERE nest_neuron.population_id = " +
+        population->second);
+    txn.commit();
+
+    population_node_ids.reserve(population_node_ids_result.size());
+
+    for (const auto& node_id : population_node_ids_result) {
+      population_node_ids.insert(node_id[0].as<uint64_t>());
+    }
+
+    spikes.erase(std::remove_if(spikes.begin(), spikes.end(), [&population_node_ids](const Spike& spike) {
+      return population_node_ids.count(spike.gid) == 0;
+    }), spikes.end());
+  }
 
   const auto spike_happened_before = [](const Spike& spike,
                                         double simulation_time) {
     return spike.simulation_time < simulation_time;
   };
 
+  auto spikes_begin = spikes.begin();
+  auto spikes_end = spikes.end();
   if (from != parameters.end()) {
     const auto from_number = std::stoll(from->second);
     spikes_begin = std::lower_bound(spikes.begin(), spikes.end(), from_number,
@@ -64,6 +91,7 @@ web::http::http_response HttpServer::GetSpikes(
                                   spike_happened_before);
   }
 
+
   const auto element_count = spikes_end - spikes_begin;
   web::json::value gids = web::json::value::array(element_count);
   web::json::value simulation_times = web::json::value::array(element_count);
@@ -73,7 +101,10 @@ web::http::http_response HttpServer::GetSpikes(
     for (auto spike = spikes_begin; spike != spikes_end; ++spike, ++index) {
       gids[index] = spike->gid;
       simulation_times[index] = spike->simulation_time;
+
+      std::cout << population_node_ids.count(spike->gid) << " " << gids[index] << "\n";
     }
+    std::cout << std::endl;
   }
 
   response.set_body(web::json::value::object(
@@ -105,38 +136,41 @@ web::http::http_response HttpServer::GetMultimeterMeasurement(
                                   parameter_gids->second.end(), regex, -1};
     std::vector<std::string> filter_gid_strings{it, {}};
     std::transform(filter_gid_strings.begin(), filter_gid_strings.end(),
-      std::back_inserter(filter_gids), [ ] (const std::string& str) { 
-        return std::stoll(str); 
-      });
+                   std::back_inserter(filter_gids),
+                   [](const std::string& str) { return std::stoll(str); });
   }
   std::cout << "Filter GID count: " << filter_gids.size() << "\n";
 
   const auto measurements = storage_->GetMultimeterMeasurements();
   if (measurements.find(multimeter_id) != measurements.end() &&
-      measurements.at(multimeter_id).find(attribute) 
-      != measurements.at(multimeter_id).end()) {
+      measurements.at(multimeter_id).find(attribute) !=
+          measurements.at(multimeter_id).end()) {
     auto& measurement = measurements.at(multimeter_id).at(attribute);
     auto& simulation_times = measurement.simulation_times;
     auto& gids = measurement.gids;
     auto& values = measurement.values;
 
-    auto simulation_times_begin = parameter_from == parameters.end() 
-      ? simulation_times.begin() : std::lower_bound(simulation_times.begin(), 
-      simulation_times.end(), std::stoll(parameter_from->second));
-    auto simulation_times_end = parameter_to == parameters.end() 
-      ? simulation_times.end() : std::lower_bound(simulation_times.begin(), 
-      simulation_times.end(), std::stoll(parameter_to->second));
+    auto simulation_times_begin =
+        parameter_from == parameters.end()
+            ? simulation_times.begin()
+            : std::lower_bound(simulation_times.begin(), simulation_times.end(),
+                               std::stoll(parameter_from->second));
+    auto simulation_times_end =
+        parameter_to == parameters.end()
+            ? simulation_times.end()
+            : std::lower_bound(simulation_times.begin(), simulation_times.end(),
+                               std::stoll(parameter_to->second));
     if (parameter_offset != parameters.end())
       simulation_times_begin += std::stoll(parameter_offset->second);
     if (parameter_limit != parameters.end())
-      simulation_times_end = simulation_times_begin + 
-        std::stoll(parameter_limit->second);
+      simulation_times_end =
+          simulation_times_begin + std::stoll(parameter_limit->second);
     auto simulation_times_subset = std::vector<web::json::value>(
         simulation_times_begin, simulation_times_end);
-    std::size_t simulation_start_index = std::distance(simulation_times.begin(),
-      simulation_times_begin);
-    std::size_t simulation_end_index = std::distance(simulation_times.begin(), 
-      simulation_times_end);
+    std::size_t simulation_start_index =
+        std::distance(simulation_times.begin(), simulation_times_begin);
+    std::size_t simulation_end_index =
+        std::distance(simulation_times.begin(), simulation_times_end);
 
     auto gids_begin = filter_gids.empty() ? gids.begin() : filter_gids.begin();
     auto gids_end = filter_gids.empty() ? gids.end() : filter_gids.end();
@@ -144,7 +178,8 @@ web::http::http_response HttpServer::GetMultimeterMeasurement(
     auto gid_indices = std::vector<std::size_t>();
     if (!filter_gids.empty())
       for (auto& filter_gid : filter_gids)
-        gid_indices.push_back(std::distance(gids.begin(), 
+        gid_indices.push_back(std::distance(
+            gids.begin(),
             std::lower_bound(gids.begin(), gids.end(), filter_gid)));
     else {
       gid_indices.resize(gids.size());

http_server.hpp

@@ -3,6 +3,7 @@
 
 #include <cpprest/http_listener.h>
 #include <string>
+#include <pqxx/pqxx>
 
 namespace insite {
 
@@ -10,11 +11,12 @@ class DataStorage;
 
 class HttpServer {
  public:
-  HttpServer(web::http::uri address, DataStorage* storage);
+  HttpServer(web::http::uri address, DataStorage* storage, pqxx::connection* database_connection);
 
  private:
   web::http::experimental::listener::http_listener http_listener_;
   DataStorage* storage_;
+  pqxx::connection* database_connection_;
 
   web::http::http_response GetCurrentSimulationTime(const web::http::http_request& request);