#ifndef _CASS_H_
#define _CASS_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <values.h>
#include <math.h>

#ifdef __cplusplus
extern "C" {
#endif


extern void __debug (const char *, int, const char *, const char *, ...);

#ifndef __func__
#define __func__ "__func__"
#endif

#define info(...) do { printf(__VA_ARGS__); fflush(stdout); } while (0)
#define warn(...) do { fprintf(stderr, __VA_ARGS__); } while (0)
#define fatal(...) do { fprintf(stderr, __VA_ARGS__); exit(-1); } while (0)
#define debug(...) __debug(__FILE__, __LINE__, __func__, __VA_ARGS__)

#include <cass_type.h>

enum {
    CASS_ERR_UNKNOWN = -9999,
    CASS_ERR_OUTOFMEM,  // following enum will be also negative.
    CASS_ERR_MALFORMATVEC,  
    CASS_ERR_PARAMETER,
    CASS_ERR_IO,
    CASS_ERR_CORRUPTED
    // others.
}; 

const char *cass_strerror (int err);

int cass_init (void);
int cass_cleanup (void);

#include <cass_array.h>
#include <cass_topk.h>
#include <cass_file.h>
#include <cass_matrix.h>
#include <cass_reg.h>
#include <cass_bitmap.h>

enum {
//    CASS_DATAOBJ_IS_VECSETID = 1 << 3,
    CASS_MAPPING      = 1<<3,

    CASS_VECSET_ID_BITMAP = 1 << 4,
    CASS_VECSET_ID_ARRAY = 1 << 5,
};

enum {
    CASS_DATA 		= 0x1,
    CASS_VEC_INDEX	= 0x2,
    CASS_VECSET_INDEX	= 0x4,
    CASS_VEC_SKETCH	= 0x8,
    CASS_VECSET_SKETCH	= 0x10,
    CASS_OUTOFCORE 	= 0x100,
    CASS_SEQUENTIAL	= 0x200
};

enum {
    CASS_READONLY = 1 << 1,
    CASS_EXCL = 1 << 2
};

// hide datalog
/*
typedef struct _cass_datum_t {
    uchar   *data;
    uint32_t size;
    uint32_t ulen;
    uint32_t flags;
} cass_datum_t;
*/

typedef struct _cass_vec_t {
    float weight;
    cass_vecset_id_t parent;
    union {	/* place holder */
	    uchar	data[1];
	    int32_t	int_data[1];
	    float	float_data[1];
//	    double	double_data[0]; -- not supposed to work with 64-bit data
	    chunk_t	bit_data[1];
    } u;
} cass_vec_t;

#define CASS_VEC_HEAD_SIZE	((size_t)(((cass_vec_t *)0)->u.data))


typedef struct _cass_vecset_t {
    uint32_t num_regions;
    cass_vec_id_t start_vecid;
              // Since cass_vec_t is continuously allocated,
              // start_id => start_id + num_regions belongs to the same vecset
} cass_vecset_t;  // Continuously allocated indexed by cass_vecset_id.

enum {
    CASS_NONE = 0,
    CASS_ANY = 0xFFFFFFFFU,

/* cass_vecset_type_t */
    CASS_VECSET_NONE	= 1 << 0,	/* for sketches, which do not store the vecsets */
    CASS_VECSET_SINGLE	= 1 << 1,
    CASS_VECSET_SET	= 1 << 2,

/* cass_vec_type_t */
    CASS_VEC_INT	= 1 << 0,	/* 32bit integer */
    CASS_VEC_FLOAT	= 1 << 1,	/* 32bit float */
    CASS_VEC_BIT	= 1 << 2,	/* bit vector */
    CASS_VEC_QUANT	= 1 << 3,	/* what does QUANT mean? */

/* cass_vecset_dist_t */
    CASS_VECSET_DIST_TYPE_TRIVIAL	= 1 << 0,
    CASS_VECSET_DIST_TYPE_SINGLE	= 1 << 1,
    CASS_VECSET_DIST_TYPE_EMD	= 1 << 2,
 
/* cass_vec_dist_t */
    CASS_VEC_DIST_TYPE_TRIVIAL	= 1 << 1,	/* always return 0 */
    CASS_VEC_DIST_TYPE_ID	= 1 << 2,	/* 0 if exactly the same, 1 otherwise */
    CASS_VEC_DIST_TYPE_L1	= 1 << 3,
    CASS_VEC_DIST_TYPE_L2	= 1 << 4,
    CASS_VEC_DIST_TYPE_MAX	= 1 << 5,
    CASS_VEC_DIST_TYPE_HAMMING	= 1 << 6,
    CASS_VEC_DIST_TYPE_COS	= 1 << 7,
};

typedef struct {
#define CASS_DATASET_VEC	(1 << 0)
#define CASS_DATASET_VECSET	(1 << 1)
#define CASS_DATASET_BOTH	(CASS_DATASET_VEC | CASS_DATASET_VECSET)

/* if CASS_DATASET_VEC only, then the parent id's are not converted when merged*/
    	uint32_t 		flags;
	uint32_t		loaded;
	cass_size_t		vec_size;
	cass_size_t		vec_dim;
	cass_vec_id_t		max_vec;
	cass_vec_id_t		num_vec;
	void			*vec;
	cass_vecset_id_t	max_vecset;
	cass_vecset_id_t	num_vecset;
	cass_vecset_t		*vecset;
} cass_dataset_t;

#define DATASET_VEC(ds, vec_id)	((cass_vec_t *)((char *)(ds)->vec + (vec_id) * (ds)->vec_size))

typedef int (*cass_dataset_map_t) (void *from, void *to, void *param);

int cass_dataset_init (cass_dataset_t *ds, cass_size_t vec_size, cass_size_t vec_dim, uint32_t flags);
/* this function only allocate the space so that ds->max_vec(set) > num_vec(set)
   do not actually change ds->num_vec(set) */
int cass_dataset_grow (cass_dataset_t *ds, cass_size_t num_vecset, cass_size_t num_vec);
int cass_dataset_release (cass_dataset_t *ds);
int cass_dataset_merge (cass_dataset_t *ds, const cass_dataset_t *src, cass_vecset_id_t start, cass_vecset_id_t num, cass_dataset_map_t map, void *map_param);
int cass_dataset_checkpoint (cass_dataset_t *ds, CASS_FILE *);
int cass_dataset_restore (cass_dataset_t *ds, CASS_FILE *);
cass_vecset_id_t cass_dataset_vec2vecset (cass_dataset_t *ds, cass_vec_id_t id);


int cass_dataset_load (cass_dataset_t *ds, CASS_FILE *in, cass_vec_type_t vec_type);
int cass_dataset_dump (cass_dataset_t *ds, CASS_FILE *out);

/* ================ ENVIRONMENT ==================== */

typedef struct _cass_env_t {
    // Internal management data for controlling the whole system 
    // similar to DB_ENV in BDB.
    // Need to hold all the meta data about tables, maps, indexes as well
    // as their checkpoint informations.
    // All the associations.
    uint32_t mode;
    char *base_dir;
    cass_reg_t table;
    cass_reg_t cfg;
    cass_reg_t map;
    cass_reg_t vecset_dist;
    cass_reg_t vec_dist;
} cass_env_t; 

// cass_env functions
// int cass_env_create(cass_env_t **env, uint32_t flags);
int cass_env_open(cass_env_t **env, char *db_home, uint32_t flags); 
      // Automatically recover to a consistent stage in case of crash.
int cass_env_close(cass_env_t *env, uint32_t flags);

int cass_env_errmsg(cass_env_t *env, int error, const char *fmt, ...);

int cass_env_panic(cass_env_t *env, const char *msg); // Can not proceed, fail the system.

int cass_env_checkpoint(cass_env_t *env);

int cass_env_describe (cass_env_t *env, CASS_FILE *);

//int cass_env_restore(cass_env_t *env); 


/* ================ VEC_DIST_CLASS / VECSET_DIST_CLASS ==================== */

typedef cass_dist_t (*cass_vec_dist_func_t) (cass_size_t n, void *, void *, void *);

typedef struct _cass_vec_dist_class {
	char *name;
	cass_vec_type_t vec_type;
	cass_vec_dist_type_t type;
	cass_vec_dist_func_t dist;
	/* void ** is actually cass_vec_dist_t ** */
	int (*describe) (void *, CASS_FILE *);
	int (*construct) (void **, const char *);
	int (*checkpoint) (void *, CASS_FILE *);
	int (*restore) (void **, CASS_FILE *);
	void (*free) (void *);
} cass_vec_dist_class_t;

typedef struct {
	uint32_t refcnt;
	char *name;
	cass_vec_dist_class_t *__class;
	/* private data... */
} cass_vec_dist_t;

#include <cass_dist.h>

extern cass_reg_t cass_vec_dist_class_reg;

static inline int cass_vec_dist_class_init (void)
{
	return cass_reg_init(&cass_vec_dist_class_reg);
}

static inline int cass_vec_dist_class_cleanup (void)
{
	return cass_reg_cleanup(&cass_vec_dist_class_reg);
}

static inline int32_t cass_vec_dist_class_lookup (const char *n)
{
	return cass_reg_lookup(&cass_vec_dist_class_reg, n);
}

static inline int32_t cass_vec_dist_class_find (const cass_vec_dist_class_t *p)
{
	return cass_reg_find(&cass_vec_dist_class_reg, p);
}

static inline cass_vec_dist_class_t *cass_vec_dist_class_get (uint32_t i)
{
	return (cass_vec_dist_class_t *)cass_reg_get(&cass_vec_dist_class_reg, i);
}

static inline int cass_vec_dist_class_add (cass_vec_dist_class_t *p)
{
	return cass_reg_add(&cass_vec_dist_class_reg, p->name, p);
}

typedef cass_dist_t (*cass_vecset_dist_func_t) (cass_dataset_t *, cass_vecset_id_t,
		cass_dataset_t *, cass_vecset_id_t , cass_vec_dist_t *vec_dist, void *);

typedef struct _cass_vecset_dist_class{
	char *name;
	cass_vecset_type_t vecset_type;
	cass_vecset_dist_type_t type;
	cass_vecset_dist_func_t dist;
	/* void ** is actually cass_vecset_dist_t ** */
	int (*describe) (void *, CASS_FILE *);
	int (*construct) (void **, const char *);
	int (*checkpoint) (void *, CASS_FILE *);
	int (*restore) (void **, CASS_FILE *);
	void (*free) (void *);
	/* private data... */
} cass_vecset_dist_class_t;

typedef struct {
	uint32_t refcnt;
	char *name;
	int32_t vec_dist;
	cass_vecset_dist_class_t *__class;
} cass_vecset_dist_t;

extern cass_reg_t cass_vecset_dist_class_reg;

static inline int cass_vecset_dist_class_init (void)
{
	return cass_reg_init(&cass_vecset_dist_class_reg);
}

static inline int cass_vecset_dist_class_cleanup (void)
{
	return cass_reg_cleanup(&cass_vecset_dist_class_reg);
}

static inline int32_t cass_vecset_dist_class_lookup (const char *n)
{
	return cass_reg_lookup(&cass_vecset_dist_class_reg, n);
}

/* find id by pointer */
static inline int32_t cass_vecset_dist_class_find (const cass_vecset_dist_class_t *p)
{
	return cass_reg_find(&cass_vecset_dist_class_reg, p);
}

static inline cass_vecset_dist_class_t *cass_vecset_dist_class_get (uint32_t i)
{
	return (cass_vecset_dist_class_t *)cass_reg_get(&cass_vecset_dist_class_reg, i);
}

static inline int cass_vecset_dist_class_add (cass_vecset_dist_class_t *p)
{
	return cass_reg_add(&cass_vecset_dist_class_reg, p->name, p);
}

/* ================ CONFIG ==================== */

typedef struct _cass_vecset_cfg_t {
    uint32_t refcnt;
    char *name;  // vecset_config can be shared between
                        // different datasets with same feature(eg: color hist)
    cass_vecset_type_t	vecset_type; // TBD
    cass_vec_type_t	vec_type; // float_array, bitvec, vec_quant, etc.
    cass_size_t		vec_dim;
    cass_size_t		vec_size;   // number of bytes
    uint32_t 		flag;  // one flag: data_obj_name can be used as vecset_id.

  //  int32_t vecset_dist_id;
  //  int32_t vec_dist_id;
  //  int data_is_dirty;
  //  int private_data_size;
  //  void *private_data;  // Eg: May include sketch upper/lower bound stuff?
} cass_vecset_cfg_t; // one per vecset type

cass_size_t cass_vec_dim2size (cass_vec_type_t, cass_size_t dim);

int cass_vecset_cfg_describe (cass_vecset_cfg_t *, cass_env_t *, CASS_FILE *);

int cass_vecset_cfg_checkpoint (cass_vecset_cfg_t *vecset_cfg, CASS_FILE *out);

int cass_vecset_cfg_restore (cass_vecset_cfg_t **, CASS_FILE *in);

int cass_vecset_cfg_free (cass_vecset_cfg_t *cfg);

/* ================ MAP ==================== */
struct CKHash_Table_;
typedef struct cass_map_t {
    int magic;
    uint32_t refcnt;
    char *name;
    //    char *dataset_name;   // same dataset can have multiple features.

    struct _cass_env_t *env;    // The containing cass_env.
    uint32_t flag; // id is obj_name.
    ARRAY_TYPE(int32_t) table_ids; //tables that uses the map.

    int loaded;  // Whether mapping is in memory.
    int dirty;

    // Real data, to map vecset_id -> dataobj_name
    ARRAY_TYPE(char *) vtable;
    // Reverse mapping, dataobj_name ->vecset_id
    struct CKHash_Table_ *htable;
} cass_map_t;

// Deal with cass_map_t.
int cass_map_create(cass_map_t **map, cass_env_t *env, char *map_name, uint32_t flag);
     // flag says whether the dataobj name can be treated as id,
     // then translation need no memory overhead.
int cass_map_associate_table(cass_map_t *map, int32_t table_id);
int cass_map_disassociate_table(cass_map_t *map, int32_t table_id);

int cass_map_insert(cass_map_t *map, cass_vecset_id_t *id,
                    char *dataobj_name); // Will return the id assigned.
int cass_map_load(cass_map_t *map);  // bring mapping in-mem.
int cass_map_release(cass_map_t *map);  // release in-mem mapping.

int cass_map_dataobj_to_id(cass_map_t *map, char *dataobj_name, cass_vecset_id_t *id);
int cass_map_id_to_dataobj(cass_map_t *map, cass_vecset_id_t id, char **dataobj_name);

int cass_map_describe(cass_map_t *map, CASS_FILE *);
int cass_map_checkpoint(cass_map_t *map, CASS_FILE *out);
int cass_map_restore(cass_map_t **, cass_env_t *env, CASS_FILE *in);
int cass_map_drop(cass_map_t *map); // destroy on-disk version.
int cass_map_free(cass_map_t *map); // release map struct.

/* ================ QUERY RELATED ==================== */

typedef struct {
	cass_id_t id;
	cass_dist_t dist;
} cass_list_entry_t;

typedef ARRAY_TYPE(cass_list_entry_t) cass_list_t;

QUICKSORT_PROTOTYPE(__cass_list_entry, cass_list_entry_t);

/* see cass_bitmap.h
typedef struct {
	// only work for cass_id_t;
	uint32_t	size;	// size in bits
	uint32_t	count;	// number of non-zero entries 
	uchar		*vec; 	
} cass_bitmap_t;
*/

typedef struct {
	uint32_t flags;
/* flags = combination of the following values */
#define CASS_RESULT_BITMAP	0x1
#define CASS_RESULT_LIST	0x2
#define CASS_RESULT_BITMAPS	0x4
#define CASS_RESULT_LISTS	0x8

#define CASS_RESULT_SORT	0x10
#define CASS_RESULT_DIST	0x20	/* the dist field in list entries are
valid */
#define CASS_RESULT_MALLOC	0x100
#define CASS_RESULT_REALLOC	0x200	/* usermem is not sufficient, memory reallocated */
#define CASS_RESULT_USERMEM	0x400
	union {
	bitmap_t bitmap;
	cass_list_t list;
	ARRAY_TYPE(bitmap_t) bitmaps;
	ARRAY_TYPE(cass_list_t) lists;
	} u;
} cass_result_t;

typedef struct {
	uint32_t flags;	/* the same as the value of cass_result_t.flags,
			soft requirement, hoping the query algorithm will
			return the required format, but not guaranteed. */
	cass_dataset_t	*dataset;	/* the query dataset */
	cass_id_t	vecset_id;	/* and the query vecset_id */

	cass_size_t topk;
	cass_dist_t range;

	const char *extra_params;  // note: we can use more efficient repre if needed.
	cass_result_t *candidate; // NULL means no filter.

	int32_t vec_dist_id;
	int32_t vecset_dist_id;
} cass_query_t;

/* ================ TABLE ==================== */

typedef struct _cass_table {
    uint32_t refcnt;
    char *name;   // Name of the table, (when create/drop, use name)
    char *filename;	// name of the backing storage file

    struct _cass_env_t *env;    // The containing cass_env.
    int32_t parent_id; // table associated with this index.
    int32_t cfg_id;
    int32_t parent_cfg_id;
    int32_t map_id;

    //int32_t default_vec_dist_id;
    //int32_t default_vecset_dist_id;

    ARRAY_TYPE(int32_t) child_ids; // including sketch & index

    // Convention: all cass_table's filename start with "casstb_" + table_name.

    struct _cass_table_opr *opr;  // restored at restore_checkpoint()

/* !!!! loaded & dirty are managed by the cass_table_*** functions, the table
 * opr implementations could use these flags, but should not change them. */

    int loaded;	// as original vecsets_in_memory -- the data are in memoroy 
    int dirty;	// data is dirty
    
    //char *parameters;  // a copy of input paramters, (will be saved in private_data)

    void *__private;  // private data to store index-specific info,

/* for tables keep the following as private data
    cass_vecset_id_t num_vecsets;
    cass_vecset_t *vecsets; // If in memory: array of vecset indexed by
    */
    cass_vecset_cfg_t *cfg;
    cass_vecset_cfg_t *parent_cfg;
    cass_map_t *map;

    ARRAY_TYPE(struct _cass_table *) children; // including sketch & index

} cass_table_t;

typedef struct _cass_table_opr cass_table_opr_t;
/*    table operations */

typedef cass_vecset_cfg_t *cass_table_cfg_t (const char *param);

typedef int cass_table_init_private_t (cass_table_t *table,  // See management section
				const char *param);

typedef int cass_table_opr_describe_t (cass_table_opr_t *table, CASS_FILE *out);

typedef int cass_table_checkpoint_private_t (cass_table_t *table, CASS_FILE *out);
                       // Initiate the checkpoint, upon success,
                       // return the chkpnt_data to store in the
                       // cass_env for checkpointing and future recovery.
                       // Note: this will also checkpoint the meta data for table.
typedef int cass_table_restore_private_t (cass_table_t *table, CASS_FILE *in);                    // This shall also restore the meta data for table.

typedef int cass_table_load_t (cass_table_t *table);  // bring data in mem

typedef int cass_table_release_t (cass_table_t *table);  // release in-mem vecsets.

//typedef int cass_table_insert_t (cass_table_t *table, cass_vecset_id_t id, cass_vecset_t *vecset);

typedef int cass_table_batch_insert_t (cass_table_t *table, cass_dataset_t *dataset, cass_vecset_id_t start, cass_vecset_id_t end);

typedef int cass_table_query_t(cass_table_t *table, 
	cass_query_t *query, cass_result_t *result);

typedef int cass_table_batch_query_t(cass_table_t *table, 
/* the dataset of all the queries should be the same */
	uint32_t count, cass_query_t **queries, cass_result_t **results);

typedef int cass_table_drop_t(cass_table_t *table);
                       // Destroy on-disk datalog.
typedef int cass_table_free_private_t(cass_table_t *table); // free the table struct.

// Note, if data is not in memory, this will trigger on-disk sequential scan.
// Need to add linear scan cursor interface.

typedef char *cass_table_tune_t(cass_table_t *parent, char *extra_input);

struct _cass_table_opr {
    char *name;
    int type;	// CASS_DATA or CASS_SKETCH or CASS_INDEX, CASS_OUTOFCORE, CASS_SEQUENTIAL
    cass_vecset_type_t		vecset_type;
    cass_vec_type_t		vec_type;
    cass_vecset_dist_type_t	dist_vecset;
    cass_vec_dist_type_t	dist_vec;

    cass_table_cfg_t		*cfg;
    cass_table_tune_t		*tune; // a set of function pointers.
    cass_table_init_private_t	*init_private;
//    cass_table_insert_t		*insert;
    cass_table_batch_insert_t	*batch_insert;
    cass_table_query_t		*query;
    cass_table_batch_query_t	*batch_query;
    cass_table_load_t		*load; // load data
    cass_table_release_t	*release; // release data
    cass_table_checkpoint_private_t	*checkpoint_private;
    cass_table_restore_private_t	*restore_private;
    //cass_table_drop_t		*drop;
    cass_table_free_private_t	*free_private;
    cass_table_opr_describe_t	*describe; // load data
};

extern cass_reg_t cass_table_opr_reg;

static inline int cass_table_opr_init (void)
{
	return cass_reg_init(&cass_table_opr_reg);
}

static inline int cass_table_opr_cleanup (void)
{
	return cass_reg_cleanup(&cass_table_opr_reg);
}

static inline int32_t cass_table_opr_lookup (const char *n)
{
	return cass_reg_lookup(&cass_table_opr_reg, n);
}

/* find id by pointer */
static inline int32_t cass_table_opr_find (const cass_table_opr_t *p)
{
	return cass_reg_find(&cass_table_opr_reg, p);
}

static inline cass_table_opr_t *cass_table_opr_get (uint32_t i)
{
	return (cass_table_opr_t *)cass_reg_get(&cass_table_opr_reg, i);
}

static inline int cass_table_opr_add (const char *n, cass_table_opr_t *p)
{
	return cass_reg_add(&cass_table_opr_reg, n, p);
}

int cass_table_create (cass_table_t **table,
				cass_env_t *env,  // See management section
                                char *table_name,
				uint32_t opr_idx,
                                int32_t cfg_id,
                                int32_t parent_id,
				int32_t parent_cfg_id,
                                int32_t map_id,
				char *param);

int cass_table_free(cass_table_t *table);

int cass_table_describe (cass_table_t *, CASS_FILE *);

int cass_table_restore (cass_table_t **, cass_env_t *env, CASS_FILE *in);

int cass_table_checkpoint (cass_table_t *, CASS_FILE *out);

/* This function is called after every table is restored, then all the
 * cfg/map/children ids are converted into pointers, and the corresponding
 * reference counts are incremented, and also, put in the self_id. */
int __cass_table_ref (cass_table_t *);
/* decrement the reference count. */
int __cass_table_unref (cass_table_t *);

int cass_table_import_data(cass_table_t *table, char *fname); 
int cass_table_export_data(cass_table_t *table, char *fname); 

int cass_table_associate (cass_table_t *table, int32_t tbl2_id);

int cass_table_disassociate (cass_table_t *table, int32_t tbl2_id);

cass_table_t *cass_table_parent (cass_table_t *table);

static inline int cass_table_load (cass_table_t *table)
{
	int ret = table->opr->load(table);
	if (ret == 0) table->loaded = 1;
	return ret;
}

static inline int cass_table_release (cass_table_t *table)
{
	int ret =  table->opr->release(table);
	if (ret == 0) table->loaded = 0;
	return ret;
}

//int cass_table_insert (cass_table_t *table, cass_vecset_id_t id, cass_vecset_t *vecset);

int cass_table_batch_insert (cass_table_t *table, cass_dataset_t *dataset, cass_vecset_id_t start, cass_vecset_id_t end);

int cass_table_query (cass_table_t *table,
                           cass_query_t *query, cass_result_t *result);

int cass_table_batch_query (cass_table_t *table, uint32_t count,
                           cass_query_t **queries, cass_result_t **results);

/* ================ UTIL FUNCTIONS ==================== */

int mkpath (char *buf, const char *base, const char *table, const char *ext);

/* non-0 if exist, 0 if not */
int dexist (const char *path); /* dir */
int fexist (const char *path); /* file */

struct raw_private
{
	cass_dataset_t dataset;
};

cass_size_t grow (cass_size_t from, cass_size_t to);

const char *cass_vec_type_name (uint32_t );
const char *cass_vecset_type_name (uint32_t );
const char *cass_vec_dist_type_name (uint32_t );
const char *cass_vecset_dist_type_name (uint32_t );

/* get value from parameter list */
/* Eg., to get from "-N 18 -L 32" the value 18, use param_get_int("-N 18 -L 32",
 * "-N");
 */
int32_t param_get_int (const char *,  const char *, int32_t def /* default */);
float param_get_float (const char *,  const char *, float def /* default */);
int param_get_float_array (const char *,  const char *, cass_size_t *n, float *f /* default */);

extern cass_table_opr_t opr_raw;
extern cass_table_opr_t opr_lsh; 
//extern cass_table_opr_t opr_tree; 

extern cass_vecset_dist_class_t vecset_dist_trivial;
extern cass_vecset_dist_class_t vecset_dist_single;
extern cass_vecset_dist_class_t vecset_dist_emd;
extern cass_vecset_dist_class_t vecset_dist_myemd;

extern cass_vec_dist_class_t vec_dist_trivial;
extern cass_vec_dist_class_t vec_dist_L1_int;
extern cass_vec_dist_class_t vec_dist_L2_int;
extern cass_vec_dist_class_t vec_dist_L1_float;
extern cass_vec_dist_class_t vec_dist_L2_float;
extern cass_vec_dist_class_t vec_dist_hamming;
extern cass_vec_dist_class_t vec_dist_cos_float;


/* the following functions are shared among the sketches */
typedef int (*sketch_func_t) (chunk_t *out, const void *in, void *sketch);
typedef int (*sketch_asym_func_t) (float *out, const void *in, void *sketch);

int __vec_sketch_query(cass_table_t *table, 
                     cass_query_t *query, cass_result_t *result, sketch_func_t sketch, void *param);

int __vec_sketch_query_asym(cass_table_t *table, 
                     cass_query_t *query, cass_result_t *result, sketch_asym_func_t sketch, void *param);

int cass_result_alloc_list (cass_result_t *result, cass_size_t num_regions, cass_size_t topk);

int cass_result_alloc_bitmap (cass_result_t *result, cass_size_t num_regions, cass_size_t size);

int cass_result_merge_bitmaps(cass_result_t *src, cass_result_t *dst); 

int cass_result_free (cass_result_t *);

cass_result_t *
cass_result_merge_lists (cass_result_t *src, cass_dataset_t *ds, int32_t topk);

#ifdef __cplusplus
};
#endif
#endif