view nearestaccumulator.h @ 458:913a95f06998 api-inversion

Start using the query state structure.

Actually using it means moving it around in the source code a little
bit, thanks to entanglements.  It'll all be alright on the night.  Now
the accumulator, allowed_keys and exact_evaluation_queue are all part of
the query state, and can therefore be passed around with minimal effort
(and deleted in the appropriate place).

Now a whole bunch of static methods (the callbacks, basically) in
index.cpp can be rewritten as plain old C functions.  The callbacks need
both an adb_t and a query state structure to function (the adb_t to get
at things like lsh_n_point_bits and the track->key table; the qstate to
get at the accumulator and allowed_keys list).

Rearrange audioDB::query a little bit, and mark the beginning and the
end of the putative audiodb_query_spec() API function implementation.

template <class T> class NearestAccumulator : public Accumulator {
public:
  NearestAccumulator();
  ~NearestAccumulator();
  void add_point(adb_result_t *r);
  adb_query_results_t *get_points();
private:
  std::set< adb_result_t, adb_result_triple_lt > *set;
  std::set< adb_result_t, adb_result_qpos_lt > *points;
};

template <class T> NearestAccumulator<T>::NearestAccumulator()
  : set(0), points(0) {
  set = new std::set< adb_result_t, adb_result_triple_lt >;
  points = new std::set< adb_result_t, adb_result_qpos_lt >;
}

template <class T> NearestAccumulator<T>::~NearestAccumulator() {
  if(set) {
    delete set;
  }
  if(points) {
    delete points;
  }
}

template <class T> void NearestAccumulator<T>::add_point(adb_result_t *r) {
  if(!isnan(r->dist)) {
    if(set->find(*r) == set->end()) {
      set->insert(*r);

      std::set< adb_result_t, adb_result_qpos_lt >::iterator it;
      it = points->find(*r);
      if(it == points->end()) {
        points->insert(*r);
      } else if(T()(*(const adb_result_t *)r,(*it))) {
        points->erase(it);
        points->insert(*r);
      }
    }
  }
}

template <class T> adb_query_results_t *NearestAccumulator<T>::get_points() {
  unsigned int nresults = points->size();
  adb_query_results_t *r = (adb_query_results_t *) malloc(sizeof(adb_query_results_t));
  adb_result_t *rs = (adb_result_t *) calloc(nresults, sizeof(adb_result_t));
  r->nresults = nresults;
  r->results = rs;
  std::set< adb_result_t, adb_result_qpos_lt >::iterator it;
  unsigned int k = 0;
  for(it = points->begin(); it != points->end(); it++) {
    rs[k++] = *it;
  }
  return r;
}