comparison query.cpp @ 473:b2fd8113d8bc api-inversion

const declarations for some API arguments.

This should make it slightly clearer whose responsibility (the user's)
it is to manage the memory pointed to by the corresponding arguments.
Suggested by Chris Cannam.

 #include "audioDB.h"
 #include "audioDB-internals.h"
 #include "accumulators.h"
 
-bool audiodb_powers_acceptable(adb_query_refine_t *r, double p1, double p2) {
+bool audiodb_powers_acceptable(const adb_query_refine_t *r, double p1, double p2) {
   if (r->flags & ADB_REFINE_ABSOLUTE_THRESHOLD) {
     if ((p1 < r->absolute_threshold) || (p2 < r->absolute_threshold)) {
       return false;
     }
   }

     }
   }
   return true;
 }
 
-adb_query_results_t *audiodb_query_spec(adb_t *adb, adb_query_spec_t *qspec) {
+adb_query_results_t *audiodb_query_spec(adb_t *adb, const adb_query_spec_t *qspec) {
   adb_qstate_internal_t qstate = {0};
   qstate.allowed_keys = new std::set<std::string>;
   adb_query_results_t *results;
   if(qspec->refine.flags & ADB_REFINE_INCLUDE_KEYLIST) {
     for(unsigned int k = 0; k < qspec->refine.include.nkeys; k++) {

   if(qstate.allowed_keys)
     delete qstate.allowed_keys;
   return NULL;
 }
 
-int audiodb_query_free_results(adb_t *adb, adb_query_spec_t *spec, adb_query_results_t *rs) {
+int audiodb_query_free_results(adb_t *adb, const adb_query_spec_t *spec, adb_query_results_t *rs) {
   free(rs->results);
   free(rs);
   return 0;
 }
 
-static void audiodb_initialize_arrays(adb_t *adb, adb_query_spec_t *spec, int track, unsigned int numVectors, double *query, double *data_buffer, double **D, double **DD) {
+static void audiodb_initialize_arrays(adb_t *adb, const adb_query_spec_t *spec, int track, unsigned int numVectors, double *query, double *data_buffer, double **D, double **DD) {
   unsigned int j, k, l, w;
   double *dp, *qp, *sp;
 
   const unsigned HOP_SIZE = spec->refine.hopsize;
   const unsigned wL = spec->qid.sequence_length;

   qpointers->l2norm = qpointers->l2norm_data;
   qpointers->power = qpointers->power_data;
   return 0;
 }
 
-int audiodb_query_spec_qpointers(adb_t *adb, adb_query_spec_t *spec, double **vector_data, double **vector, adb_qpointers_internal_t *qpointers) {
+int audiodb_query_spec_qpointers(adb_t *adb, const adb_query_spec_t *spec, double **vector_data, double **vector, adb_qpointers_internal_t *qpointers) {
   adb_datum_t *datum;
   adb_datum_t d = {0};
   uint32_t sequence_length;
   uint32_t sequence_start;
 

   }
 
   return 0;
 }
 
-static int audiodb_set_up_dbpointers(adb_t *adb, adb_query_spec_t *spec, adb_qpointers_internal_t *dbpointers) {
+static int audiodb_set_up_dbpointers(adb_t *adb, const adb_query_spec_t *spec, adb_qpointers_internal_t *dbpointers) {
   uint32_t nvectors = adb->header->length / (adb->header->dim * sizeof(double));
   uint32_t sequence_length = spec->qid.sequence_length;
 
   bool using_power = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
   bool using_times = spec->refine.flags & ADB_REFINE_DURATION_RATIO;

   }
   return 1;
   
 }
 
-int audiodb_query_queue_loop(adb_t *adb, adb_query_spec_t *spec, adb_qstate_internal_t *qstate, double *query, adb_qpointers_internal_t *qpointers) {
+int audiodb_query_queue_loop(adb_t *adb, const adb_query_spec_t *spec, adb_qstate_internal_t *qstate, double *query, adb_qpointers_internal_t *qpointers) {
   adb_qpointers_internal_t dbpointers = {0};
 
   uint32_t sequence_length = spec->qid.sequence_length;
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 

   SAFE_DELETE_ARRAY(dbpointers.mean_duration);
   delete qstate->exact_evaluation_queue;
   return 0;
 }
 
-int audiodb_query_loop(adb_t *adb, adb_query_spec_t *spec, adb_qstate_internal_t *qstate) {
+int audiodb_query_loop(adb_t *adb, const adb_query_spec_t *spec, adb_qstate_internal_t *qstate) {
   
   double *query, *query_data;
   adb_qpointers_internal_t qpointers = {0}, dbpointers = {0};
 
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);