libncat.h

/*
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 *  Copyright (C) 2005 Liam Girdwood, Radu Corlan  
 */

#ifndef __LIBNCAT_H
#define __LIBNCAT_H

#ifdef __cplusplus
extern "C" {
#endif
    
#define LNC_PRELOAD                     0x1     
#define LNC_PRECACHE            0x2     
#define LNC_PREGET                      0x4     
#define LNC_CACHE                       0x8         
#define LNC_FLAG_MEM            0x0             
#define LNC_FLAG_CACHE          0x1             
#define LNC_FLAG_LOCAL          0x2             
#define LNC_FLAG_ONLINE         0x3             
typedef struct lnc_library lnc_library;
typedef struct lnc_catalog lnc_catalog;
typedef struct lnc_dataset lnc_dataset;
typedef struct lnc_search lnc_search;
typedef struct lnc_slist lnc_slist;
typedef struct lnc_dlist lnc_dlist;

typedef enum {
        CT_INT,                         
        CT_DOUBLE,                      
        CT_FLOAT,                       
        CT_STRING,                      
        CT_SIGN,                        
        CT_DOUBLE_HMS_HRS,      
        CT_DOUBLE_HMS_MINS, 
        CT_DOUBLE_HMS_SECS, 
        CT_DOUBLE_DMS_DEGS, 
        CT_DOUBLE_DMS_MINS, 
        CT_DOUBLE_DMS_SECS,     
    CT_DOUBLE_MPC,      
        CT_NULL,                        
} lnc_ctype;


typedef enum {
    LNC_OP_AND,     
    LNC_OP_OR       
} lnc_operator;


typedef enum  {
    LNC_COMP_LT,    
    LNC_COMP_GT,    
    LNC_COMP_EQ,    
    LNC_COMP_NE     
} lnc_comparator;

typedef struct {
        unsigned int flags:8;       /* LNC_FLAG_ status flag */
    unsigned int size:24;       /* number of elements in tile */
        void* micro_ta;                         /* ptr to micro tile array or NULL*/    
} lnc_tile_status;

struct ln_equ_posn
{
    double ra;  
    double dec; 
};

#define OBJECT_ID_SIZE          12
#define OBJECT_NAME_SIZE        12

typedef struct {
        unsigned int type:8;                    
        unsigned int oclass:8;                  
        unsigned int reserved:16;               
        char id[OBJECT_ID_SIZE];                
        char name[OBJECT_NAME_SIZE];    
} lnc_astro_object;

typedef struct {
        lnc_astro_object aobject;               
        struct ln_equ_posn posn;                
        float Vmag;                                             
} lnc_deep_object;

typedef struct {
        char* name;                                             
        int records;                                    
        int length;                                             
        char* title;                                    
    lnc_dlist* byte_description;        
} lnc_dset_info;


typedef struct { 
    short start;        
    short end;          
    char* type;         
    char* units;        
    char* label;        
    char* explanation;  
} lnc_dset_byte_desc;

typedef struct {
        char* name;
        lnc_astro_object* base;
        int object_size;
        int (*add_element)(void* object, char* name, lnc_ctype ctype, char* value);
        lnc_ctype (*get_ctype) (void* object, char* field);
        int (*get_offset) (void* object, char* field);
} lnc_object_class;

typedef void (*lnc_progress) (float percent, char* msg, void* data);

typedef void (*lnc_func)(void* data, void* user);

lnc_library* lnc_lib_init(char *remote, char* local);

void lnc_lib_free(lnc_library* lib);

lnc_catalog* lnc_cat_create(lnc_library* lib, char* cclass, char* cnum, 
                                                                double ra_min, double ra_max,
                                                                double dec_min, double dec_max, 
                                                                double mag_faint, double mag_bright, int flags);

lnc_dlist* lnc_cat_query(lnc_catalog* cat);

void lnc_cat_free (lnc_catalog* cat);

const char *lnc_get_version(void);

const char* lnc_get_last_err_msg(void);

int lnc_get_last_err(void);

int lnc_cat_register_class(lnc_object_class* cls);
        
lnc_dataset* lnc_dset_create(lnc_catalog* cat, char* dset_name);

int lnc_dset_init(lnc_dataset* dset, lnc_progress progress, int ra, int dec, int mag, 
                        unsigned int flags);

void lnc_dset_free(lnc_dataset* dset);

int lnc_dset_add_custom_field(lnc_dataset* dset, char* field);

int lnc_dset_set_alt_index(lnc_dataset* dset, char* field, char* alt, int flags);

void lnc_dset_clip_posn (lnc_dataset* dset, double min_ra, double min_dec, 
                                         double max_ra, double max_dec, double faint_mag,
                                         double bright_mag);
                     
void lnc_dset_clip_dist (lnc_dataset* dset, double min_AU, double max_AU);

void lnc_dset_unclip (lnc_dataset* dset);

int lnc_dset_get_objects (lnc_dataset* dset, lnc_progress progress, lnc_slist **results, unsigned int flags); 

void lnc_dset_put_objects (lnc_slist *results);

/* some catalog management functionality to manage memory and access */

int lnc_dset_prune(lnc_dataset* dset);

int lnc_dset_get_size(lnc_dataset* dset);

int lnc_dset_get_object_size(lnc_dataset* dset);

void lnc_dset_set_status_posn (lnc_dataset* dset, double min_ra, double min_dec, 
                                         double max_ra, double max_dec, double faint_mag,
                                         double bright_mag, unsigned int status);

void lnc_dset_set_status_dist (lnc_dataset* dset, double min_AU, double max_AU, 
                                                   unsigned int status);

lnc_tile_status lnc_dset_get_status_posn (lnc_dataset* dset, double ra, double dec, double mag);

lnc_tile_status lnc_dset_get_status_dist (lnc_dataset* dset, double AU);

lnc_ctype lnc_dset_get_field_type(lnc_dataset* dset, char* field);

int lnc_dset_get_field_offset(lnc_dataset* dset, char* field);

int lnc_dset_for_results_do(lnc_slist* res, void(*func)(void* object, void* data), void* data);

typedef int (*lnc_custom_comparator)(void* object);

lnc_search* lnc_search_create(lnc_dataset* dset);

void lnc_search_free(lnc_search* search);

int lnc_search_add_operator(lnc_search* search, lnc_operator op);

int lnc_search_add_comparator(lnc_search* search, char* field, lnc_comparator comp,
                       char* value);
                                           
int lnc_search_add_custom_comparator(lnc_search* search, lnc_custom_comparator comp);                                      

int lnc_search_get_results(lnc_search* search, lnc_progress progress, lnc_slist **result, unsigned int flags); 

void lnc_search_put_results (lnc_slist *results);

int lnc_search_get_hits(lnc_search* search);

int lnc_search_get_tests(lnc_search* search);

lnc_slist* lnc_slist_prepend(lnc_slist* s, void* object);

lnc_slist* lnc_slist_append(lnc_slist* s, void* object);

void lnc_slist_foreach(lnc_slist* sl , lnc_func func, void* user);

void lnc_slist_foreach_free(lnc_slist* sl , lnc_func func, void* user);

lnc_dlist* lnc_dlist_prepend(lnc_dlist* d, void* object);

lnc_dlist* lnc_dlist_append(lnc_dlist* d, void* object);

lnc_dlist* lnc_dlist_head(lnc_dlist* d);

lnc_dlist* lnc_dlist_free_object(lnc_dlist* d, void* object);

void lnc_dlist_foreach(lnc_dlist* dl , lnc_func func, void* user);

void lnc_dlist_foreach_free(lnc_dlist* dl , lnc_func func, void* user);


#ifdef __cplusplus
};
#endif

#endif

---