Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
JudyL_funcs(3)		   Library Functions Manual		JudyL_funcs(3)

NAME
       JudyL  functions	- C library for	creating and accessing a dynamic array
       of words, using any value of a word as an index

SYNOPSIS
       PPvoid_t	JudyLIns(	PPvoid_t PPJLArray, Word_t    Index, PJError_t PJError);
       int	JudyLDel(	PPvoid_t PPJLArray, Word_t    Index, PJError_t PJError);
       PPvoid_t	JudyLGet(	Pcvoid_t  PJLArray, Word_t    Index, PJError_t PJError);
       Word_t	JudyLCount(	Pcvoid_t  PJLArray, Word_t    Index1, Word_t	Index2,	PJError_t PJError);
       PPvoid_t	JudyLByCount(	Pcvoid_t  PJLArray, Word_t    Nth,  Word_t * PIndex,  PJError_t	PJError);
       Word_t	JudyLFreeArray(	PPvoid_t PPJLArray, PJError_t PJError);
       Word_t	JudyLMemUsed(	Pcvoid_t  PJLArray);
       PPvoid_t	JudyLFirst(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       PPvoid_t	JudyLNext(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       PPvoid_t	JudyLLast(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       PPvoid_t	JudyLPrev(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       int	JudyLFirstEmpty(Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       int	JudyLNextEmpty(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       int	JudyLLastEmpty(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);
       int	JudyLPrevEmpty(	Pcvoid_t  PJLArray, Word_t * PIndex, PJError_t PJError);

DESCRIPTION
       A macro equivalent exists for each function call.   Because  the	 macro
       forms  are sometimes faster and have a simpler error handling interface
       than the	equivalent functions, they are the preferred  way  of  calling
       the  JudyL functions.  See JudyL(3) for more information.  The function
       call definitions	are included here for completeness.

       One of the difficulties in using	the JudyL function calls lies  in  de-
       termining whether to pass a pointer or the address of a pointer.	 Since
       the  functions that modify the JudyL array must also modify the pointer
       to the JudyL array, you must pass the address  of  the  pointer	rather
       than  the  pointer  itself.  This often leads to	hard-to-debug program-
       matic errors.  In practice, the macros allow the	compiler to catch pro-
       gramming	errors when pointers instead  of  addresses  of	 pointers  are
       passed.

       The  JudyL  function  calls  have  an additional	parameter beyond those
       specified in the	macro calls.  This parameter is	either a pointer to an
       error structure,	or NULL	(in which case the detailed error  information
       is not returned).

       In  the following descriptions, the functions are described in terms of
       how the macros use them (only in	the case of  #define  JUDYERROR_NOTEST
       1).   This  is  the  suggested use of the macros	after your program has
       been fully debugged.  When the JUDYERROR_NOTEST macro is	not specified,
       an error	structure is declared to store error information returned from
       the JudyL functions when	an error occurs.

       Notice the placement of the & in	the different functions.

	JudyLIns(&PJLArray, Index, &JError)

		      #define JLI(PValue, PJLArray, Index)  \
			 PValue	= JudyLIns(&PJLArray, Index, PJE0)

	JudyLDel(&PJLArray, Index, &JError)

		      #define JLD(Rc_int, PJLArray, Index)  \
			 Rc_int	= JudyLDel(&PJLArray, Index, PJE0)

	JudyLGet(PJLArray, Index, &JError)

		      #define JLG(PValue, PJLArray, Index)  \
			 PValue	= JudyLGet(PJLArray, Index, PJE0)

	JudyLCount(PJLArray, Index1, Index2, &JError)

		      #define JLC(Rc_word, PJLArray, Index1, Index2)  \
			 Rc_word = JudyLCount(PJLArray,	Index1,	Index2,	PJE0)

	JudyLByCount(PJLArray, Nth, &Index, &JError)

		      #define JLBC(PValue, PJLArray, Nth, Index) \
			 PValue	= JudyLByCount(PJLArray, Nth, &Index, PJE0)

	JudyLFreeArray(&PJLArray, &JError)

		      #define JLFA(Rc_word, PJLArray) \
			 Rc_word = JudyLFreeArray(&PJLArray, PJE0)

	JudyLMemUsed(PJLArray)

		      #define JLMU(Rc_word, PJLArray) \
			 Rc_word = JudyLMemUsed(PJLArray)

	JudyLFirst(PJLArray, &Index, &JError)

		      #define JLF(PValue, PJLArray, Index) \
			 PValue	= JudyLFirst(PJLArray, &Index, PJEO)

	JudyLNext(PJLArray, &Index, &JError)

		      #define JLN(PValue, PJLArray, Index) \
			 PValue	= JudyLNext(PJLArray, &Index, PJEO)

	JudyLLast(PJLArray, &Index, &JError)

		      #define JLL(PValue, PJLArray, Index) \
			 PValue	= JudyLLast(PJLArray, &Index, PJEO)

	JudyLPrev(PJLArray, &Index, &JError)

		      #define JLP(PValue, PJLArray, Index) \
			 PValue	= JudyLPrev(PJLArray, &Index, PJEO)

	JudyLFirstEmpty(PJLArray, &Index, &JError)

		      #define JLFE(Rc_int, PJLArray, Index) \
			 Rc_int	= JudyLFirstEmpty(PJLArray, &Index, PJEO)

	JudyLNextEmpty(PJLArray, &Index, &JError)

		      #define JLNE(Rc_int, PJLArray, Index) \
			 Rc_int	= JudyLNextEmpty(PJLArray, &Index, PJEO)

	JudyLLastEmpty(PJLArray, &Index, &JError)

		      #define JLLE(Rc_int, PJLArray, Index) \
			 Rc_int	= JudyLLastEmpty(PJLArray, &Index, PJEO)

	JudyLPrevEmpty(PJLArray, &Index, &JError)

		      #define JLPE(Rc_int, PJLArray, Index) \
			 Rc_int	= JudyLPrevEmpty(PJLArray, &Index, PJEO)

       Definitions for all the Judy functions, the  types  Pvoid_t,  Pcvoid_t,
       PPvoid_t,  Word_t,  JError_t, and PJError_t, the	constants NULL,	JU_ER-
       RNO_*, JERR, PPJERR, and	PJE0, are provided in the Judy.h  header  file
       (/usr/include/Judy.h).	Note:	Callers	 should	define JudyL arrays as
       type Pvoid_t, which can be passed  by  value  to	 functions  that  take
       Pcvoid_t	(constant Pvoid_t), and	also by	address	to functions that take
       PPvoid_t.

       The  return type	from most JudyL	functions is PPvoid_t so that the val-
       ues stored in the array can be pointers to other	objects,  which	 is  a
       typical	usage,	or cast	to a Word_t * when a pointer to	a Value	is re-
       quired instead of a pointer to a	pointer.

AUTHOR
       Judy was	invented by Doug Baskins and implemented by Hewlett-Packard.

SEE ALSO
       Judy(3),	Judy1(3), JudyL(3), JudySL(3), JudyHS(3),
       malloc(),
       the Judy	website, http://judy.sourceforge.net, for more information and
       Application Notes.

								JudyL_funcs(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=JudyLFreeArray&sektion=3&manpath=FreeBSD+Ports+14.3.quarterly>

home | help