hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleaned up ase_sll_t

Browse Source
This commit is contained in:
hyung-hwan 2008-09-30 01:11:08 +00:00
parent 6269382655
commit f3d022d4ea
5 changed files with 251 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ase/doc/robodoc.rc
View File

@ -26,6 +26,7 @@ ignore files:
.svn .svn
headertypes: headertypes:
o "Overview" robo_overview 0 o "Overview" robo_overview 0
b "Callbacks" robo_callbacks 1
options: options:
--nosort --nosort
--cmode --cmode

45
ase/include/ase/cmn/map.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: map.h 391 2008-09-27 09:51:23Z baconevi $ * $Id: map.h 397 2008-09-29 07:11:08Z baconevi $
* *
* {License} * {License}
*/ */
@ -31,9 +31,16 @@ enum ase_map_walk_t
ASE_MAP_WALK_FORWARD = 1 ASE_MAP_WALK_FORWARD = 1
}; };
enum ase_map_id_t
{
ASE_MAP_KEY = 0,
ASE_MAP_VAL = 1
};
typedef struct ase_map_t ase_map_t; typedef struct ase_map_t ase_map_t;
typedef struct ase_map_pair_t ase_map_pair_t; typedef struct ase_map_pair_t ase_map_pair_t;
typedef enum ase_map_walk_t ase_map_walk_t; typedef enum ase_map_walk_t ase_map_walk_t;
typedef enum ase_map_id_t ase_map_id_t;
/* data copier */ /* data copier */
typedef void* (*ase_map_copier_t) ( typedef void* (*ase_map_copier_t) (
@ -166,11 +173,6 @@ struct ase_map_t
}; };
/******/ /******/
enum ase_map_id_t
{
ASE_MAP_KEY = 0,
ASE_MAP_VAL = 1
};
#define ASE_MAP_COPIER_INLINE ase_map_copyinline #define ASE_MAP_COPIER_INLINE ase_map_copyinline
@ -303,8 +305,8 @@ ase_size_t ase_map_getcapa (
); );
int ase_map_getscale ( int ase_map_getscale (
ase_map_t* map, ase_map_t* map /* a map */,
int id ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */
); );
/****f* ase.cmn.map/ase_map_setscale /****f* ase.cmn.map/ase_map_setscale
@ -323,15 +325,15 @@ int ase_map_getscale (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_map_setscale ( void ase_map_setscale (
ase_map_t* map /* a map */, ase_map_t* map /* a map */,
int id /* ASE_MAP_KEY or ASE_MAP_VAL */, ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */,
int scale /* a scale factor */ int scale /* a scale factor */
); );
/******/ /******/
ase_map_copier_t ase_map_getcopier ( ase_map_copier_t ase_map_getcopier (
ase_map_t* map /* a map */, ase_map_t* map /* a map */,
int id /* ASE_MAP_KEY or ASE_MAP_VAL */ ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */
); );
/****f* ase.cmn.map/ase_map_setcopier /****f* ase.cmn.map/ase_map_setcopier
@ -349,16 +351,15 @@ ase_map_copier_t ase_map_getcopier (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_map_setcopier ( void ase_map_setcopier (
ase_map_t* map /* a map */, ase_map_t* map /* a map */,
int id /* ASE_MAP_KEY or ASE_MAP_VAL */, ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */,
ase_map_copier_t copier /* an element copier */ ase_map_copier_t copier /* an element copier */
); );
/******/ /******/
ase_map_freeer_t ase_map_getfreeer ( ase_map_freeer_t ase_map_getfreeer (
ase_map_t* map /* a map */, ase_map_t* map /* a map */,
int id /* ASE_MAP_KEY or ASE_MAP_VAL */ ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */
); );
/****f* ase.cmn.map/ase_map_setfreeer /****f* ase.cmn.map/ase_map_setfreeer
@ -371,9 +372,9 @@ ase_map_freeer_t ase_map_getfreeer (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_map_setfreeer ( void ase_map_setfreeer (
ase_map_t* map /* a map */, ase_map_t* map /* a map */,
int id /* ASE_MAP_KEY or ASE_MAP_VAL */, ase_map_id_t id /* ASE_MAP_KEY or ASE_MAP_VAL */,
ase_map_freeer_t freeer /* an element freeer */ ase_map_freeer_t freeer /* an element freeer */
); );
/******/ /******/

