314 lines
8.0 KiB
C
314 lines
8.0 KiB
C
/************************************************************************
|
|
* InterVal Index interface
|
|
* NOTE that:
|
|
* (1) There are no overlapping intervals in InterVal Index;
|
|
* (2) Each interval is closed;
|
|
* (3) The interval supports rollback.
|
|
*
|
|
* author: zhengchao@iie.ac.cn tangqi@iie.ac.cn
|
|
* last modify time: 2015-12-04
|
|
*************************************************************************/
|
|
|
|
#ifndef _INTERVAL_INDEX_H_
|
|
#define _INTERVAL_INDEX_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"{
|
|
#endif
|
|
|
|
|
|
#define SIZE_8
|
|
|
|
#ifdef SIZE_8
|
|
typedef unsigned long long OFFSET_TYPE;
|
|
typedef signed long long S_OFFSET_TYPE;
|
|
#else
|
|
typedef unsigned int OFFSET_TYPE;
|
|
typedef signed int S_OFFSET_TYPE;
|
|
#endif
|
|
|
|
|
|
typedef struct{
|
|
}IVI_t;
|
|
|
|
|
|
/**
|
|
* structure of segment
|
|
**/
|
|
typedef struct __IVI_seg_t{
|
|
OFFSET_TYPE left;
|
|
OFFSET_TYPE right;
|
|
void * data;
|
|
}IVI_seg_t;
|
|
|
|
|
|
typedef void IVI_callback_t(IVI_seg_t * seg, void * usr_para);
|
|
|
|
/**
|
|
* Deal with rollback
|
|
* Refering to the approach of Linux's kernel to solute tcp seq rollback
|
|
**/
|
|
static inline int before(OFFSET_TYPE off1, OFFSET_TYPE off2)
|
|
{
|
|
return (S_OFFSET_TYPE)(off1 - off2) < 0;
|
|
}
|
|
#define after(off2, off1) before(off1, off2)
|
|
|
|
static inline int continuous(OFFSET_TYPE prev, OFFSET_TYPE next)
|
|
{
|
|
return ((next - prev) == 1);
|
|
}
|
|
|
|
|
|
IVI_seg_t * IVI_first_seg(IVI_t * handler);
|
|
IVI_seg_t * IVI_last_seg(IVI_t * handler);
|
|
IVI_seg_t * IVI_prev_seg(IVI_seg_t * seg);
|
|
IVI_seg_t * IVI_next_seg(IVI_seg_t * seg);
|
|
IVI_seg_t * IVI_prev_continuous_seg(IVI_seg_t * seg);
|
|
IVI_seg_t * IVI_next_continuous_seg(IVI_seg_t * seg);
|
|
|
|
|
|
/**
|
|
* Relation of two segments
|
|
**/
|
|
typedef enum __Relation_t{
|
|
LEFT_NO_OVERLAP = 1, // |___A___|
|
|
// |___B___|
|
|
|
|
LEFT_OVERLAP, // |___A___|
|
|
// |___B___|
|
|
|
|
CONTAINED, // |___A___|
|
|
// |_____B_____|
|
|
|
|
CONTAIN, // |_____A_____|
|
|
// |___B___|
|
|
|
|
RIGHT_OVERLAP, // |___A___|
|
|
// |___B___|
|
|
|
|
RIGHT_NO_OVERLAP, // |___A___|
|
|
// |___B___|
|
|
|
|
ERROR
|
|
}Relation_t;
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_relative_position
|
|
* Description:
|
|
* Get relative position of given two interval segments
|
|
* Params:
|
|
* seg1: Subject of relation
|
|
* seg2: Object of relation
|
|
* Relation:
|
|
* On success, return the relation of two segments with enum;
|
|
* Else, return ERROR in enum;
|
|
**/
|
|
Relation_t IVI_relative_position(IVI_seg_t * seg1, IVI_seg_t * seg2);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_create
|
|
* Description:
|
|
* Create an InterVal Index
|
|
* Params:
|
|
* void
|
|
* Return:
|
|
* Return a handler of this InterVal Index
|
|
**/
|
|
IVI_t * IVI_create(void);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_destroy
|
|
* Description:
|
|
* Destroy a given InterVal Index's handler
|
|
* Params:
|
|
* handler: The InterVal Index you want to destroy
|
|
* cb: Callback function for user to free data in segement
|
|
* usr_para: User parameter
|
|
* Return:
|
|
* void
|
|
**/
|
|
void IVI_destroy(IVI_t * handler, IVI_callback_t cb, void * usr_para);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_seg_malloc
|
|
* Description:
|
|
* Malloc a segment with given parameters
|
|
* Params:
|
|
* left: Left point of segment
|
|
* right: Right point of segment
|
|
* data: User data
|
|
* Return:
|
|
* Return a pointer of segment structure.
|
|
**/
|
|
IVI_seg_t * IVI_seg_malloc(OFFSET_TYPE left, OFFSET_TYPE right, void * data);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_seg_free
|
|
* Description:
|
|
* Free the memory of given segment
|
|
* Params:
|
|
* seg: The segment that you want to free
|
|
* cb: Callback function for user to free *data in seg
|
|
* usr_para: User parameter for cb
|
|
* Return:
|
|
* void
|
|
**/
|
|
void IVI_seg_free(IVI_seg_t * seg, IVI_callback_t cb, void * usr_para);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_insert
|
|
* Description:
|
|
* Insert a segment to an InterVal Index handler,and the segment
|
|
* MUST not be overlapped with others in handler.
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create
|
|
* seg: A segment that user wants to add. It MUST be created
|
|
* by IVI_seg_malloc.
|
|
* Return:
|
|
* On success, 0 is returned;
|
|
* Else when overlapp occures or error occures, -1 is returned.
|
|
**/
|
|
int IVI_insert(IVI_t * handler, IVI_seg_t * seg);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_remove
|
|
* Description:
|
|
* Remove a given segment from given InterVal Index handler.
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create
|
|
* seg: A segment that user wants to delete. It MUST be created
|
|
* by IVI_seg_malloc.
|
|
* Return:
|
|
* On success, 0 is returned;
|
|
* Else when overlapp occures, -1 is returned.
|
|
**/
|
|
int IVI_remove(IVI_t * handler, IVI_seg_t * seg);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_query
|
|
* Description:
|
|
* Query from given InterVal Index and get the number of segments
|
|
* which are overlapped with given interval, and store those segments
|
|
* in the last parameter.
|
|
* Params:
|
|
* handler: The handler of interval index created by IVI_create
|
|
* left: Left point of given interval
|
|
* right: Right point of given interval
|
|
* segs: An address of a segment pointer array to store those segments which
|
|
* are overlapped with given interval. NOTE that user should not malloc
|
|
* the array, and segs need to be freed by user. The element of *segs
|
|
* MUST not be freed by user.
|
|
* Return:
|
|
* Return the number of segments which are overlapped with given interval
|
|
**/
|
|
int IVI_query(IVI_t * handler, OFFSET_TYPE left, OFFSET_TYPE right, IVI_seg_t *** segs);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_query_continuous
|
|
* Description:
|
|
* Query from interval index handler and get the number of continous segments
|
|
* which are overlapped with given interval.
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create.
|
|
* left: Left point of given interval
|
|
* right: Right point of given interval
|
|
* segs: An address of a segment pointer array to store those segments which
|
|
* are overlapped with given interval. NOTE that user should not malloc
|
|
* the array, and segs need to be freed by user. The element of *segs
|
|
* MUST not be freed by user.
|
|
* Return:
|
|
* Return the number of continous segments which are overlapped with given interval
|
|
**/
|
|
int IVI_query_continuous(IVI_t * handler, OFFSET_TYPE left, OFFSET_TYPE right, IVI_seg_t *** segs);
|
|
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_seg_cnt
|
|
* Description:
|
|
* Get the count of segments in given interval index handler
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create.
|
|
* Return:
|
|
* Return the count of segments in given interval index handler
|
|
**/
|
|
int IVI_seg_cnt(IVI_t * handler);
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_seg_len
|
|
* Description:
|
|
* Get the length of whole segments in given interval index handler
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create.
|
|
* Return:
|
|
* Return the length of whole segments in given interval index handler
|
|
**/
|
|
OFFSET_TYPE IVI_seg_length(IVI_t * handler);
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_mem_occupy
|
|
* Description:
|
|
* Get the memory occupy of given interval index handler
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create.
|
|
* Return:
|
|
* Return the memory occupy of given interval index handler
|
|
**/
|
|
unsigned long long IVI_mem_occupy(IVI_t * handler);
|
|
|
|
|
|
/**
|
|
* Name:
|
|
* IVI_traverse
|
|
* Description:
|
|
* Traverse given InterVal Index and execute given callback function
|
|
* one time for each seg in InterVal Index.
|
|
* Params:
|
|
* handler: The handler of InterVal Index created by IVI_create.
|
|
* IVI_callback_t: Callback function for user to define.
|
|
* usr_para: Parameter user want to pass to callback function.
|
|
* Return:
|
|
* void
|
|
**/
|
|
void IVI_traverse(IVI_t * handler, IVI_callback_t cb, void * usr_para);
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _INTERVAL_INDEX_H_ */
|