300
ase/include/ase/cmn/sll.h
View File

@ -10,30 +10,66 @@
#include <ase/types.h> #include <ase/types.h>
#include <ase/macros.h> #include <ase/macros.h>
/* values to be returned by ase_sll_walker_t */ /****t* ase.cmn.sll/ase_sll_walk_t
* NAME
* ase_sll_walk_t - define return values for ase_sll_walker_t
*
* SEE ALSO
* ase_sll_walk, ase_sll_walker_t
*
* SYNOPSIS
*/
enum ase_sll_walk_t enum ase_sll_walk_t
{ {
ASE_SLL_WALK_STOP = 0, ASE_SLL_WALK_STOP = 0,
ASE_SLL_WALK_FORWARD = 1 ASE_SLL_WALK_FORWARD = 1
}; };
/******/
typedef struct ase_sll_t ase_sll_t; typedef struct ase_sll_t ase_sll_t;
typedef struct ase_sll_node_t ase_sll_node_t; typedef struct ase_sll_node_t ase_sll_node_t;
typedef enum ase_sll_walk_t ase_sll_walk_t; typedef enum ase_sll_walk_t ase_sll_walk_t;
/* data copier */ /****b* ase.cmn.sll/ase_sll_copier_t
* NAME
* ase_sll_copier_t - define a node contruction callback
*
* DESCRIPTION
* The ase_sll_copier_t defines a callback function for node construction.
* A node is contructed when a user adds data to a list. The user can
* define how the data to add can be maintained in the list. A singly
* linked list not specified with any copiers stores the data pointer and
* the data length into a node. A special copier ASE_SLL_COPIER_INLINE copies
* the contents of the data a user provided into the node. You can use the
* ase_sll_setcopier() function to change the copier.
*
* A copier should return the pointer to the copied data. If it fails to copy
* data, it may return ASE_NULL. You need to set a proper freeer to free up
* memory allocated for copy.
*
* SEE ALSO
* ase_sll_setcopier, ase_sll_getcopier, ASE_SLL_COPIER
*
* SYNOPSIS
*/
typedef void* (*ase_sll_copier_t) ( typedef void* (*ase_sll_copier_t) (
ase_sll_t* sll, ase_sll_t* sll /* a map */,
void* dptr, void* dptr /* the pointer to data to copy */,
ase_size_t dlen ase_size_t dlen /* the length of data to copy */
); );
/******/
/* data freeer */ /****b* ase.cmn.sll/ase_sll_freeer_t
* NAME
* ase_sll_freeer_t - define a node destruction callback
* SYNOPSIS
*/
typedef void (*ase_sll_freeer_t) ( typedef void (*ase_sll_freeer_t) (
ase_sll_t* sll, ase_sll_t* sll /* a map */,
void* dptr, void* dptr /* the pointer to data to free */,
ase_size_t dlen ase_size_t dlen /* the length of data to free */
); );
/******/
/****t* ase.cmn.sll/ase_sll_comper_t /****t* ase.cmn.sll/ase_sll_comper_t
* NAME * NAME
@ -50,17 +86,36 @@ typedef void (*ase_sll_freeer_t) (
* SYNOPSIS * SYNOPSIS
*/ */
typedef int (*ase_sll_comper_t) ( typedef int (*ase_sll_comper_t) (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
const void* dptr1 /* a data pointer */, const void* dptr1 /* a data pointer */,
ase_size_t dlen1 /* a data length */, ase_size_t dlen1 /* a data length */,
const void* dptr2 /* a data pointer */, const void* dptr2 /* a data pointer */,
ase_size_t dlen2 /* a data length */ ase_size_t dlen2 /* a data length */
); );
/******/ /******/
/* node visitor */ /****b* ase.cmn.sll/ase_sll_walker_t
* NAME
* ase_sll_walker_t - define a list traversal callback for each node
*
* DESCRIPTION
* The ase_sll_walk() calls a callback function of the type ase_sll_walker_t
* for each node until it returns ASE_SLL_WALK_STOP. The walker should return
* ASE_SLL_WALK_FORWARD to let ase_sll_walk() continue visiting the next node.
* The third parameter to ase_sll_walk() is passed to the walker as the third
* parameter.
*
* SEE ALSO
* ase_sll_walk, ase_sll_walk_t
*
* SYNOPSIS
*/
typedef ase_sll_walk_t (*ase_sll_walker_t) ( typedef ase_sll_walk_t (*ase_sll_walker_t) (
ase_sll_t* sll, ase_sll_node_t* node, void* arg); ase_sll_t* sll /* a map */,
ase_sll_node_t* node /* a visited node */,
void* arg /* user-defined data */
);
/******/
/****s* ase.cmn.sll/ase_sll_t /****s* ase.cmn.sll/ase_sll_t
* NAME * NAME
@ -73,16 +128,16 @@ typedef ase_sll_walk_t (*ase_sll_walker_t) (
*/ */
struct ase_sll_t struct ase_sll_t
{ {
ase_mmgr_t* mmgr; ase_mmgr_t* mmgr; /* memory manager */
ase_sll_copier_t copier; ase_sll_copier_t copier; /* data copier */
ase_sll_freeer_t freeer; ase_sll_freeer_t freeer; /* data freeer */
ase_sll_comper_t comper; ase_sll_comper_t comper; /* data comparator */
ase_byte_t scale; ase_byte_t scale; /* scale factor */
ase_size_t size; ase_size_t size; /* the number of nodes */
ase_sll_node_t* head; ase_sll_node_t* head; /* the head node */
ase_sll_node_t* tail; ase_sll_node_t* tail; /* the tail node */
}; };
/******/ /******/
@ -93,7 +148,7 @@ struct ase_sll_t
* DESCRIPTION * DESCRIPTION
* The ase_sll_node_t type defines a list node containing a data pointer and * The ase_sll_node_t type defines a list node containing a data pointer and
* and data length. * and data length.
* *
* SEE ALSO * SEE ALSO
* ASE_SLL_DPTR, ASE_SLL_DLEN, ASE_SLL_NEXT * ASE_SLL_DPTR, ASE_SLL_DLEN, ASE_SLL_NEXT
* *
@ -101,13 +156,12 @@ struct ase_sll_t
*/ */
struct ase_sll_node_t struct ase_sll_node_t
{ {
void* dptr; /* pointer to the beginning of data */ void* dptr; /* the pointer to data */
ase_size_t dlen; /* length of data in bytes */ ase_size_t dlen; /* the length of data */
ase_sll_node_t* next; /* pointer to the next node */ ase_sll_node_t* next; /* the pointer to the next node */
}; };
/******/ /******/
#define ASE_SLL_COPIER_INLINE ase_sll_copyinline #define ASE_SLL_COPIER_INLINE ase_sll_copyinline
#define ASE_SLL_MMGR(sll) ((sll)->mmgr) #define ASE_SLL_MMGR(sll) ((sll)->mmgr)
@ -153,8 +207,8 @@ extern "C" {
* SYNOPSIS * SYNOPSIS
*/ */
ase_sll_t* ase_sll_open ( ase_sll_t* ase_sll_open (
ase_mmgr_t* mmgr /* memory manager */ , ase_mmgr_t* mmgr /* memory manager */ ,
ase_size_t ext /* size of extension area in bytes */ ase_size_t ext /* size of extension area in bytes */
); );
/******/ /******/
@ -172,14 +226,38 @@ void ase_sll_close (
); );
/******/ /******/
/****f* ase.cmn.sll/ase_sll_init
* NAME
* ase_sll_init - initialize a singly linked list
*
* DESCRIPTION
* The ase_sll_init() function initializes a singly linked list. The memory
* should be allocated by a caller and be passed to it. The caller may declare
* a static variable of the ase_sll_t type and pass its address. A memory
* manager still needs to be passed for node manipulation later.
*
* RETURN
* The ase_sll_init() function returns the first parameter on success and
* ASE_NULL on failure.
*
* SYNOPSIS
*/
ase_sll_t* ase_sll_init ( ase_sll_t* ase_sll_init (
ase_sll_t* sll /* an uninitialized singly linked list */, ase_sll_t* sll /* an uninitialized singly linked list */,
ase_mmgr_t* mmgr /* memory manager */ ase_mmgr_t* mmgr /* a memory manager */
); );
/******/
/****f* ase.cmn.sll/ase_sll_fini
* NAME
* ase_sll_init - deinitialize a singly linked list
*
* SYNOPSIS
*/
void ase_sll_fini ( void ase_sll_fini (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_getextension /****f* ase.cmn.sll/ase_sll_getextension
* NAME * NAME
@ -191,34 +269,59 @@ void ase_sll_fini (
* SYNOPSIS * SYNOPSIS
*/ */
void* ase_sll_getextension ( void* ase_sll_getextension (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/ /******/
/* /****f* ase.cmn.sll/ase_sll_getmmgr
* NAME: get the pointer to the memory manager in use * NAME
* ase_sll_getmmgr - get the memory manager
*
* SYNOPSIS
*/ */
ase_mmgr_t* ase_sll_getmmgr ( ase_mmgr_t* ase_sll_getmmgr (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_setmmgr
* NAME
* ase_sll_setmmgr - set the memory manager
*
* SYNOPSIS
*/
void ase_sll_setmmgr ( void ase_sll_setmmgr (
ase_sll_t* sll, ase_sll_t* sll /* a singly linked list */,
ase_mmgr_t* mmgr ase_mmgr_t* mmgr /* a memory manager */
); );
/******/
/* /****f* ase.cmn.sll/ase_sll_getsize
* NAME: Gets the number of elements held in a singly linked list * NAME
* RETURN: the number of elements the list holds * ase_sll_getsize - get the number of nodes
*
* DESCRIPTION
* The ase_sll_getsize() function returns the number of the data nodes held
* in a singly linked list.
*
* SYNOPSIS
*/ */
ase_size_t ase_sll_getsize ( ase_size_t ase_sll_getsize (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_getscale
* NAME
* ase_sll_getscale - get the scale factor
*
* SYNOPSIS
*/
int ase_sll_getscale ( int ase_sll_getscale (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_setscale /****f* ase.cmn.sll/ase_sll_setscale
* NAME * NAME
@ -241,13 +344,20 @@ void ase_sll_setscale (
); );
/******/ /******/
/****f* ase.cmn.sll/ase_sll_getcopier
* NAME
* ase_sll_getfreeer - get the data copier
*
* SYNOPSIS
*/
ase_sll_copier_t ase_sll_getcopier ( ase_sll_copier_t ase_sll_getcopier (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_setcopier /****f* ase.cmn.sll/ase_sll_setcopier
* NAME * NAME
* ase_sll_setcopier - specify how to clone an element * ase_sll_setcopier - set a data copier
* *
* DESCRIPTION * DESCRIPTION
* A special copier ASE_SLL_COPIER_INLINE is provided. This copier enables * A special copier ASE_SLL_COPIER_INLINE is provided. This copier enables
@ -261,17 +371,24 @@ ase_sll_copier_t ase_sll_getcopier (
*/ */
void ase_sll_setcopier ( void ase_sll_setcopier (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_copier_t copier /* a element copier */ ase_sll_copier_t copier /* a data copier */
); );
/******/ /******/
/****f* ase.cmn.sll/ase_sll_getfreeer
* NAME
* ase_sll_getfreeer - get the data freeer
*
* SYNOPSIS
*/
ase_sll_freeer_t ase_sll_getfreeer ( ase_sll_freeer_t ase_sll_getfreeer (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_setfreeer /****f* ase.cmn.sll/ase_sll_setfreeer
* NAME * NAME
* ase_sll_setfreeer - specify how to destroy an element * ase_sll_setfreeer - set a data freeer
* *
* DESCRIPTION * DESCRIPTION
* The freeer is called when a node containing the element is destroyed. * The freeer is called when a node containing the element is destroyed.
@ -280,34 +397,54 @@ ase_sll_freeer_t ase_sll_getfreeer (
*/ */
void ase_sll_setfreeer ( void ase_sll_setfreeer (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_freeer_t freeer /* a element freeer */ ase_sll_freeer_t freeer /* a data freeer */
); );
/******/ /******/
/****f* ase.cmn.sll/ase_sll_getcomper
* NAME
* ase_sll_getcomper - get the data comparator
*
* SYNOPSIS
*/
ase_sll_comper_t ase_sll_getcomper ( ase_sll_comper_t ase_sll_getcomper (
ase_sll_t* sll ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_setcomper
* NAME
* ase_sll_setcomper - set the data comparator
*
* SYNOPSIS
*/
void ase_sll_setcomper ( void ase_sll_setcomper (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_comper_t comper /* a comparator */ ase_sll_comper_t comper /* a comparator */
); );
/******/
/* /****f* ase.cmn.sll/ase_sll_gethead
* NAME: Gets the head(first) node * NAME
* RETURN: the tail node of a singly linked list * ase_sll_gethead - get the head node
*
* SYNOPSIS
*/ */
ase_sll_node_t* ase_sll_gethead ( ase_sll_node_t* ase_sll_gethead (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/* /****f* ase.cmn.sll/ase_sll_gettail
* NAME: Gets the tail(last) node * NAME
* RETURN: the tail node of a singly linked list * ase_sll_gettail - get the tail node
*
* SYNOPSIS
*/ */
ase_sll_node_t* ase_sll_gettail ( ase_sll_node_t* ase_sll_gettail (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/
/****f* ase.cmn.sll/ase_sll_search /****f* ase.cmn.sll/ase_sll_search
* NAME * NAME
@ -329,10 +466,10 @@ ase_sll_node_t* ase_sll_gettail (
* SYNOPSIS * SYNOPSIS
*/ */
ase_sll_node_t* ase_sll_search ( ase_sll_node_t* ase_sll_search (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_node_t* pos /* a positional node */, ase_sll_node_t* pos /* a positional node */,
const void* dptr /* a data pointer */, const void* dptr /* a data pointer */,
ase_size_t dlen /* a data length */ ase_size_t dlen /* a data length */
); );
/******/ /******/
@ -352,10 +489,10 @@ ase_sll_node_t* ase_sll_search (
* SYNOPSIS * SYNOPSIS
*/ */
ase_sll_node_t* ase_sll_insert ( ase_sll_node_t* ase_sll_insert (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_node_t* pos /* a node before which a new node is inserted */, ase_sll_node_t* pos /* a node before which a new node is inserted */,
void* dptr /* the pointer to the data */, void* dptr /* the pointer to the data */,
ase_size_t dlen /* the length of the data */ ase_size_t dlen /* the length of the data */
); );
/******/ /******/
@ -369,7 +506,7 @@ ase_sll_node_t* ase_sll_insert (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_sll_delete ( void ase_sll_delete (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_node_t* pos /* a node to delete */ ase_sll_node_t* pos /* a node to delete */
); );
/******/ /******/
@ -385,19 +522,19 @@ void ase_sll_delete (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_sll_clear ( void ase_sll_clear (
ase_sll_t* sll /* a singly linked list */ ase_sll_t* sll /* a singly linked list */
); );
/******/ /******/
ase_sll_node_t* ase_sll_pushhead ( ase_sll_node_t* ase_sll_pushhead (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
void* dptr, void* dptr,
ase_size_t dlen ase_size_t dlen
); );
ase_sll_node_t* ase_sll_pushtail ( ase_sll_node_t* ase_sll_pushtail (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
void* dptr, void* dptr,
ase_size_t dlen ase_size_t dlen
); );
@ -420,6 +557,7 @@ void ase_sll_poptail (
* head node down to its tail node as long as the walker function returns * head node down to its tail node as long as the walker function returns
* ASE_SLL_WALK_FORWARD. A walker can return ASE_SLL_WALK_STOP to cause * ASE_SLL_WALK_FORWARD. A walker can return ASE_SLL_WALK_STOP to cause
* immediate stop of traversal. * immediate stop of traversal.
*
* For each node, the walker function is called and it is passed three * For each node, the walker function is called and it is passed three
* parameters: the singly linked list, the visiting node, and the * parameters: the singly linked list, the visiting node, and the
* user-defined data passed as the third parameter in a call to the * user-defined data passed as the third parameter in a call to the
@ -428,9 +566,9 @@ void ase_sll_poptail (
* SYNOPSIS * SYNOPSIS
*/ */
void ase_sll_walk ( void ase_sll_walk (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
ase_sll_walker_t walker /* a user-defined walker function */, ase_sll_walker_t walker /* a user-defined walker function */,
void* arg /* pointer to user-defined data */ void* arg /* the pointer to user-defined data */
); );
/******/ /******/
@ -439,9 +577,9 @@ void ase_sll_walk (
* Use ASE_SLL_COPIER_INLINE instead. * Use ASE_SLL_COPIER_INLINE instead.
*/ */
void* ase_sll_copyinline ( void* ase_sll_copyinline (
ase_sll_t* sll /* a singly linked list */, ase_sll_t* sll /* a singly linked list */,
void* data /* pointer to data to copy */ , void* data /* pointer to data to copy */ ,
ase_size_t len /* length of data in bytes */ ase_size_t len /* length of data in bytes */
); );
#ifdef __cplusplus #ifdef __cplusplus

14
ase/lib/cmn/map.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: map.c 391 2008-09-27 09:51:23Z baconevi $ * $Id: map.c 397 2008-09-29 07:11:08Z baconevi $
* *
* {License} * {License}
*/ */
@ -299,14 +299,14 @@ size_t ase_map_getcapa (map_t* map)
return map->capa; return map->capa;
} }
int ase_map_getscale (map_t* map, int id) int ase_map_getscale (map_t* map, ase_map_id_t id)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");
return map->scale[id]; return map->scale[id];
} }
void ase_map_setscale (map_t* map, int id, int scale) void ase_map_setscale (map_t* map, ase_map_id_t id, int scale)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");
@ -320,28 +320,28 @@ void ase_map_setscale (map_t* map, int id, int scale)
map->scale[id] = scale; map->scale[id] = scale;
} }
copier_t ase_map_getcopier (map_t* map, int id) copier_t ase_map_getcopier (map_t* map, ase_map_id_t id)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");
return map->copier[id]; return map->copier[id];
} }
void ase_map_setcopier (map_t* map, int id, copier_t copier) void ase_map_setcopier (map_t* map, ase_map_id_t id, copier_t copier)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");
map->copier[id] = copier; map->copier[id] = copier;
} }
freeer_t ase_map_getfreeer (map_t* map, int id) freeer_t ase_map_getfreeer (map_t* map, ase_map_id_t id)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");
return map->freeer[id]; return map->freeer[id];
} }
void ase_map_setfreeer (map_t* map, int id, freeer_t freeer) void ase_map_setfreeer (map_t* map, ase_map_id_t id, freeer_t freeer)
{ {
ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL, ASE_ASSERTX (id == ASE_MAP_KEY || id == ASE_MAP_VAL,
"The ID should be either ASE_MAP_KEY or ASE_MAP_VAL"); "The ID should be either ASE_MAP_KEY or ASE_MAP_VAL");

1
ase/lib/cmn/sll.c
View File

@ -66,6 +66,7 @@ sll_t* ase_sll_init (sll_t* sll, mmgr_t* mmgr)
{ {
/* do not zero out the extension */ /* do not zero out the extension */
ASE_MEMSET (sll, 0, ASE_SIZEOF(sll_t)); ASE_MEMSET (sll, 0, ASE_SIZEOF(sll_t));
sll->mmgr = mmgr; sll->mmgr = mmgr;
sll->size = 0; sll->size = 0;
sll->scale = 1; sll->scale = 1;