# HG changeset patch # User Mike Becker # Date 1612635104 -3600 # Node ID d345541018fae434c5fd28098f353d4fc510f895 # Parent 92e4824104532ffd3364f741a535c208d6d9a73f starts ucx 3.0 development diff -r 92e482410453 -r d345541018fa .hgignore --- a/.hgignore Mon Dec 30 09:54:10 2019 +0100 +++ b/.hgignore Sat Feb 06 19:11:44 2021 +0100 @@ -26,7 +26,7 @@ /\.deps/ /\.libs/ ^stamp-h -^test/ucxtest +test/test_list.c /test-suite.log$ ^ucx-.*\.tar.gz$ ^.idea/ diff -r 92e482410453 -r d345541018fa CHANGELOG --- a/CHANGELOG Mon Dec 30 09:54:10 2019 +0100 +++ b/CHANGELOG Sat Feb 06 19:11:44 2021 +0100 @@ -1,3 +1,8 @@ +Version 3.0 M1 +-------------- +work in progress + + Version 2.1 - 2019-12-30 ------------------------ diff -r 92e482410453 -r d345541018fa CMakeLists.txt --- a/CMakeLists.txt Mon Dec 30 09:54:10 2019 +0100 +++ b/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 @@ -1,5 +1,5 @@ -cmake_minimum_required(VERSION 3.10) -project(ucx VERSION 2.1 DESCRIPTION "UAP Common Extensions") +cmake_minimum_required(VERSION 3.14) +project(ucx VERSION 3.0 DESCRIPTION "UAP Common Extensions") # Configuration set(CMAKE_C_STANDARD 11) @@ -11,7 +11,6 @@ # Tests enable_testing() add_subdirectory(test) -add_test(NAME test COMMAND ucxtest WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/test") # Web Documentation add_subdirectory(docs/src) @@ -31,10 +30,18 @@ configure_file(${CMAKE_SOURCE_DIR}/cmake_infile.doxygen ${CMAKE_BINARY_DIR}/Doxyfile) + add_custom_target(docs-api-21 + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/docs/api-2.1 ${CMAKE_BINARY_DIR}/docs/web/api-2.1 + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + COMMENT "Copying UCX 2.1 API documentation.") + add_custom_target(docs-api COMMAND ${DOXYGEN_EXECUTABLE} WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - COMMENT "Generating API documentation with Doxygen") + COMMENT "Generating API documentation with Doxygen.") + + add_custom_target(docs-all DEPENDS docs-html docs-api docs-api-21) +else() + add_custom_target(docs-all DEPENDS docs-html) endif() -add_custom_target(docs-all DEPENDS docs-html docs-api) diff -r 92e482410453 -r d345541018fa COPYING --- a/COPYING Mon Dec 30 09:54:10 2019 +0100 +++ b/COPYING Sat Feb 06 19:11:44 2021 +0100 @@ -1,4 +1,4 @@ -Copyright 2017 Mike Becker, Olaf Wintermann. All rights reserved. +Copyright 2021 Mike Becker, Olaf Wintermann. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff -r 92e482410453 -r d345541018fa Makefile.am --- a/Makefile.am Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,30 +0,0 @@ -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. -# -# Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# - -SUBDIRS = src test -ACLOCAL_AMFLAGS = -I m4 diff -r 92e482410453 -r d345541018fa README --- a/README Mon Dec 30 09:54:10 2019 +0100 +++ b/README Sat Feb 06 19:11:44 2021 +0100 @@ -5,11 +5,10 @@ 0. Table of Contents: 1. Introduction ........................................................ 15 - 2. Build ............................................................... 26 - 3. Install ............................................................. 37 - 4. Documentation ....................................................... 50 - 5. Contact ............................................................. 63 - 6. License ............................................................. 69 + 2. Build ............................................................... 25 + 3. Documentation ....................................................... 44 + 4. Contact ............................................................. 57 + 5. License ............................................................. 64 1. Introduction @@ -26,28 +25,23 @@ 2. Build -------- -Untar the source archive and simply run +Untar the source archive and run - ./configure && make + mkdir build + cd build + cmake .. + make -If you want to verify your build, you may then run +Optionally install UCX by running the following command as privileged user + + make install + +If you want to verify your build, you can run make check -3. Install ----------- -Build the binaries as described above. Then install UCX, by running - - make install - -or - - make install PREFIX= - -The default prefix is /usr/local and will require privileged access. - -4. Documentation +3. Documentation ---------------- Documentation is available at: @@ -60,16 +54,17 @@ https://develop.uap-core.de/ucx/api/index.html -5. Contact +4. Contact ---------- Olaf Wintermann (olaf.wintermann@gmail.com) Mike Becker (universe@uap-core.de) -6. License + +5. License ---------- -Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. +Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff -r 92e482410453 -r d345541018fa autogen.sh --- a/autogen.sh Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,3 +0,0 @@ -#!/bin/sh -autoreconf --install - diff -r 92e482410453 -r d345541018fa cmake_infile.doxygen --- a/cmake_infile.doxygen Mon Dec 30 09:54:10 2019 +0100 +++ b/cmake_infile.doxygen Sat Feb 06 19:11:44 2021 +0100 @@ -230,12 +230,6 @@ ALIASES = -# This tag can be used to specify a number of word-keyword mappings (TCL only). -# A mapping has the form "name=value". For example adding "class=itcl::class" -# will allow you to use the command class in the itcl::class meaning. - -TCL_SUBST = - # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all @@ -989,13 +983,6 @@ ALPHABETICAL_INDEX = YES -# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in -# which the alphabetical index list will be split. -# Minimum value: 1, maximum value: 20, default value: 5. -# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. - -COLS_IN_ALPHA_INDEX = 5 - # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored @@ -2008,12 +1995,6 @@ EXTERNAL_PAGES = YES -# The PERL_PATH should be the absolute path and name of the perl script -# interpreter (i.e. the result of 'which perl'). -# The default file (with absolute path) is: /usr/bin/perl. - -PERL_PATH = /usr/bin/perl - #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- @@ -2027,15 +2008,6 @@ CLASS_DIAGRAMS = YES -# You can define message sequence charts within doxygen comments using the \msc -# command. Doxygen will then run the mscgen tool (see: -# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the -# documentation. The MSCGEN_PATH tag allows you to specify the directory where -# the mscgen tool resides. If left empty the tool is assumed to be found in the -# default search path. - -MSCGEN_PATH = - # You can include diagrams made with dia in doxygen documentation. Doxygen will # then run dia to produce the diagram and insert it in the documentation. The # DIA_PATH tag allows you to specify the directory where the dia binary resides. diff -r 92e482410453 -r d345541018fa configure.ac --- a/configure.ac Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,64 +0,0 @@ -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. -# -# Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# - -# the package version must match the macros in ucx.h -# the lib version must follow the libtool versioning convention -AC_PREREQ([2.60]) -AC_INIT([ucx], [2.1.0], [olaf.wintermann@gmail.com]) -AC_SUBST([UCX_LIB_VERSION], [4:0:1]) - -# don't place everything in the project root -AC_CONFIG_AUX_DIR([build-aux]) -AC_CONFIG_MACRO_DIR([m4]) - -# we use our own directory structure -AM_INIT_AUTOMAKE([foreign -Wall -Werror]) - -# if there is an archiver, use it -m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) - -# we are compiling a library -LT_INIT - -# we want c11, and may fall back to c99 -AC_PROG_CC_C99 - -# we want to support automake < 1.14, so we need this deprecated macro -# it tests, whether the compiler allows -c and -o simultaneously -# in modern versions of autoconf, this is done by AC_PROG_CC -AM_PROG_CC_C_O - -# where to place config macros -AC_CONFIG_HEADERS([config.h]) - -# our Makefiles -AC_CONFIG_FILES([Makefile src/Makefile test/Makefile]) - -# GO -AC_OUTPUT - diff -r 92e482410453 -r d345541018fa docs/api-2.1/allocator_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/allocator_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,600 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/allocator.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Typedefs | +Functions
+
+
allocator.h File Reference
+
+
+ +

Allocator for custom memory management. +More...

+
#include "ucx.h"
+
+

Go to the source code of this file.

+ + + + + +

+Data Structures

struct  UcxAllocator
 UCX allocator data structure containing memory management functions. More...
 
+ + + + + + + + + + + + + + + + +

+Macros

#define almalloc(allocator, n)   ((allocator)->malloc((allocator)->pool, n))
 Shorthand for calling an allocators malloc function. More...
 
#define alcalloc(allocator, n, size)   ((allocator)->calloc((allocator)->pool, n, size))
 Shorthand for calling an allocators calloc function. More...
 
#define alrealloc(allocator, ptr, n)   ((allocator)->realloc((allocator)->pool, ptr, n))
 Shorthand for calling an allocators realloc function. More...
 
#define alfree(allocator, ptr)   ((allocator)->free((allocator)->pool, ptr))
 Shorthand for calling an allocators free function. More...
 
#define UCX_ALLOCATOR_DEFAULT
 Convenient macro for a default allocator struct definition. More...
 
+ + + + + + + + + + + + + +

+Typedefs

typedef void *(* ucx_allocator_malloc) (void *pool, size_t n)
 A function pointer to the allocators malloc() function. More...
 
typedef void *(* ucx_allocator_calloc) (void *pool, size_t n, size_t size)
 A function pointer to the allocators calloc() function. More...
 
typedef void *(* ucx_allocator_realloc) (void *pool, void *data, size_t n)
 A function pointer to the allocators realloc() function. More...
 
typedef void(* ucx_allocator_free) (void *pool, void *data)
 A function pointer to the allocators free() function. More...
 
+ + + + + + + + + + + + + + + + +

+Functions

UcxAllocator * ucx_default_allocator ()
 Returns a pointer to the default allocator. More...
 
void * ucx_default_malloc (void *ignore, size_t n)
 A wrapper for the standard libc malloc() function. More...
 
void * ucx_default_calloc (void *ignore, size_t n, size_t size)
 A wrapper for the standard libc calloc() function. More...
 
void * ucx_default_realloc (void *ignore, void *data, size_t n)
 A wrapper for the standard libc realloc() function. More...
 
void ucx_default_free (void *ignore, void *data)
 A wrapper for the standard libc free() function. More...
 
+

Detailed Description

+

Allocator for custom memory management.

+

A UCX allocator consists of a pointer to the memory area / pool and four function pointers to memory management functions operating on this memory area / pool. These functions shall behave equivalent to the standard libc functions malloc(), calloc(), realloc() and free().

+

The signature of the memory management functions is based on the signature of the respective libc function but each of them takes the pointer to the memory area / pool as first argument.

+

As the pointer to the memory area / pool can be arbitrarily chosen, any data can be provided to the memory management functions. A UcxMempool is just one example.

+
See also
mempool.h
+
+UcxMap
+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ alcalloc

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define alcalloc( allocator,
 n,
 size 
)   ((allocator)->calloc((allocator)->pool, n, size))
+
+ +

Shorthand for calling an allocators calloc function.

+
Parameters
+ + + + +
allocatorthe allocator to use
nthe count of elements the space should be allocated for
sizethe size of each element
+
+
+
Returns
a pointer to the allocated memory area
+ +
+
+ +

◆ alfree

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define alfree( allocator,
 ptr 
)   ((allocator)->free((allocator)->pool, ptr))
+
+ +

Shorthand for calling an allocators free function.

+
Parameters
+ + + +
allocatorthe allocator to use
ptrthe pointer to the memory area that shall be freed
+
+
+ +
+
+ +

◆ almalloc

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define almalloc( allocator,
 n 
)   ((allocator)->malloc((allocator)->pool, n))
+
+ +

Shorthand for calling an allocators malloc function.

+
Parameters
+ + + +
allocatorthe allocator to use
nsize of space to allocate
+
+
+
Returns
a pointer to the allocated memory area
+ +
+
+ +

◆ alrealloc

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define alrealloc( allocator,
 ptr,
 n 
)   ((allocator)->realloc((allocator)->pool, ptr, n))
+
+ +

Shorthand for calling an allocators realloc function.

+
Parameters
+ + + + +
allocatorthe allocator to use
ptrthe pointer to the memory area that shall be reallocated
nthe new size of the allocated memory area
+
+
+
Returns
a pointer to the reallocated memory area
+ +
+
+ +

◆ UCX_ALLOCATOR_DEFAULT

+ +
+
+ + + + +
#define UCX_ALLOCATOR_DEFAULT
+
+Value:
{NULL, \
ucx_default_malloc, ucx_default_calloc, ucx_default_realloc, \
ucx_default_free }
ucx_default_calloc
void * ucx_default_calloc(void *ignore, size_t n, size_t size)
A wrapper for the standard libc calloc() function.
Definition: allocator.c:50
+
ucx_default_realloc
void * ucx_default_realloc(void *ignore, void *data, size_t n)
A wrapper for the standard libc realloc() function.
Definition: allocator.c:54
+
+

Convenient macro for a default allocator struct definition.

+ +
+
+

Typedef Documentation

+ +

◆ ucx_allocator_calloc

+ +
+
+ + + + +
typedef void*(* ucx_allocator_calloc) (void *pool, size_t n, size_t size)
+
+ +

A function pointer to the allocators calloc() function.

+
See also
UcxAllocator
+ +
+
+ +

◆ ucx_allocator_free

+ +
+
+ + + + +
typedef void(* ucx_allocator_free) (void *pool, void *data)
+
+ +

A function pointer to the allocators free() function.

+
See also
UcxAllocator
+ +
+
+ +

◆ ucx_allocator_malloc

+ +
+
+ + + + +
typedef void*(* ucx_allocator_malloc) (void *pool, size_t n)
+
+ +

A function pointer to the allocators malloc() function.

+
See also
UcxAllocator
+ +
+
+ +

◆ ucx_allocator_realloc

+ +
+
+ + + + +
typedef void*(* ucx_allocator_realloc) (void *pool, void *data, size_t n)
+
+ +

A function pointer to the allocators realloc() function.

+
See also
UcxAllocator
+ +
+
+

Function Documentation

+ +

◆ ucx_default_allocator()

+ +
+
+ + + + + + + +
UcxAllocator* ucx_default_allocator ()
+
+ +

Returns a pointer to the default allocator.

+

The default allocator contains wrappers to the standard libc memory management functions. Use this function to get a pointer to a globally available allocator. You may also define an own UcxAllocator by assigning UCX_ALLOCATOR_DEFAULT to a variable and pass the address of this variable to any function that takes a UcxAllocator as argument. Note that using this function is the recommended way of passing a default allocator, thus it never runs out of scope.

+
Returns
a pointer to the default allocator
+
See also
UCX_ALLOCATOR_DEFAULT
+ +
+
+ +

◆ ucx_default_calloc()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void* ucx_default_calloc (void * ignore,
size_t n,
size_t size 
)
+
+ +

A wrapper for the standard libc calloc() function.

+
Parameters
+ + + + +
ignoreignored (may be used by allocators for pooled memory)
nargument passed to calloc()
sizeargument passed to calloc()
+
+
+
Returns
return value of calloc()
+ +
+
+ +

◆ ucx_default_free()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_default_free (void * ignore,
void * data 
)
+
+ +

A wrapper for the standard libc free() function.

+
Parameters
+ + + +
ignoreignored (may be used by allocators for pooled memory)
dataargument passed to free()
+
+
+ +
+
+ +

◆ ucx_default_malloc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_default_malloc (void * ignore,
size_t n 
)
+
+ +

A wrapper for the standard libc malloc() function.

+
Parameters
+ + + +
ignoreignored (may be used by allocators for pooled memory)
nargument passed to malloc()
+
+
+
Returns
return value of malloc()
+ +
+
+ +

◆ ucx_default_realloc()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void* ucx_default_realloc (void * ignore,
void * data,
size_t n 
)
+
+ +

A wrapper for the standard libc realloc() function.

+
Parameters
+ + + + +
ignoreignored (may be used by allocators for pooled memory)
dataargumend passed to realloc()
nargument passed to realloc()
+
+
+
Returns
return value of realloc()
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/allocator_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/allocator_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,95 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/allocator.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
allocator.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
52 #ifndef UCX_ALLOCATOR_H
53 #define UCX_ALLOCATOR_H
54 
55 #include "ucx.h"
56 
57 #ifdef __cplusplus
58 extern "C" {
59 #endif
60 
65 typedef void*(*ucx_allocator_malloc)(void *pool, size_t n);
66 
71 typedef void*(*ucx_allocator_calloc)(void *pool, size_t n, size_t size);
72 
77 typedef void*(*ucx_allocator_realloc)(void *pool, void *data, size_t n);
78 
83 typedef void(*ucx_allocator_free)(void *pool, void *data);
84 
88 typedef struct {
93  void *pool;
97  ucx_allocator_malloc malloc;
101  ucx_allocator_calloc calloc;
105  ucx_allocator_realloc realloc;
109  ucx_allocator_free free;
110 } UcxAllocator;
111 
127 UcxAllocator *ucx_default_allocator();
128 
135 void *ucx_default_malloc(void *ignore, size_t n);
143 void *ucx_default_calloc(void *ignore, size_t n, size_t size);
151 void *ucx_default_realloc(void *ignore, void *data, size_t n);
157 void ucx_default_free(void *ignore, void *data);
158 
165 #define almalloc(allocator, n) ((allocator)->malloc((allocator)->pool, n))
166 
174 #define alcalloc(allocator, n, size) \
175  ((allocator)->calloc((allocator)->pool, n, size))
176 
184 #define alrealloc(allocator, ptr, n) \
185  ((allocator)->realloc((allocator)->pool, ptr, n))
186 
192 #define alfree(allocator, ptr) ((allocator)->free((allocator)->pool, ptr))
193 
197 #define UCX_ALLOCATOR_DEFAULT {NULL, \
198  ucx_default_malloc, ucx_default_calloc, ucx_default_realloc, \
199  ucx_default_free }
200 
201 #ifdef __cplusplus
202 }
203 #endif
204 
205 #endif /* UCX_ALLOCATOR_H */
206 
ucx.h
Main UCX Header providing most common definitions.
+
ucx_default_malloc
void * ucx_default_malloc(void *ignore, size_t n)
A wrapper for the standard libc malloc() function.
Definition: allocator.c:46
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
UcxAllocator::malloc
ucx_allocator_malloc malloc
The malloc() function for this allocator.
Definition: allocator.h:97
+
ucx_allocator_calloc
void *(* ucx_allocator_calloc)(void *pool, size_t n, size_t size)
A function pointer to the allocators calloc() function.
Definition: allocator.h:71
+
UcxAllocator::free
ucx_allocator_free free
The free() function for this allocator.
Definition: allocator.h:109
+
ucx_allocator_malloc
void *(* ucx_allocator_malloc)(void *pool, size_t n)
A function pointer to the allocators malloc() function.
Definition: allocator.h:65
+
ucx_default_allocator
UcxAllocator * ucx_default_allocator()
Returns a pointer to the default allocator.
Definition: allocator.c:41
+
ucx_default_calloc
void * ucx_default_calloc(void *ignore, size_t n, size_t size)
A wrapper for the standard libc calloc() function.
Definition: allocator.c:50
+
ucx_allocator_realloc
void *(* ucx_allocator_realloc)(void *pool, void *data, size_t n)
A function pointer to the allocators realloc() function.
Definition: allocator.h:77
+
ucx_default_realloc
void * ucx_default_realloc(void *ignore, void *data, size_t n)
A wrapper for the standard libc realloc() function.
Definition: allocator.c:54
+
ucx_allocator_free
void(* ucx_allocator_free)(void *pool, void *data)
A function pointer to the allocators free() function.
Definition: allocator.h:83
+
UcxAllocator::calloc
ucx_allocator_calloc calloc
The calloc() function for this allocator.
Definition: allocator.h:101
+
ucx_default_free
void ucx_default_free(void *ignore, void *data)
A wrapper for the standard libc free() function.
Definition: allocator.c:58
+
UcxAllocator::realloc
ucx_allocator_realloc realloc
The realloc() function for this allocator.
Definition: allocator.h:105
+
UcxAllocator::pool
void * pool
Pointer to an area of memory or a complex memory pool.
Definition: allocator.h:93
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/annotated.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/annotated.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,101 @@ + + + + + + + +ucx: Data Structures + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
Data Structures
+
+
+
Here are the data structures with brief descriptions:
+ + + + + + + + + + + + + + + + + + + + + + + +
 Cscstr_tThe UCX string structure for immutable (constant) strings
 Csstr_tThe UCX string structure
 Cucx_memchunkCapsule for destructible memory chunks
 Cucx_regdestrCapsule for data and its destructor
 Cucx_stack_metadataMetadata for each UCX stack element
 CUcxAllocatorUCX allocator data structure containing memory management functions
 CUcxArrayUCX array type
 CUcxAVLNodeUCX AVL Node
 CUcxAVLTreeUCX AVL Tree
 CUcxBufferUCX Buffer
 CUcxKeyStructure to publicly denote a key of a UcxMap
 CUcxListUCX list structure
 CUcxLoggerThe UCX Logger object
 CUcxMapStructure for the UCX map
 CUcxMapElementStructure for an element of a UcxMap
 CUcxMapIteratorStructure for an iterator over a UcxMap
 CUcxMapKeyInternal structure for a key of a UcxMap
 CUcxMempoolUCX mempool structure
 CUcxPropertiesUcxProperties object for parsing properties data
 CUcxStackUCX stack structure
 CUcxTestListStructure for the internal list of test cases
 CUcxTestSuiteA test suite containing multiple test cases
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/array_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/array_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,1376 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/array.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Functions
+
+
array.h File Reference
+
+
+ +

Dynamically allocated array implementation. +More...

+
#include "ucx.h"
+#include "allocator.h"
+
+

Go to the source code of this file.

+ + + + + +

+Data Structures

struct  UcxArray
 UCX array type. More...
 
+ + + + + + + +

+Macros

#define ucx_array_util_set(array, capacity, elmsize, idx, data)
 Sets an element in an arbitrary user defined array. More...
 
#define ucx_array_util_setptr(array, capacity, idx, ptr)
 Stores a pointer in an arbitrary user defined array. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

int ucx_array_util_set_a (UcxAllocator *alloc, void **array, size_t *capacity, size_t elmsize, size_t idx, void *data)
 Sets an element in an arbitrary user defined array. More...
 
int ucx_array_util_setptr_a (UcxAllocator *alloc, void **array, size_t *capacity, size_t idx, void *ptr)
 Stores a pointer in an arbitrary user defined array. More...
 
UcxArray * ucx_array_new (size_t capacity, size_t elemsize)
 Creates a new UCX array with the given capacity and element size. More...
 
UcxArray * ucx_array_new_a (size_t capacity, size_t elemsize, UcxAllocator *allocator)
 Creates a new UCX array using the specified allocator. More...
 
void ucx_array_init (UcxArray *array, size_t capacity, size_t elemsize)
 Initializes a UCX array structure with the given capacity and element size. More...
 
void ucx_array_init_a (UcxArray *array, size_t capacity, size_t elemsize, UcxAllocator *allocator)
 Initializes a UCX array structure using the specified allocator. More...
 
int ucx_array_clone (UcxArray *dest, UcxArray const *src)
 Creates an shallow copy of an array. More...
 
int ucx_array_equals (UcxArray const *array1, UcxArray const *array2, cmp_func cmpfnc, void *data)
 Compares two UCX arrays element-wise by using a compare function. More...
 
void ucx_array_destroy (UcxArray *array)
 Destroys the array. More...
 
void ucx_array_free (UcxArray *array)
 Destroys and frees the array. More...
 
int ucx_array_append_from (UcxArray *array, void *data, size_t count)
 Inserts elements at the end of the array. More...
 
int ucx_array_prepend_from (UcxArray *array, void *data, size_t count)
 Inserts elements at the beginning of the array. More...
 
int ucx_array_set_from (UcxArray *array, size_t index, void *data, size_t count)
 Sets elements starting at the specified index. More...
 
int ucx_array_concat (UcxArray *array1, const UcxArray *array2)
 Concatenates two arrays. More...
 
void * ucx_array_at (UcxArray const *array, size_t index)
 Returns a pointer to the array element at the specified index. More...
 
size_t ucx_array_find (UcxArray const *array, void *elem, cmp_func cmpfnc, void *data)
 Returns the index of an element containing the specified data. More...
 
int ucx_array_contains (UcxArray const *array, void *elem, cmp_func cmpfnc, void *data)
 Checks, if an array contains a specific element. More...
 
void ucx_array_sort (UcxArray *array, cmp_func cmpfnc, void *data)
 Sorts a UcxArray with the best available sort algorithm. More...
 
void ucx_array_remove (UcxArray *array, size_t index)
 Removes an element from the array. More...
 
void ucx_array_remove_fast (UcxArray *array, size_t index)
 Removes an element from the array. More...
 
int ucx_array_shrink (UcxArray *array)
 Shrinks the memory to exactly fit the contents. More...
 
int ucx_array_resize (UcxArray *array, size_t capacity)
 Sets the capacity of the array. More...
 
int ucx_array_reserve (UcxArray *array, size_t capacity)
 Resizes the array only, if the capacity is insufficient. More...
 
int ucx_array_grow (UcxArray *array, size_t count)
 Resizes the capacity, if the specified number of elements would not fit. More...
 
+

Detailed Description

+

Dynamically allocated array implementation.

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ ucx_array_util_set

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_array_util_set( array,
 capacity,
 elmsize,
 idx,
 data 
)
+
+Value:
ucx_array_util_set_a(ucx_default_allocator(), (void**)(array), capacity, \
elmsize, idx, data)
ucx_array_util_set_a
int ucx_array_util_set_a(UcxAllocator *alloc, void **array, size_t *capacity, size_t elmsize, size_t idx, void *data)
Sets an element in an arbitrary user defined array.
Definition: array.c:72
+
ucx_default_allocator
UcxAllocator * ucx_default_allocator()
Returns a pointer to the default allocator.
Definition: allocator.c:41
+
+

Sets an element in an arbitrary user defined array.

+

The data is copied from the specified data location.

+

If the capacity is insufficient, the array is automatically reallocated and the possibly new pointer is stored in the array argument.

+

On reallocation the capacity of the array is doubled until it is sufficient. The new capacity is stored back to capacity.

+
Parameters
+ + + + + + +
arraya pointer to location of the array pointer
capacitya pointer to the capacity
elmsizethe size of each element
idxthe index of the element to set
dataa pointer to the element data
+
+
+
Returns
zero on success or non-zero on error (errno will be set)
+ +
+
+ +

◆ ucx_array_util_setptr

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_array_util_setptr( array,
 capacity,
 idx,
 ptr 
)
+
+Value:
ucx_array_util_setptr_a(ucx_default_allocator(), (void**)(array), \
capacity, idx, ptr)
ucx_default_allocator
UcxAllocator * ucx_default_allocator()
Returns a pointer to the default allocator.
Definition: allocator.c:41
+
ucx_array_util_setptr_a
int ucx_array_util_setptr_a(UcxAllocator *alloc, void **array, size_t *capacity, size_t idx, void *ptr)
Stores a pointer in an arbitrary user defined array.
Definition: array.c:112
+
+

Stores a pointer in an arbitrary user defined array.

+

The element size of the array must be sizeof(void*).

+

If the capacity is insufficient, the array is automatically reallocated and the possibly new pointer is stored in the array argument.

+

On reallocation the capacity of the array is doubled until it is sufficient. The new capacity is stored back to capacity.

+
Parameters
+ + + + + +
arraya pointer to location of the array pointer
capacitya pointer to the capacity
idxthe index of the element to set
ptrthe pointer to store
+
+
+
Returns
zero on success or non-zero on error (errno will be set)
+ +
+
+

Function Documentation

+ +

◆ ucx_array_append_from()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_append_from (UcxArray * array,
void * data,
size_t count 
)
+
+ +

Inserts elements at the end of the array.

+

This is an O(1) operation. The array will automatically grow, if the capacity is exceeded. If a pointer to data is provided, the data is copied into the array with memcpy(). Otherwise the new elements are completely zeroed.

+
Parameters
+ + + + +
arraya pointer the array where to append the data
dataa pointer to the data to insert (may be NULL)
countnumber of elements to copy from data (if data is NULL, zeroed elements are appended)
+
+
+
Returns
zero on success, non-zero if a reallocation was necessary but failed
+
See also
ucx_array_set_from()
+
+ucx_array_append()
+ +
+
+ +

◆ ucx_array_at()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_array_at (UcxArray const * array,
size_t index 
)
+
+ +

Returns a pointer to the array element at the specified index.

+
Parameters
+ + + +
arraythe array to retrieve the element from
indexindex of the element to return
+
+
+
Returns
a pointer to the element at the specified index or NULL, if the index is greater than the array size
+ +
+
+ +

◆ ucx_array_clone()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_array_clone (UcxArray * dest,
UcxArray const * src 
)
+
+ +

Creates an shallow copy of an array.

+

This function clones the specified array by using memcpy(). If the destination capacity is insufficient, an automatic reallocation is attempted.

+

Note: if the destination array is uninitialized, the behavior is undefined.

+
Parameters
+ + + +
destthe array to copy to
srcthe array to copy from
+
+
+
Returns
zero on success, non-zero on reallocation failure.
+ +
+
+ +

◆ ucx_array_concat()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_array_concat (UcxArray * array1,
const UcxArray * array2 
)
+
+ +

Concatenates two arrays.

+

The contents of the second array are appended to the first array in one single operation. The second array is otherwise left untouched.

+

The first array may grow automatically. If this fails, both arrays remain unmodified.

+
Parameters
+ + + +
array1first array
array2second array
+
+
+
Returns
zero on success, non-zero if reallocation was necessary but failed or the element size does not match
+ +
+
+ +

◆ ucx_array_contains()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_contains (UcxArray const * array,
void * elem,
cmp_func cmpfnc,
void * data 
)
+
+ +

Checks, if an array contains a specific element.

+

An element is found, if ucx_array_find() returns a value less than the size.

+
Parameters
+ + + + + +
arraythe array where to search for the data
elemthe element data
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
1, if and only if the array contains the specified element data
+
See also
ucx_array_find()
+ +
+
+ +

◆ ucx_array_destroy()

+ +
+
+ + + + + + + + +
void ucx_array_destroy (UcxArray * array)
+
+ +

Destroys the array.

+

The data is freed and both capacity and count are reset to zero. If the array structure itself has been dynamically allocated, it has to be freed separately.

+
Parameters
+ + +
arraythe array to destroy
+
+
+ +
+
+ +

◆ ucx_array_equals()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_equals (UcxArray const * array1,
UcxArray const * array2,
cmp_func cmpfnc,
void * data 
)
+
+ +

Compares two UCX arrays element-wise by using a compare function.

+

Elements of the two specified arrays are compared by using the specified compare function and the additional data. The type and content of this additional data depends on the cmp_func() used.

+

This function always returns zero, if the element sizes of the arrays do not match and performs no comparisons in this case.

+
Parameters
+ + + + + +
array1the first array
array2the second array
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
1, if and only if the two arrays equal element-wise, 0 otherwise
+ +
+
+ +

◆ ucx_array_find()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
size_t ucx_array_find (UcxArray const * array,
void * elem,
cmp_func cmpfnc,
void * data 
)
+
+ +

Returns the index of an element containing the specified data.

+

This function uses a cmp_func() to compare the data of each list element with the specified data. If no cmp_func is provided, memcmp() is used.

+

If the array contains the data more than once, the index of the first occurrence is returned. If the array does not contain the data, the size of array is returned.

+
Parameters
+ + + + + +
arraythe array where to search for the data
elemthe element data
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
the index of the element containing the specified data or the size of the array, if the data is not found in this array
+ +
+
+ +

◆ ucx_array_free()

+ +
+
+ + + + + + + + +
void ucx_array_free (UcxArray * array)
+
+ +

Destroys and frees the array.

+
Parameters
+ + +
arraythe array to free
+
+
+ +
+
+ +

◆ ucx_array_grow()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_array_grow (UcxArray * array,
size_t count 
)
+
+ +

Resizes the capacity, if the specified number of elements would not fit.

+

A call to ucx_array_grow(array, count) is effectively the same as ucx_array_reserve(array, array->size+count).

+
Parameters
+ + + +
arraya pointer to the array
countthe number of elements that should additionally fit into the array
+
+
+
Returns
zero on success, non-zero if reallocation failed
+ +
+
+ +

◆ ucx_array_init()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ucx_array_init (UcxArray * array,
size_t capacity,
size_t elemsize 
)
+
+ +

Initializes a UCX array structure with the given capacity and element size.

+

The structure must be uninitialized as the data pointer will be overwritten.

+
Parameters
+ + + + +
arraythe structure to initialize
capacitythe initial capacity
elemsizethe element size
+
+
+ +
+
+ +

◆ ucx_array_init_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ucx_array_init_a (UcxArray * array,
size_t capacity,
size_t elemsize,
UcxAllocator * allocator 
)
+
+ +

Initializes a UCX array structure using the specified allocator.

+

The structure must be uninitialized as the data pointer will be overwritten.

+
Parameters
+ + + + + +
arraythe structure to initialize
capacitythe initial capacity
elemsizethe element size
allocatorthe allocator to use
+
+
+ +
+
+ +

◆ ucx_array_new()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxArray* ucx_array_new (size_t capacity,
size_t elemsize 
)
+
+ +

Creates a new UCX array with the given capacity and element size.

+
Parameters
+ + + +
capacitythe initial capacity
elemsizethe element size
+
+
+
Returns
a pointer to a new UCX array structure
+ +
+
+ +

◆ ucx_array_new_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxArray* ucx_array_new_a (size_t capacity,
size_t elemsize,
UcxAllocator * allocator 
)
+
+ +

Creates a new UCX array using the specified allocator.

+
Parameters
+ + + + +
capacitythe initial capacity
elemsizethe element size
allocatorthe allocator to use
+
+
+
Returns
a pointer to new UCX array structure
+ +
+
+ +

◆ ucx_array_prepend_from()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_prepend_from (UcxArray * array,
void * data,
size_t count 
)
+
+ +

Inserts elements at the beginning of the array.

+

This is an expensive operation, because the contents must be moved. If there is no particular reason to prepend data, you should use ucx_array_append_from() instead.

+
Parameters
+ + + + +
arraya pointer the array where to prepend the data
dataa pointer to the data to insert (may be NULL)
countnumber of elements to copy from data (if data is NULL, zeroed elements are inserted)
+
+
+
Returns
zero on success, non-zero if a reallocation was necessary but failed
+
See also
ucx_array_append_from()
+
+ucx_array_set_from()
+
+ucx_array_prepend()
+ +
+
+ +

◆ ucx_array_remove()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_array_remove (UcxArray * array,
size_t index 
)
+
+ +

Removes an element from the array.

+

This is in general an expensive operation, because several elements may be moved. If the order of the elements is not relevant, use ucx_array_remove_fast() instead.

+
Parameters
+ + + +
arraypointer to the array from which the element shall be removed
indexthe index of the element to remove
+
+
+ +
+
+ +

◆ ucx_array_remove_fast()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_array_remove_fast (UcxArray * array,
size_t index 
)
+
+ +

Removes an element from the array.

+

This is an O(1) operation, but does not maintain the order of the elements. The last element in the array is moved to the location of the removed element.

+
Parameters
+ + + +
arraypointer to the array from which the element shall be removed
indexthe index of the element to remove
+
+
+ +
+
+ +

◆ ucx_array_reserve()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_array_reserve (UcxArray * array,
size_t capacity 
)
+
+ +

Resizes the array only, if the capacity is insufficient.

+

If the requested capacity is smaller than the current capacity, this function does nothing.

+
Parameters
+ + + +
arraya pointer to the array
capacitythe guaranteed capacity
+
+
+
Returns
zero on success, non-zero if reallocation failed
+ +
+
+ +

◆ ucx_array_resize()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_array_resize (UcxArray * array,
size_t capacity 
)
+
+ +

Sets the capacity of the array.

+

If the new capacity is smaller than the size of the array, the elements are removed and the size is adjusted accordingly.

+
Parameters
+ + + +
arraya pointer to the array
capacitythe new capacity
+
+
+
Returns
zero on success, non-zero if reallocation failed
+ +
+
+ +

◆ ucx_array_set_from()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_set_from (UcxArray * array,
size_t index,
void * data,
size_t count 
)
+
+ +

Sets elements starting at the specified index.

+

If the any index is out of bounds, the array automatically grows. The pointer to the data may be NULL, in which case the elements are zeroed.

+
Parameters
+ + + + + +
arraya pointer the array where to set the data
indexthe index of the element to set
dataa pointer to the data to insert (may be NULL)
countnumber of elements to copy from data (if data is NULL, the memory in the array is zeroed)
+
+
+
Returns
zero on success, non-zero if a reallocation was necessary but failed
+
See also
ucx_array_append_from()
+
+ucx_array_set()
+ +
+
+ +

◆ ucx_array_shrink()

+ +
+
+ + + + + + + + +
int ucx_array_shrink (UcxArray * array)
+
+ +

Shrinks the memory to exactly fit the contents.

+

After this operation, the capacity equals the size.

+
Parameters
+ + +
arraya pointer to the array
+
+
+
Returns
zero on success, non-zero if reallocation failed
+ +
+
+ +

◆ ucx_array_sort()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ucx_array_sort (UcxArray * array,
cmp_func cmpfnc,
void * data 
)
+
+ +

Sorts a UcxArray with the best available sort algorithm.

+

The qsort_r() function is used, if available (glibc, FreeBSD or MacOS). The order of arguments is automatically adjusted for the FreeBSD and MacOS version of qsort_r().

+

If qsort_r() is not available, a merge sort algorithm is used, which is guaranteed to use no more additional memory than for exactly one element.

+
Parameters
+ + + + +
arraythe array to sort
cmpfncthe function that shall be used to compare the element data
dataadditional data for the cmp_func() or NULL
+
+
+ +
+
+ +

◆ ucx_array_util_set_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_util_set_a (UcxAllocator * alloc,
void ** array,
size_t * capacity,
size_t elmsize,
size_t idx,
void * data 
)
+
+ +

Sets an element in an arbitrary user defined array.

+

The data is copied from the specified data location.

+

If the capacity is insufficient, the array is automatically reallocated using the specified allocator and the possibly new pointer is stored in the array argument.

+

On reallocation the capacity of the array is doubled until it is sufficient. The new capacity is stored back to capacity.

+
Parameters
+ + + + + + + +
allocthe allocator that shall be used to reallocate the array
arraya pointer to location of the array pointer
capacitya pointer to the capacity
elmsizethe size of each element
idxthe index of the element to set
dataa pointer to the element data
+
+
+
Returns
zero on success or non-zero on error (errno will be set)
+ +
+
+ +

◆ ucx_array_util_setptr_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_array_util_setptr_a (UcxAllocator * alloc,
void ** array,
size_t * capacity,
size_t idx,
void * ptr 
)
+
+ +

Stores a pointer in an arbitrary user defined array.

+

The element size of the array must be sizeof(void*).

+

If the capacity is insufficient, the array is automatically reallocated using the specified allocator and the possibly new pointer is stored in the array argument.

+

On reallocation the capacity of the array is doubled until it is sufficient. The new capacity is stored back to capacity.

+
Parameters
+ + + + + + +
allocthe allocator that shall be used to reallocate the array
arraya pointer to location of the array pointer
capacitya pointer to the capacity
idxthe index of the element to set
ptrthe pointer to store
+
+
+
Returns
zero on success or non-zero on error (errno will be set)
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/array_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/array_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,113 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/array.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
array.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
36 #ifndef UCX_ARRAY_H
37 #define UCX_ARRAY_H
38 
39 #include "ucx.h"
40 #include "allocator.h"
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
49 typedef struct {
53  size_t capacity;
57  size_t size;
61  size_t elemsize;
65  void* data;
69  UcxAllocator* allocator;
70 } UcxArray;
71 
89 #define ucx_array_util_set(array, capacity, elmsize, idx, data) \
90  ucx_array_util_set_a(ucx_default_allocator(), (void**)(array), capacity, \
91  elmsize, idx, data)
92 
112 int ucx_array_util_set_a(UcxAllocator* alloc, void** array, size_t* capacity,
113  size_t elmsize, size_t idx, void* data);
114 
131 #define ucx_array_util_setptr(array, capacity, idx, ptr) \
132  ucx_array_util_setptr_a(ucx_default_allocator(), (void**)(array), \
133  capacity, idx, ptr)
134 
153 int ucx_array_util_setptr_a(UcxAllocator* alloc, void** array, size_t* capacity,
154  size_t idx, void* ptr);
155 
156 
163 UcxArray* ucx_array_new(size_t capacity, size_t elemsize);
164 
173 UcxArray* ucx_array_new_a(size_t capacity, size_t elemsize,
174  UcxAllocator* allocator);
175 
184 void ucx_array_init(UcxArray* array, size_t capacity, size_t elemsize);
185 
195 void ucx_array_init_a(UcxArray* array, size_t capacity, size_t elemsize,
196  UcxAllocator* allocator);
197 
211 int ucx_array_clone(UcxArray* dest, UcxArray const* src);
212 
213 
230 int ucx_array_equals(UcxArray const *array1, UcxArray const *array2,
231  cmp_func cmpfnc, void* data);
232 
242 void ucx_array_destroy(UcxArray *array);
243 
249 void ucx_array_free(UcxArray *array);
250 
267 int ucx_array_append_from(UcxArray *array, void *data, size_t count);
268 
269 
286 int ucx_array_prepend_from(UcxArray *array, void *data, size_t count);
287 
288 
304 int ucx_array_set_from(UcxArray *array, size_t index, void *data, size_t count);
305 
320 int ucx_array_concat(UcxArray *array1, const UcxArray *array2);
321 
330 void *ucx_array_at(UcxArray const* array, size_t index);
331 
349 size_t ucx_array_find(UcxArray const *array, void *elem,
350  cmp_func cmpfnc, void *data);
351 
364 int ucx_array_contains(UcxArray const *array, void *elem,
365  cmp_func cmpfnc, void *data);
366 
381 void ucx_array_sort(UcxArray* array, cmp_func cmpfnc, void *data);
382 
393 void ucx_array_remove(UcxArray *array, size_t index);
394 
405 void ucx_array_remove_fast(UcxArray *array, size_t index);
406 
415 int ucx_array_shrink(UcxArray* array);
416 
427 int ucx_array_resize(UcxArray* array, size_t capacity);
428 
439 int ucx_array_reserve(UcxArray* array, size_t capacity);
440 
452 int ucx_array_grow(UcxArray* array, size_t count);
453 
454 
455 #ifdef __cplusplus
456 }
457 #endif
458 
459 #endif /* UCX_ARRAY_H */
460 
ucx_array_append_from
int ucx_array_append_from(UcxArray *array, void *data, size_t count)
Inserts elements at the end of the array.
Definition: array.c:206
+
ucx_array_prepend_from
int ucx_array_prepend_from(UcxArray *array, void *data, size_t count)
Inserts elements at the beginning of the array.
Definition: array.c:221
+
ucx_array_grow
int ucx_array_grow(UcxArray *array, size_t count)
Resizes the capacity, if the specified number of elements would not fit.
Definition: array.c:465
+
cmp_func
int(* cmp_func)(const void *, const void *, void *)
Function pointer to a compare function.
Definition: ucx.h:84
+
ucx_array_shrink
int ucx_array_shrink(UcxArray *array)
Shrinks the memory to exactly fit the contents.
Definition: array.c:418
+
ucx_array_concat
int ucx_array_concat(UcxArray *array1, const UcxArray *array2)
Concatenates two arrays.
Definition: array.c:259
+
ucx.h
Main UCX Header providing most common definitions.
+
UcxArray::capacity
size_t capacity
The current capacity of the array.
Definition: array.h:53
+
ucx_array_util_set_a
int ucx_array_util_set_a(UcxAllocator *alloc, void **array, size_t *capacity, size_t elmsize, size_t idx, void *data)
Sets an element in an arbitrary user defined array.
Definition: array.c:72
+
ucx_array_equals
int ucx_array_equals(UcxArray const *array1, UcxArray const *array2, cmp_func cmpfnc, void *data)
Compares two UCX arrays element-wise by using a compare function.
Definition: array.c:166
+
ucx_array_init_a
void ucx_array_init_a(UcxArray *array, size_t capacity, size_t elemsize, UcxAllocator *allocator)
Initializes a UCX array structure using the specified allocator.
Definition: array.c:136
+
ucx_array_sort
void ucx_array_sort(UcxArray *array, cmp_func cmpfnc, void *data)
Sorts a UcxArray with the best available sort algorithm.
Definition: array.c:395
+
UcxArray::data
void * data
A pointer to the data.
Definition: array.h:65
+
ucx_array_new
UcxArray * ucx_array_new(size_t capacity, size_t elemsize)
Creates a new UCX array with the given capacity and element size.
Definition: array.c:119
+
ucx_array_remove
void ucx_array_remove(UcxArray *array, size_t index)
Removes an element from the array.
Definition: array.c:400
+
UcxArray::allocator
UcxAllocator * allocator
The allocator used for the data.
Definition: array.h:69
+
ucx_array_set_from
int ucx_array_set_from(UcxArray *array, size_t index, void *data, size_t count)
Sets elements starting at the specified index.
Definition: array.c:240
+
ucx_array_remove_fast
void ucx_array_remove_fast(UcxArray *array, size_t index)
Removes an element from the array.
Definition: array.c:409
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
ucx_array_contains
int ucx_array_contains(UcxArray const *array, void *elem, cmp_func cmpfnc, void *data)
Checks, if an array contains a specific element.
Definition: array.c:309
+
ucx_array_find
size_t ucx_array_find(UcxArray const *array, void *elem, cmp_func cmpfnc, void *data)
Returns the index of an element containing the specified data.
Definition: array.c:286
+
UcxArray
UCX array type.
Definition: array.h:49
+
UcxArray::size
size_t size
The actual number of elements in the array.
Definition: array.h:57
+
ucx_array_destroy
void ucx_array_destroy(UcxArray *array)
Destroys the array.
Definition: array.c:194
+
ucx_array_util_setptr_a
int ucx_array_util_setptr_a(UcxAllocator *alloc, void **array, size_t *capacity, size_t idx, void *ptr)
Stores a pointer in an arbitrary user defined array.
Definition: array.c:112
+
allocator.h
Allocator for custom memory management.
+
ucx_array_free
void ucx_array_free(UcxArray *array)
Destroys and frees the array.
Definition: array.c:201
+
ucx_array_clone
int ucx_array_clone(UcxArray *dest, UcxArray const *src)
Creates an shallow copy of an array.
Definition: array.c:151
+
ucx_array_at
void * ucx_array_at(UcxArray const *array, size_t index)
Returns a pointer to the array element at the specified index.
Definition: array.c:280
+
ucx_array_resize
int ucx_array_resize(UcxArray *array, size_t capacity)
Sets the capacity of the array.
Definition: array.c:430
+
ucx_array_init
void ucx_array_init(UcxArray *array, size_t capacity, size_t elemsize)
Initializes a UCX array structure with the given capacity and element size.
Definition: array.c:132
+
UcxArray::elemsize
size_t elemsize
The size of an individual element in bytes.
Definition: array.h:61
+
ucx_array_reserve
int ucx_array_reserve(UcxArray *array, size_t capacity)
Resizes the array only, if the capacity is insufficient.
Definition: array.c:449
+
ucx_array_new_a
UcxArray * ucx_array_new_a(size_t capacity, size_t elemsize, UcxAllocator *allocator)
Creates a new UCX array using the specified allocator.
Definition: array.c:123
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/avl_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/avl_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,883 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/avl.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Typedefs | +Functions
+
+
avl.h File Reference
+
+
+ +

AVL tree implementation. +More...

+
#include "ucx.h"
+#include "allocator.h"
+#include <inttypes.h>
+
+

Go to the source code of this file.

+ + + + + + + + +

+Data Structures

struct  UcxAVLNode
 UCX AVL Node. More...
 
struct  UcxAVLTree
 UCX AVL Tree. More...
 
+ + + + + + + + + + + + + + + + +

+Macros

#define ucx_avl_default_new()   ucx_avl_new_a(ucx_cmp_ptr, ucx_default_allocator())
 Macro for initializing a new UcxAVLTree with the default allocator and a ucx_cmp_ptr() compare function. More...
 
+#define UCX_AVL_FIND_EXACT   0
 A mode for ucx_avl_find_node() with the same behavior as ucx_avl_get_node().
 
+#define UCX_AVL_FIND_LOWER_BOUNDED   1
 A mode for ucx_avl_find_node() finding the node whose key is at least as large as the specified key.
 
+#define UCX_AVL_FIND_UPPER_BOUNDED   2
 A mode for ucx_avl_find_node() finding the node whose key is at most as large as the specified key.
 
#define UCX_AVL_FIND_CLOSEST   3
 A mode for ucx_avl_find_node() finding the node with a key that is as close to the specified key as possible. More...
 
+ + + + +

+Typedefs

typedef struct UcxAVLNode UcxAVLNode
 UCX AVL Node type. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

UcxAVLTree * ucx_avl_new (cmp_func cmpfunc)
 Initializes a new UcxAVLTree with a default allocator. More...
 
UcxAVLTree * ucx_avl_new_a (cmp_func cmpfunc, UcxAllocator *allocator)
 Initializes a new UcxAVLTree with the specified allocator. More...
 
void ucx_avl_free (UcxAVLTree *tree)
 Destroys a UcxAVLTree. More...
 
void ucx_avl_free_content (UcxAVLTree *tree, ucx_destructor destr)
 Frees the contents of a UcxAVLTree. More...
 
UcxAVLNode * ucx_avl_get_node (UcxAVLTree *tree, intptr_t key)
 Gets the node from the tree, that is associated with the specified key. More...
 
void * ucx_avl_get (UcxAVLTree *tree, intptr_t key)
 Gets the value from the tree, that is associated with the specified key. More...
 
UcxAVLNode * ucx_avl_find_node (UcxAVLTree *tree, intptr_t key, distance_func dfnc, int mode)
 Finds a node within the tree. More...
 
void * ucx_avl_find (UcxAVLTree *tree, intptr_t key, distance_func dfnc, int mode)
 Finds a value within the tree. More...
 
int ucx_avl_put (UcxAVLTree *tree, intptr_t key, void *value)
 Puts a key/value pair into the tree. More...
 
int ucx_avl_put_s (UcxAVLTree *tree, intptr_t key, void *value, void **oldvalue)
 Puts a key/value pair into the tree. More...
 
int ucx_avl_remove_node (UcxAVLTree *tree, UcxAVLNode *node)
 Removes a node from the AVL tree. More...
 
int ucx_avl_remove (UcxAVLTree *tree, intptr_t key)
 Removes an element from the AVL tree. More...
 
int ucx_avl_remove_s (UcxAVLTree *tree, intptr_t key, intptr_t *oldkey, void **oldvalue)
 Removes an element from the AVL tree. More...
 
size_t ucx_avl_count (UcxAVLTree *tree)
 Counts the nodes in the specified UcxAVLTree. More...
 
UcxAVLNode * ucx_avl_pred (UcxAVLNode *node)
 Finds the in-order predecessor of the given node. More...
 
UcxAVLNode * ucx_avl_succ (UcxAVLNode *node)
 Finds the in-order successor of the given node. More...
 
+

Detailed Description

+

AVL tree implementation.

+

This binary search tree implementation allows average O(1) insertion and removal of elements (excluding binary search time).

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ ucx_avl_default_new

+ +
+
+ + + + + + + +
#define ucx_avl_default_new()   ucx_avl_new_a(ucx_cmp_ptr, ucx_default_allocator())
+
+ +

Macro for initializing a new UcxAVLTree with the default allocator and a ucx_cmp_ptr() compare function.

+
Returns
a new default UcxAVLTree object
+ +
+
+ +

◆ UCX_AVL_FIND_CLOSEST

+ +
+
+ + + + +
#define UCX_AVL_FIND_CLOSEST   3
+
+ +

A mode for ucx_avl_find_node() finding the node with a key that is as close to the specified key as possible.

+

If the key is present, the behavior is like ucx_avl_get_node(). This mode only returns NULL on empty trees.

+ +
+
+

Typedef Documentation

+ +

◆ UcxAVLNode

+ +
+
+ + + + +
typedef struct UcxAVLNode UcxAVLNode
+
+ +

UCX AVL Node type.

+
See also
UcxAVLNode
+ +
+
+

Function Documentation

+ +

◆ ucx_avl_count()

+ +
+
+ + + + + + + + +
size_t ucx_avl_count (UcxAVLTree * tree)
+
+ +

Counts the nodes in the specified UcxAVLTree.

+
Parameters
+ + +
treethe AVL tree
+
+
+
Returns
the node count
+ +
+
+ +

◆ ucx_avl_find()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void* ucx_avl_find (UcxAVLTree * tree,
intptr_t key,
distance_func dfnc,
int mode 
)
+
+ +

Finds a value within the tree.

+

See ucx_avl_find_node() for details.

+
Parameters
+ + + + + +
treethe UcxAVLTree
keythe key
dfncthe distance function
modethe find mode
+
+
+
Returns
the value (or NULL, if no value can be found)
+ +
+
+ +

◆ ucx_avl_find_node()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxAVLNode* ucx_avl_find_node (UcxAVLTree * tree,
intptr_t key,
distance_func dfnc,
int mode 
)
+
+ +

Finds a node within the tree.

+

The following modes are supported:

+

The distance function provided MUST agree with the compare function of the AVL tree.

+
Parameters
+ + + + + +
treethe UcxAVLTree
keythe key
dfncthe distance function
modethe find mode
+
+
+
Returns
the node (or NULL, if no node can be found)
+ +
+
+ +

◆ ucx_avl_free()

+ +
+
+ + + + + + + + +
void ucx_avl_free (UcxAVLTree * tree)
+
+ +

Destroys a UcxAVLTree.

+

Note, that the contents are not automatically freed. Use may use ucx_avl_free_content() before calling this function.

+
Parameters
+ + +
treethe tree to destroy
+
+
+
See also
ucx_avl_free_content()
+ +
+
+ +

◆ ucx_avl_free_content()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_avl_free_content (UcxAVLTree * tree,
ucx_destructor destr 
)
+
+ +

Frees the contents of a UcxAVLTree.

+

This is a convenience function that iterates over the tree and passes all values to the specified destructor function.

+

If no destructor is specified (NULL), the free() function of the tree's own allocator is used.

+

You must ensure, that it is valid to pass each value in the map to the same destructor function.

+

You should free the entire tree afterwards, as the contents will be invalid.

+
Parameters
+ + + +
treefor which the contents shall be freed
destroptional pointer to a destructor function
+
+
+
See also
ucx_avl_free()
+ +
+
+ +

◆ ucx_avl_get()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_avl_get (UcxAVLTree * tree,
intptr_t key 
)
+
+ +

Gets the value from the tree, that is associated with the specified key.

+
Parameters
+ + + +
treethe UcxAVLTree
keythe key
+
+
+
Returns
the value (or NULL, if the key is not present)
+ +
+
+ +

◆ ucx_avl_get_node()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxAVLNode* ucx_avl_get_node (UcxAVLTree * tree,
intptr_t key 
)
+
+ +

Gets the node from the tree, that is associated with the specified key.

+
Parameters
+ + + +
treethe UcxAVLTree
keythe key
+
+
+
Returns
the node (or NULL, if the key is not present)
+ +
+
+ +

◆ ucx_avl_new()

+ +
+
+ + + + + + + + +
UcxAVLTree* ucx_avl_new (cmp_func cmpfunc)
+
+ +

Initializes a new UcxAVLTree with a default allocator.

+
Parameters
+ + +
cmpfuncthe compare function that shall be used
+
+
+
Returns
a new UcxAVLTree object
+
See also
ucx_avl_new_a()
+ +
+
+ +

◆ ucx_avl_new_a()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxAVLTree* ucx_avl_new_a (cmp_func cmpfunc,
UcxAllocator * allocator 
)
+
+ +

Initializes a new UcxAVLTree with the specified allocator.

+

The cmpfunc should be capable of comparing two keys within this AVL tree. So if you want to use null terminated strings as keys, you could use the ucx_cmp_str() function here.

+
Parameters
+ + + +
cmpfuncthe compare function that shall be used
allocatorthe UcxAllocator that shall be used
+
+
+
Returns
a new UcxAVLTree object
+ +
+
+ +

◆ ucx_avl_pred()

+ +
+
+ + + + + + + + +
UcxAVLNode* ucx_avl_pred (UcxAVLNode * node)
+
+ +

Finds the in-order predecessor of the given node.

+
Parameters
+ + +
nodean AVL node
+
+
+
Returns
the in-order predecessor of the given node, or NULL if the given node is the in-order minimum
+ +
+
+ +

◆ ucx_avl_put()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_avl_put (UcxAVLTree * tree,
intptr_t key,
void * value 
)
+
+ +

Puts a key/value pair into the tree.

+

Attention: use this function only, if a possible old value does not need to be preserved.

+
Parameters
+ + + + +
treethe UcxAVLTree
keythe key
valuethe new value
+
+
+
Returns
zero, if and only if the operation succeeded
+ +
+
+ +

◆ ucx_avl_put_s()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_avl_put_s (UcxAVLTree * tree,
intptr_t key,
void * value,
void ** oldvalue 
)
+
+ +

Puts a key/value pair into the tree.

+

This is a secure function which saves the old value to the variable pointed at by oldvalue.

+
Parameters
+ + + + + +
treethe UcxAVLTree
keythe key
valuethe new value
oldvalueoptional: a pointer to the location where a possible old value shall be stored
+
+
+
Returns
zero, if and only if the operation succeeded
+ +
+
+ +

◆ ucx_avl_remove()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_avl_remove (UcxAVLTree * tree,
intptr_t key 
)
+
+ +

Removes an element from the AVL tree.

+
Parameters
+ + + +
treethe UcxAVLTree
keythe key
+
+
+
Returns
zero, if and only if an element has been removed
+ +
+
+ +

◆ ucx_avl_remove_node()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_avl_remove_node (UcxAVLTree * tree,
UcxAVLNode * node 
)
+
+ +

Removes a node from the AVL tree.

+

Note: the specified node is logically removed. The tree implementation decides which memory area is freed. In most cases the here provided node is freed, so its further use is generally undefined.

+
Parameters
+ + + +
treethe UcxAVLTree
nodethe node to remove
+
+
+
Returns
zero, if and only if an element has been removed
+ +
+
+ +

◆ ucx_avl_remove_s()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_avl_remove_s (UcxAVLTree * tree,
intptr_t key,
intptr_t * oldkey,
void ** oldvalue 
)
+
+ +

Removes an element from the AVL tree.

+

This is a secure function which saves the old key and value data from node to the variables at the location of oldkey and oldvalue (if specified), so they can be freed afterwards (if necessary).

+

Note: the returned key in oldkey is possibly not the same as the provided key for the lookup (in terms of memory location).

+
Parameters
+ + + + + +
treethe UcxAVLTree
keythe key of the element to remove
oldkeyoptional: a pointer to the location where the old key shall be stored
oldvalueoptional: a pointer to the location where the old value shall be stored
+
+
+
Returns
zero, if and only if an element has been removed
+ +
+
+ +

◆ ucx_avl_succ()

+ +
+
+ + + + + + + + +
UcxAVLNode* ucx_avl_succ (UcxAVLNode * node)
+
+ +

Finds the in-order successor of the given node.

+
Parameters
+ + +
nodean AVL node
+
+
+
Returns
the in-order successor of the given node, or NULL if the given node is the in-order maximum
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/avl_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/avl_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,113 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/avl.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
avl.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 
42 #ifndef UCX_AVL_H
43 #define UCX_AVL_H
44 
45 #include "ucx.h"
46 #include "allocator.h"
47 #include <inttypes.h>
48 
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52 
58 typedef struct UcxAVLNode UcxAVLNode;
59 
63 struct UcxAVLNode {
67  intptr_t key;
71  void *value;
75  size_t height;
79  UcxAVLNode *parent;
83  UcxAVLNode *left;
87  UcxAVLNode *right;
88 };
89 
93 typedef struct {
97  UcxAllocator *allocator;
101  UcxAVLNode *root;
106  cmp_func cmpfunc;
111  void *userdata;
112 } UcxAVLTree;
113 
121 UcxAVLTree *ucx_avl_new(cmp_func cmpfunc);
122 
134 UcxAVLTree *ucx_avl_new_a(cmp_func cmpfunc, UcxAllocator *allocator);
135 
145 void ucx_avl_free(UcxAVLTree *tree);
146 
165 void ucx_avl_free_content(UcxAVLTree *tree, ucx_destructor destr);
166 
173 #define ucx_avl_default_new() \
174  ucx_avl_new_a(ucx_cmp_ptr, ucx_default_allocator())
175 
182 UcxAVLNode *ucx_avl_get_node(UcxAVLTree *tree, intptr_t key);
183 
190 void *ucx_avl_get(UcxAVLTree *tree, intptr_t key);
191 
196 #define UCX_AVL_FIND_EXACT 0
197 
201 #define UCX_AVL_FIND_LOWER_BOUNDED 1
202 
206 #define UCX_AVL_FIND_UPPER_BOUNDED 2
207 
213 #define UCX_AVL_FIND_CLOSEST 3
214 
238 UcxAVLNode *ucx_avl_find_node(UcxAVLTree *tree, intptr_t key,
239  distance_func dfnc, int mode);
240 
251 void *ucx_avl_find(UcxAVLTree *tree, intptr_t key,
252  distance_func dfnc, int mode);
253 
265 int ucx_avl_put(UcxAVLTree *tree, intptr_t key, void *value);
266 
280 int ucx_avl_put_s(UcxAVLTree *tree, intptr_t key, void *value, void **oldvalue);
281 
293 int ucx_avl_remove_node(UcxAVLTree *tree, UcxAVLNode *node);
294 
302 int ucx_avl_remove(UcxAVLTree *tree, intptr_t key);
303 
322 int ucx_avl_remove_s(UcxAVLTree *tree, intptr_t key,
323  intptr_t *oldkey, void **oldvalue);
324 
330 size_t ucx_avl_count(UcxAVLTree *tree);
331 
338 UcxAVLNode* ucx_avl_pred(UcxAVLNode* node);
339 
346 UcxAVLNode* ucx_avl_succ(UcxAVLNode* node);
347 
348 #ifdef __cplusplus
349 }
350 #endif
351 
352 #endif /* UCX_AVL_H */
353 
ucx_avl_new
UcxAVLTree * ucx_avl_new(cmp_func cmpfunc)
Initializes a new UcxAVLTree with a default allocator.
Definition: avl.c:109
+
ucx_avl_remove
int ucx_avl_remove(UcxAVLTree *tree, intptr_t key)
Removes an element from the AVL tree.
Definition: avl.c:266
+
UcxAVLNode
UCX AVL Node.
Definition: avl.h:63
+
cmp_func
int(* cmp_func)(const void *, const void *, void *)
Function pointer to a compare function.
Definition: ucx.h:84
+
UcxAVLNode::parent
UcxAVLNode * parent
Parent node.
Definition: avl.h:79
+
ucx_avl_pred
UcxAVLNode * ucx_avl_pred(UcxAVLNode *node)
Finds the in-order predecessor of the given node.
Definition: avl.c:335
+
ucx_avl_put
int ucx_avl_put(UcxAVLTree *tree, intptr_t key, void *value)
Puts a key/value pair into the tree.
Definition: avl.c:211
+
ucx.h
Main UCX Header providing most common definitions.
+
UcxAVLTree
UCX AVL Tree.
Definition: avl.h:93
+
ucx_avl_count
size_t ucx_avl_count(UcxAVLTree *tree)
Counts the nodes in the specified UcxAVLTree.
Definition: avl.c:331
+
ucx_avl_new_a
UcxAVLTree * ucx_avl_new_a(cmp_func cmpfunc, UcxAllocator *allocator)
Initializes a new UcxAVLTree with the specified allocator.
Definition: avl.c:113
+
UcxAVLTree::userdata
void * userdata
Custom user data.
Definition: avl.h:111
+
ucx_avl_remove_node
int ucx_avl_remove_node(UcxAVLTree *tree, UcxAVLNode *node)
Removes a node from the AVL tree.
Definition: avl.c:270
+
UcxAVLTree::cmpfunc
cmp_func cmpfunc
Compare function that shall be used to compare the UcxAVLNode keys.
Definition: avl.h:106
+
ucx_avl_succ
UcxAVLNode * ucx_avl_succ(UcxAVLNode *node)
Finds the in-order successor of the given node.
Definition: avl.c:355
+
ucx_avl_free_content
void ucx_avl_free_content(UcxAVLTree *tree, ucx_destructor destr)
Frees the contents of a UcxAVLTree.
Definition: avl.c:152
+
UcxAVLTree::allocator
UcxAllocator * allocator
The UcxAllocator that shall be used to manage the memory for node data.
Definition: avl.h:97
+
ucx_avl_remove_s
int ucx_avl_remove_s(UcxAVLTree *tree, intptr_t key, intptr_t *oldkey, void **oldvalue)
Removes an element from the AVL tree.
Definition: avl.c:274
+
ucx_avl_find
void * ucx_avl_find(UcxAVLTree *tree, intptr_t key, distance_func dfnc, int mode)
Finds a value within the tree.
Definition: avl.c:205
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
ucx_avl_put_s
int ucx_avl_put_s(UcxAVLTree *tree, intptr_t key, void *value, void **oldvalue)
Puts a key/value pair into the tree.
Definition: avl.c:215
+
UcxAVLTree::root
UcxAVLNode * root
Root node of the tree.
Definition: avl.h:101
+
distance_func
intmax_t(* distance_func)(const void *, const void *, void *)
Function pointer to a distance function.
Definition: ucx.h:93
+
allocator.h
Allocator for custom memory management.
+
ucx_avl_get
void * ucx_avl_get(UcxAVLTree *tree, intptr_t key)
Gets the value from the tree, that is associated with the specified key.
Definition: avl.c:166
+
UcxAVLNode::left
UcxAVLNode * left
Root node of left subtree.
Definition: avl.h:83
+
ucx_avl_free
void ucx_avl_free(UcxAVLTree *tree)
Destroys a UcxAVLTree.
Definition: avl.c:133
+
UcxAVLNode::value
void * value
Data contained by this node.
Definition: avl.h:71
+
ucx_avl_find_node
UcxAVLNode * ucx_avl_find_node(UcxAVLTree *tree, intptr_t key, distance_func dfnc, int mode)
Finds a node within the tree.
Definition: avl.c:171
+
UcxAVLNode::key
intptr_t key
The key for this node.
Definition: avl.h:67
+
UcxAVLNode::right
UcxAVLNode * right
Root node of right subtree.
Definition: avl.h:87
+
ucx_avl_get_node
UcxAVLNode * ucx_avl_get_node(UcxAVLTree *tree, intptr_t key)
Gets the node from the tree, that is associated with the specified key.
Definition: avl.c:156
+
UcxAVLNode::height
size_t height
The height of this (sub)-tree.
Definition: avl.h:75
+
ucx_destructor
void(* ucx_destructor)(void *)
A function pointer to a destructor function.
Definition: ucx.h:72
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/bc_s.png Binary file docs/api-2.1/bc_s.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/bdwn.png Binary file docs/api-2.1/bdwn.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/buffer_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/buffer_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,844 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/buffer.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Functions
+
+
buffer.h File Reference
+
+
+ +

Advanced buffer implementation. +More...

+
#include "ucx.h"
+#include <sys/types.h>
+#include <stdio.h>
+
+

Go to the source code of this file.

+ + + + + +

+Data Structures

struct  UcxBuffer
 UCX Buffer. More...
 
+ + + + + + + + + + + + + + + + + + + +

+Macros

+#define UCX_BUFFER_DEFAULT   0x00
 No buffer features enabled (all flags cleared).
 
+#define UCX_BUFFER_AUTOFREE   0x01
 If this flag is enabled, the buffer will automatically free its contents.
 
+#define UCX_BUFFER_AUTOEXTEND   0x02
 If this flag is enabled, the buffer will automatically extends its capacity.
 
#define ucx_buffer_clone(src, flags)   ucx_buffer_extract(src, 0, (src)->capacity, flags)
 A shorthand macro for the full extraction of the buffer. More...
 
#define ucx_buffer_clear(buffer)
 Clears the buffer by resetting the position and deleting the data. More...
 
#define ucx_buffer_to_sstr(buffer)   sstrn((buffer)->space, (buffer)->size)
 Returns the complete buffer content as sstr_t. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

UcxBuffer * ucx_buffer_new (void *space, size_t capacity, int flags)
 Creates a new buffer. More...
 
void ucx_buffer_free (UcxBuffer *buffer)
 Destroys a buffer. More...
 
UcxBuffer * ucx_buffer_extract (UcxBuffer *src, size_t start, size_t length, int flags)
 Creates a new buffer and fills it with extracted content from another buffer. More...
 
int ucx_buffer_shift (UcxBuffer *buffer, off_t shift)
 Shifts the contents of the buffer by the given offset. More...
 
int ucx_buffer_shift_right (UcxBuffer *buffer, size_t shift)
 Shifts the buffer to the right. More...
 
int ucx_buffer_shift_left (UcxBuffer *buffer, size_t shift)
 Shifts the buffer to the left. More...
 
int ucx_buffer_seek (UcxBuffer *buffer, off_t offset, int whence)
 Moves the position of the buffer. More...
 
int ucx_buffer_eof (UcxBuffer *buffer)
 Tests, if the buffer position has exceeded the buffer capacity. More...
 
int ucx_buffer_extend (UcxBuffer *buffer, size_t additional_bytes)
 Extends the capacity of the buffer. More...
 
size_t ucx_buffer_write (const void *ptr, size_t size, size_t nitems, UcxBuffer *buffer)
 Writes data to a UcxBuffer. More...
 
size_t ucx_buffer_read (void *ptr, size_t size, size_t nitems, UcxBuffer *buffer)
 Reads data from a UcxBuffer. More...
 
int ucx_buffer_putc (UcxBuffer *buffer, int c)
 Writes a character to a buffer. More...
 
int ucx_buffer_getc (UcxBuffer *buffer)
 Gets a character from a buffer. More...
 
size_t ucx_buffer_puts (UcxBuffer *buffer, const char *str)
 Writes a string to a buffer. More...
 
+

Detailed Description

+

Advanced buffer implementation.

+

Instances of UcxBuffer can be used to read from or to write to like one would do with a stream. This allows the use of ucx_stream_copy() to copy contents from one buffer to another.

+

Some features for convenient use of the buffer can be enabled. See the documentation of the macro constants for more information.

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ ucx_buffer_clear

+ +
+
+ + + + + + + + +
#define ucx_buffer_clear( buffer)
+
+Value:
memset((buffer)->space, 0, (buffer)->size); \
(buffer)->size = 0; (buffer)->pos = 0;
+

Clears the buffer by resetting the position and deleting the data.

+

The data is deleted by a zeroing it with call to memset().

+
Parameters
+ + +
bufferthe buffer to be cleared
+
+
+ +
+
+ +

◆ ucx_buffer_clone

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_buffer_clone( src,
 flags 
)   ucx_buffer_extract(src, 0, (src)->capacity, flags)
+
+ +

A shorthand macro for the full extraction of the buffer.

+
Parameters
+ + + +
srcthe source buffer
flagsfeature mask for the new buffer
+
+
+
Returns
a new buffer with the extracted content
+ +
+
+ +

◆ ucx_buffer_to_sstr

+ +
+
+ + + + + + + + +
#define ucx_buffer_to_sstr( buffer)   sstrn((buffer)->space, (buffer)->size)
+
+ +

Returns the complete buffer content as sstr_t.

+
Parameters
+ + +
bufferthe buffer
+
+
+
Returns
the result of sstrn() with the buffer space and size as arguments
+ +
+
+

Function Documentation

+ +

◆ ucx_buffer_eof()

+ +
+
+ + + + + + + + +
int ucx_buffer_eof (UcxBuffer * buffer)
+
+ +

Tests, if the buffer position has exceeded the buffer capacity.

+
Parameters
+ + +
bufferthe buffer to test
+
+
+
Returns
non-zero, if the current buffer position has exceeded the last available byte of the buffer.
+ +
+
+ +

◆ ucx_buffer_extend()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_buffer_extend (UcxBuffer * buffer,
size_t additional_bytes 
)
+
+ +

Extends the capacity of the buffer.

+

Note: The buffer capacity increased by a power of two. I.e. the buffer capacity is doubled, as long as it would not hold the current content plus the additional required bytes.

+

Attention: the argument provided is the number of additional bytes the buffer shall hold. It is NOT the total number of bytes the buffer shall hold.

+
Parameters
+ + + +
bufferthe buffer to extend
additional_bytesthe number of additional bytes the buffer shall at least hold
+
+
+
Returns
0 on success or a non-zero value on failure
+ +
+
+ +

◆ ucx_buffer_extract()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxBuffer* ucx_buffer_extract (UcxBuffer * src,
size_t start,
size_t length,
int flags 
)
+
+ +

Creates a new buffer and fills it with extracted content from another buffer.

+

Note: the UCX_BUFFER_AUTOFREE feature is enforced for the new buffer.

+
Parameters
+ + + + + +
srcthe source buffer
startthe start position of extraction
lengththe count of bytes to extract (must not be zero)
flagsfeature mask for the new buffer
+
+
+
Returns
a new buffer containing the extraction
+ +
+
+ +

◆ ucx_buffer_free()

+ +
+
+ + + + + + + + +
void ucx_buffer_free (UcxBuffer * buffer)
+
+ +

Destroys a buffer.

+

If the UCX_BUFFER_AUTOFREE feature is enabled, the contents of the buffer are also freed.

+
Parameters
+ + +
bufferthe buffer to destroy
+
+
+ +
+
+ +

◆ ucx_buffer_getc()

+ +
+
+ + + + + + + + +
int ucx_buffer_getc (UcxBuffer * buffer)
+
+ +

Gets a character from a buffer.

+

The current position of the buffer is increased after a successful read.

+
Parameters
+ + +
bufferthe buffer to read from
+
+
+
Returns
the character as int value or EOF, if the end of the buffer is reached
+ +
+
+ +

◆ ucx_buffer_new()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxBuffer* ucx_buffer_new (void * space,
size_t capacity,
int flags 
)
+
+ +

Creates a new buffer.

+

Note: you may provide NULL as argument for space. Then this function will allocate the space and enforce the UCX_BUFFER_AUTOFREE flag.

+
Parameters
+ + + + +
spacepointer to the memory area, or NULL to allocate new memory
capacitythe capacity of the buffer
flagsbuffer features (see UcxBuffer.flags)
+
+
+
Returns
the new buffer
+ +
+
+ +

◆ ucx_buffer_putc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_buffer_putc (UcxBuffer * buffer,
int c 
)
+
+ +

Writes a character to a buffer.

+

The least significant byte of the argument is written to the buffer. If the end of the buffer is reached and UCX_BUFFER_AUTOEXTEND feature is enabled, the buffer capacity is extended by ucx_buffer_extend(). If the feature is disabled or buffer extension fails, EOF is returned.

+

On successful write the position of the buffer is increased.

+
Parameters
+ + + +
bufferthe buffer to write to
cthe character to write as int value
+
+
+
Returns
the byte that has bean written as int value or EOF when the end of the stream is reached and automatic extension is not enabled or not possible
+ +
+
+ +

◆ ucx_buffer_puts()

+ +
+
+ + + + + + + + + + + + + + + + + + +
size_t ucx_buffer_puts (UcxBuffer * buffer,
const char * str 
)
+
+ +

Writes a string to a buffer.

+
Parameters
+ + + +
bufferthe buffer
strthe string
+
+
+
Returns
the number of bytes written
+ +
+
+ +

◆ ucx_buffer_read()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
size_t ucx_buffer_read (void * ptr,
size_t size,
size_t nitems,
UcxBuffer * buffer 
)
+
+ +

Reads data from a UcxBuffer.

+

The position of the buffer is increased by the number of bytes read.

+
Parameters
+ + + + + +
ptra pointer to the memory area where to store the read data
sizethe length of one element
nitemsthe element count
bufferthe UcxBuffer to read from
+
+
+
Returns
the total number of elements read
+ +
+
+ +

◆ ucx_buffer_seek()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_buffer_seek (UcxBuffer * buffer,
off_t offset,
int whence 
)
+
+ +

Moves the position of the buffer.

+

The new position is relative to the whence argument.

+

SEEK_SET marks the start of the buffer. SEEK_CUR marks the current position. SEEK_END marks the end of the buffer.

+

With an offset of zero, this function sets the buffer position to zero (SEEK_SET), the buffer size (SEEK_END) or leaves the buffer position unchanged (SEEK_CUR).

+
Parameters
+ + + + +
buffer
offsetposition offset relative to whence
whenceone of SEEK_SET, SEEK_CUR or SEEK_END
+
+
+
Returns
0 on success, non-zero if the position is invalid
+ +
+
+ +

◆ ucx_buffer_shift()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_buffer_shift (UcxBuffer * buffer,
off_t shift 
)
+
+ +

Shifts the contents of the buffer by the given offset.

+

If the offset is positive, the contents are shifted to the right. If auto extension is enabled, the buffer grows, if necessary. In case the auto extension fails, this function returns a non-zero value and no contents are changed. If auto extension is disabled, the contents that do not fit into the buffer are discarded.

+

If the offset is negative, the contents are shifted to the left where the first shift bytes are discarded. The new size of the buffer is the old size minus the absolute shift value. If this value is larger than the buffer size, the buffer is emptied (but not cleared, see the security note below).

+

The buffer position gets shifted alongside with the content but is kept within the boundaries of the buffer.

+

Security note: the shifting operation does not erase the previously occupied memory cells. You can easily do that manually, e.g. by calling memset(buffer->space, 0, shift) for a right shift or memset(buffer->size, 0, buffer->capacity-buffer->size) for a left shift.

+
Parameters
+ + + +
bufferthe buffer
shiftthe shift offset (negative means left shift)
+
+
+
Returns
0 on success, non-zero if a required auto-extension fails
+ +
+
+ +

◆ ucx_buffer_shift_left()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_buffer_shift_left (UcxBuffer * buffer,
size_t shift 
)
+
+ +

Shifts the buffer to the left.

+

See ucx_buffer_shift() for details. Note, however, that this method expects a positive shift offset.

+

Since a left shift cannot fail due to memory allocation problems, this function always returns zero.

+
Parameters
+ + + +
bufferthe buffer
shiftthe shift offset
+
+
+
Returns
always zero
+
See also
ucx_buffer_shift()
+ +
+
+ +

◆ ucx_buffer_shift_right()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_buffer_shift_right (UcxBuffer * buffer,
size_t shift 
)
+
+ +

Shifts the buffer to the right.

+

See ucx_buffer_shift() for details.

+
Parameters
+ + + +
bufferthe buffer
shiftthe shift offset
+
+
+
Returns
0 on success, non-zero if a required auto-extension fails
+
See also
ucx_buffer_shift()
+ +
+
+ +

◆ ucx_buffer_write()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
size_t ucx_buffer_write (const void * ptr,
size_t size,
size_t nitems,
UcxBuffer * buffer 
)
+
+ +

Writes data to a UcxBuffer.

+

The position of the buffer is increased by the number of bytes written.

+
Parameters
+ + + + + +
ptra pointer to the memory area containing the bytes to be written
sizethe length of one element
nitemsthe element count
bufferthe UcxBuffer to write to
+
+
+
Returns
the total count of bytes written
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/buffer_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/buffer_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,100 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/buffer.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
buffer.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
46 #ifndef UCX_BUFFER_H
47 #define UCX_BUFFER_H
48 
49 #include "ucx.h"
50 #include <sys/types.h>
51 #include <stdio.h>
52 
53 #ifdef __cplusplus
54 extern "C" {
55 #endif
56 
60 #define UCX_BUFFER_DEFAULT 0x00
61 
65 #define UCX_BUFFER_AUTOFREE 0x01
66 
70 #define UCX_BUFFER_AUTOEXTEND 0x02
71 
73 typedef struct {
75  char *space;
77  size_t pos;
79  size_t capacity;
81  size_t size;
88  int flags;
89 } UcxBuffer;
90 
104 UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags);
105 
114 void ucx_buffer_free(UcxBuffer* buffer);
115 
127 UcxBuffer* ucx_buffer_extract(UcxBuffer *src,
128  size_t start, size_t length, int flags);
129 
137 #define ucx_buffer_clone(src,flags) \
138  ucx_buffer_extract(src, 0, (src)->capacity, flags)
139 
140 
171 int ucx_buffer_shift(UcxBuffer* buffer, off_t shift);
172 
182 int ucx_buffer_shift_right(UcxBuffer* buffer, size_t shift);
183 
198 int ucx_buffer_shift_left(UcxBuffer* buffer, size_t shift);
199 
200 
220 int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence);
221 
229 #define ucx_buffer_clear(buffer) memset((buffer)->space, 0, (buffer)->size); \
230  (buffer)->size = 0; (buffer)->pos = 0;
231 
239 int ucx_buffer_eof(UcxBuffer *buffer);
240 
241 
258 int ucx_buffer_extend(UcxBuffer *buffer, size_t additional_bytes);
259 
271 size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems,
272  UcxBuffer *buffer);
273 
285 size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems,
286  UcxBuffer *buffer);
287 
304 int ucx_buffer_putc(UcxBuffer *buffer, int c);
305 
315 int ucx_buffer_getc(UcxBuffer *buffer);
316 
324 size_t ucx_buffer_puts(UcxBuffer *buffer, const char *str);
325 
332 #define ucx_buffer_to_sstr(buffer) sstrn((buffer)->space, (buffer)->size)
333 
334 #ifdef __cplusplus
335 }
336 #endif
337 
338 #endif /* UCX_BUFFER_H */
339 
UcxBuffer::flags
int flags
Flag register for buffer features.
Definition: buffer.h:88
+
ucx_buffer_seek
int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence)
Moves the position of the buffer.
Definition: buffer.c:90
+
ucx_buffer_read
size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems, UcxBuffer *buffer)
Reads data from a UcxBuffer.
Definition: buffer.c:189
+
ucx_buffer_shift_left
int ucx_buffer_shift_left(UcxBuffer *buffer, size_t shift)
Shifts the buffer to the left.
Definition: buffer.c:244
+
ucx.h
Main UCX Header providing most common definitions.
+
ucx_buffer_extend
int ucx_buffer_extend(UcxBuffer *buffer, size_t additional_bytes)
Extends the capacity of the buffer.
Definition: buffer.c:126
+
ucx_buffer_free
void ucx_buffer_free(UcxBuffer *buffer)
Destroys a buffer.
Definition: buffer.c:59
+
UcxBuffer::pos
size_t pos
Current position of the buffer.
Definition: buffer.h:77
+
ucx_buffer_write
size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems, UcxBuffer *buffer)
Writes data to a UcxBuffer.
Definition: buffer.c:152
+
UcxBuffer::capacity
size_t capacity
Current capacity (i.e.
Definition: buffer.h:79
+
UcxBuffer::space
char * space
A pointer to the buffer contents.
Definition: buffer.h:75
+
ucx_buffer_eof
int ucx_buffer_eof(UcxBuffer *buffer)
Tests, if the buffer position has exceeded the buffer capacity.
Definition: buffer.c:122
+
UcxBuffer
UCX Buffer.
Definition: buffer.h:73
+
ucx_buffer_puts
size_t ucx_buffer_puts(UcxBuffer *buffer, const char *str)
Writes a string to a buffer.
Definition: buffer.c:240
+
ucx_buffer_putc
int ucx_buffer_putc(UcxBuffer *buffer, int c)
Writes a character to a buffer.
Definition: buffer.c:210
+
ucx_buffer_shift
int ucx_buffer_shift(UcxBuffer *buffer, off_t shift)
Shifts the contents of the buffer by the given offset.
Definition: buffer.c:289
+
ucx_buffer_new
UcxBuffer * ucx_buffer_new(void *space, size_t capacity, int flags)
Creates a new buffer.
Definition: buffer.c:35
+
ucx_buffer_extract
UcxBuffer * ucx_buffer_extract(UcxBuffer *src, size_t start, size_t length, int flags)
Creates a new buffer and fills it with extracted content from another buffer.
Definition: buffer.c:66
+
UcxBuffer::size
size_t size
Current size of the buffer content.
Definition: buffer.h:81
+
ucx_buffer_getc
int ucx_buffer_getc(UcxBuffer *buffer)
Gets a character from a buffer.
Definition: buffer.c:230
+
ucx_buffer_shift_right
int ucx_buffer_shift_right(UcxBuffer *buffer, size_t shift)
Shifts the buffer to the right.
Definition: buffer.c:260
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/classes.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/classes.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,89 @@ + + + + + + + +ucx: Data Structure Index + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
Data Structure Index
+
+
+
s | u
+ + + + + + + + + +
  s  
+		ucx_regdestr   UcxBuffer   UcxMapIterator   UcxTestSuite   
ucx_stack_metadata   UcxKey   UcxMapKey   
scstr_t   UcxAllocator   UcxList   UcxMempool   
sstr_t   UcxArray   UcxLogger   UcxProperties   
  u  
+		UcxAVLNode   UcxMap   UcxStack   
UcxAVLTree   UcxMapElement   UcxTestList   
ucx_memchunk   
+
s | u
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/closed.png Binary file docs/api-2.1/closed.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/dir_68267d1309a1af8e8297ef4c3efbcdba.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/dir_68267d1309a1af8e8297ef4c3efbcdba.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,83 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src Directory Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
src Directory Reference
+
+
+ + +

+Directories

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/dir_69f4ea29401808fe6229564976cde3ce.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/dir_69f4ea29401808fe6229564976cde3ce.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,125 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx Directory Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ucx Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  allocator.h [code]
 Allocator for custom memory management.
 
file  array.h [code]
 Dynamically allocated array implementation.
 
file  avl.h [code]
 AVL tree implementation.
 
file  buffer.h [code]
 Advanced buffer implementation.
 
file  list.h [code]
 Doubly linked list implementation.
 
file  logging.h [code]
 Logging API.
 
file  map.h [code]
 Hash map implementation.
 
file  mempool.h [code]
 Memory pool implementation.
 
file  properties.h [code]
 Load / store utilities for properties files.
 
file  stack.h [code]
 Default stack memory allocation implementation.
 
file  string.h [code]
 Bounded string implementation.
 
file  test.h [code]
 UCX Test Framework.
 
file  ucx.h [code]
 Main UCX Header providing most common definitions.
 
file  utils.h [code]
 Compare, copy and printf functions.
 
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/doc.png Binary file docs/api-2.1/doc.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/doxygen.css --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/doxygen.css Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,1596 @@ +/* The standard CSS for doxygen 1.8.13 */ + +body, table, div, p, dl { + font: 400 14px/22px Roboto,sans-serif; +} + +p.reference, p.definition { + font: 400 14px/22px Roboto,sans-serif; +} + +/* @group Heading Levels */ + +h1.groupheader { + font-size: 150%; +} + +.title { + font: 400 14px/28px Roboto,sans-serif; + font-size: 150%; + font-weight: bold; + margin: 10px 2px; +} + +h2.groupheader { + border-bottom: 1px solid #879ECB; + color: #354C7B; + font-size: 150%; + font-weight: normal; + margin-top: 1.75em; + padding-top: 8px; + padding-bottom: 4px; + width: 100%; +} + +h3.groupheader { + font-size: 100%; +} + +h1, h2, h3, h4, h5, h6 { + -webkit-transition: text-shadow 0.5s linear; + -moz-transition: text-shadow 0.5s linear; + -ms-transition: text-shadow 0.5s linear; + -o-transition: text-shadow 0.5s linear; + transition: text-shadow 0.5s linear; + margin-right: 15px; +} + +h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow { + text-shadow: 0 0 15px cyan; +} + +dt { + font-weight: bold; +} + +div.multicol { + -moz-column-gap: 1em; + -webkit-column-gap: 1em; + -moz-column-count: 3; + -webkit-column-count: 3; +} + +p.startli, p.startdd { + margin-top: 2px; +} + +p.starttd { + margin-top: 0px; +} + +p.endli { + margin-bottom: 0px; +} + +p.enddd { + margin-bottom: 4px; +} + +p.endtd { + margin-bottom: 2px; +} + +/* @end */ + +caption { + font-weight: bold; +} + +span.legend { + font-size: 70%; + text-align: center; +} + +h3.version { + font-size: 90%; + text-align: center; +} + +div.qindex, div.navtab{ + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; +} + +div.qindex, div.navpath { + width: 100%; + line-height: 140%; +} + +div.navtab { + margin-right: 15px; +} + +/* @group Link Styling */ + +a { + color: #3D578C; + font-weight: normal; + text-decoration: none; +} + +.contents a:visited { + color: #4665A2; +} + +a:hover { + text-decoration: underline; +} + +a.qindex { + font-weight: bold; +} + +a.qindexHL { + font-weight: bold; + background-color: #9CAFD4; + color: #ffffff; + border: 1px double #869DCA; +} + +.contents a.qindexHL:visited { + color: #ffffff; +} + +a.el { + font-weight: bold; +} + +a.elRef { +} + +a.code, a.code:visited, a.line, a.line:visited { + color: #4665A2; +} + +a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited { + color: #4665A2; +} + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +pre.fragment { + border: 1px solid #C4CFE5; + background-color: #FBFCFD; + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: monospace, fixed; + font-size: 105%; +} + +div.fragment { + padding: 0px; + margin: 4px 8px 4px 2px; + background-color: #FBFCFD; + border: 1px solid #C4CFE5; +} + +div.line { + font-family: monospace, fixed; + font-size: 13px; + min-height: 13px; + line-height: 1.0; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +div.line:after { + content:"\000A"; + white-space: pre; +} + +div.line.glow { + background-color: cyan; + box-shadow: 0 0 10px cyan; +} + + +span.lineno { + padding-right: 4px; + text-align: right; + border-right: 2px solid #0F0; + background-color: #E8E8E8; + white-space: pre; +} +span.lineno a { + background-color: #D8D8D8; +} + +span.lineno a:hover { + background-color: #C8C8C8; +} + +.lineno { + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +div.ah, span.ah { + background-color: black; + font-weight: bold; + color: #ffffff; + margin-bottom: 3px; + margin-top: 3px; + padding: 0.2em; + border: solid thin #333; + border-radius: 0.5em; + -webkit-border-radius: .5em; + -moz-border-radius: .5em; + box-shadow: 2px 2px 3px #999; + -webkit-box-shadow: 2px 2px 3px #999; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); + background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%); +} + +div.classindex ul { + list-style: none; + padding-left: 0; +} + +div.classindex span.ai { + display: inline-block; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +body { + background-color: white; + color: black; + margin: 0; +} + +div.contents { + margin-top: 10px; + margin-left: 12px; + margin-right: 8px; +} + +td.indexkey { + background-color: #EBEFF6; + font-weight: bold; + border: 1px solid #C4CFE5; + margin: 2px 0px 2px 0; + padding: 2px 10px; + white-space: nowrap; + vertical-align: top; +} + +td.indexvalue { + background-color: #EBEFF6; + border: 1px solid #C4CFE5; + padding: 2px 10px; + margin: 2px 0px; +} + +tr.memlist { + background-color: #EEF1F7; +} + +p.formulaDsp { + text-align: center; +} + +img.formulaDsp { + +} + +img.formulaInl { + vertical-align: middle; +} + +div.center { + text-align: center; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; +} + +div.center img { + border: 0px; +} + +address.footer { + text-align: right; + padding-right: 12px; +} + +img.footer { + border: 0px; + vertical-align: middle; +} + +/* @group Code Colorization */ + +span.keyword { + color: #008000 +} + +span.keywordtype { + color: #604020 +} + +span.keywordflow { + color: #e08000 +} + +span.comment { + color: #800000 +} + +span.preprocessor { + color: #806020 +} + +span.stringliteral { + color: #002080 +} + +span.charliteral { + color: #008080 +} + +span.vhdldigit { + color: #ff00ff +} + +span.vhdlchar { + color: #000000 +} + +span.vhdlkeyword { + color: #700070 +} + +span.vhdllogic { + color: #ff0000 +} + +blockquote { + background-color: #F7F8FB; + border-left: 2px solid #9CAFD4; + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + +/* @end */ + +/* +.search { + color: #003399; + font-weight: bold; +} + +form.search { + margin-bottom: 0px; + margin-top: 0px; +} + +input.search { + font-size: 75%; + color: #000080; + font-weight: normal; + background-color: #e8eef2; +} +*/ + +td.tiny { + font-size: 75%; +} + +.dirtab { + padding: 4px; + border-collapse: collapse; + border: 1px solid #A3B4D7; +} + +th.dirtab { + background: #EBEFF6; + font-weight: bold; +} + +hr { + height: 0px; + border: none; + border-top: 1px solid #4A6AAA; +} + +hr.footer { + height: 1px; +} + +/* @group Member Descriptions */ + +table.memberdecls { + border-spacing: 0px; + padding: 0px; +} + +.memberdecls td, .fieldtable tr { + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +.memberdecls td.glow, .fieldtable tr.glow { + background-color: cyan; + box-shadow: 0 0 15px cyan; +} + +.mdescLeft, .mdescRight, +.memItemLeft, .memItemRight, +.memTemplItemLeft, .memTemplItemRight, .memTemplParams { + background-color: #F9FAFC; + border: none; + margin: 4px; + padding: 1px 0 0 8px; +} + +.mdescLeft, .mdescRight { + padding: 0px 8px 4px 8px; + color: #555; +} + +.memSeparator { + border-bottom: 1px solid #DEE4F0; + line-height: 1px; + margin: 0px; + padding: 0px; +} + +.memItemLeft, .memTemplItemLeft { + white-space: nowrap; +} + +.memItemRight { + width: 100%; +} + +.memTemplParams { + color: #4665A2; + white-space: nowrap; + font-size: 80%; +} + +/* @end */ + +/* @group Member Details */ + +/* Styles for detailed member documentation */ + +.memtitle { + padding: 8px; + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + border-top-right-radius: 4px; + border-top-left-radius: 4px; + margin-bottom: -1px; + background-image: url('nav_f.png'); + background-repeat: repeat-x; + background-color: #E2E8F2; + line-height: 1.25; + font-weight: 300; + float:left; +} + +.permalink +{ + font-size: 65%; + display: inline-block; + vertical-align: middle; +} + +.memtemplate { + font-size: 80%; + color: #4665A2; + font-weight: normal; + margin-left: 9px; +} + +.memnav { + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; + margin: 2px; + margin-right: 15px; + padding: 2px; +} + +.mempage { + width: 100%; +} + +.memitem { + padding: 0; + margin-bottom: 10px; + margin-right: 5px; + -webkit-transition: box-shadow 0.5s linear; + -moz-transition: box-shadow 0.5s linear; + -ms-transition: box-shadow 0.5s linear; + -o-transition: box-shadow 0.5s linear; + transition: box-shadow 0.5s linear; + display: table !important; + width: 100%; +} + +.memitem.glow { + box-shadow: 0 0 15px cyan; +} + +.memname { + font-weight: 400; + margin-left: 6px; +} + +.memname td { + vertical-align: bottom; +} + +.memproto, dl.reflist dt { + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 0px 6px 0px; + color: #253555; + font-weight: bold; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + background-color: #DFE5F1; + /* opera specific markup */ + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + border-top-right-radius: 4px; + /* firefox specific markup */ + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + -moz-border-radius-topright: 4px; + /* webkit specific markup */ + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + -webkit-border-top-right-radius: 4px; + +} + +.overload { + font-family: "courier new",courier,monospace; + font-size: 65%; +} + +.memdoc, dl.reflist dd { + border-bottom: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 10px 2px 10px; + background-color: #FBFCFD; + border-top-width: 0; + background-image:url('nav_g.png'); + background-repeat:repeat-x; + background-color: #FFFFFF; + /* opera specific markup */ + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + /* firefox specific markup */ + -moz-border-radius-bottomleft: 4px; + -moz-border-radius-bottomright: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + /* webkit specific markup */ + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +dl.reflist dt { + padding: 5px; +} + +dl.reflist dd { + margin: 0px 0px 10px 0px; + padding: 5px; +} + +.paramkey { + text-align: right; +} + +.paramtype { + white-space: nowrap; +} + +.paramname { + color: #602020; + white-space: nowrap; +} +.paramname em { + font-style: normal; +} +.paramname code { + line-height: 14px; +} + +.params, .retval, .exception, .tparams { + margin-left: 0px; + padding-left: 0px; +} + +.params .paramname, .retval .paramname { + font-weight: bold; + vertical-align: top; +} + +.params .paramtype { + font-style: italic; + vertical-align: top; +} + +.params .paramdir { + font-family: "courier new",courier,monospace; + vertical-align: top; +} + +table.mlabels { + border-spacing: 0px; +} + +td.mlabels-left { + width: 100%; + padding: 0px; +} + +td.mlabels-right { + vertical-align: bottom; + padding: 0px; + white-space: nowrap; +} + +span.mlabels { + margin-left: 8px; +} + +span.mlabel { + background-color: #728DC1; + border-top:1px solid #5373B4; + border-left:1px solid #5373B4; + border-right:1px solid #C4CFE5; + border-bottom:1px solid #C4CFE5; + text-shadow: none; + color: white; + margin-right: 4px; + padding: 2px 3px; + border-radius: 3px; + font-size: 7pt; + white-space: nowrap; + vertical-align: middle; +} + + + +/* @end */ + +/* these are for tree view inside a (index) page */ + +div.directory { + margin: 10px 0px; + border-top: 1px solid #9CAFD4; + border-bottom: 1px solid #9CAFD4; + width: 100%; +} + +.directory table { + border-collapse:collapse; +} + +.directory td { + margin: 0px; + padding: 0px; + vertical-align: top; +} + +.directory td.entry { + white-space: nowrap; + padding-right: 6px; + padding-top: 3px; +} + +.directory td.entry a { + outline:none; +} + +.directory td.entry a img { + border: none; +} + +.directory td.desc { + width: 100%; + padding-left: 6px; + padding-right: 6px; + padding-top: 3px; + border-left: 1px solid rgba(0,0,0,0.05); +} + +.directory tr.even { + padding-left: 6px; + background-color: #F7F8FB; +} + +.directory img { + vertical-align: -30%; +} + +.directory .levels { + white-space: nowrap; + width: 100%; + text-align: right; + font-size: 9pt; +} + +.directory .levels span { + cursor: pointer; + padding-left: 2px; + padding-right: 2px; + color: #3D578C; +} + +.arrow { + color: #9CAFD4; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + font-size: 80%; + display: inline-block; + width: 16px; + height: 22px; +} + +.icon { + font-family: Arial, Helvetica; + font-weight: bold; + font-size: 12px; + height: 14px; + width: 16px; + display: inline-block; + background-color: #728DC1; + color: white; + text-align: center; + border-radius: 4px; + margin-left: 2px; + margin-right: 2px; +} + +.icona { + width: 24px; + height: 22px; + display: inline-block; +} + +.iconfopen { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderopen.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.iconfclosed { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderclosed.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.icondoc { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('doc.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +table.directory { + font: 400 14px Roboto,sans-serif; +} + +/* @end */ + +div.dynheader { + margin-top: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +address { + font-style: normal; + color: #2A3D61; +} + +table.doxtable caption { + caption-side: top; +} + +table.doxtable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.doxtable td, table.doxtable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.doxtable th { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +table.fieldtable { + /*width: 100%;*/ + margin-bottom: 10px; + border: 1px solid #A8B8D9; + border-spacing: 0px; + -moz-border-radius: 4px; + -webkit-border-radius: 4px; + border-radius: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); +} + +.fieldtable td, .fieldtable th { + padding: 3px 7px 2px; +} + +.fieldtable td.fieldtype, .fieldtable td.fieldname { + white-space: nowrap; + border-right: 1px solid #A8B8D9; + border-bottom: 1px solid #A8B8D9; + vertical-align: top; +} + +.fieldtable td.fieldname { + padding-top: 3px; +} + +.fieldtable td.fielddoc { + border-bottom: 1px solid #A8B8D9; + /*width: 100%;*/ +} + +.fieldtable td.fielddoc p:first-child { + margin-top: 0px; +} + +.fieldtable td.fielddoc p:last-child { + margin-bottom: 2px; +} + +.fieldtable tr:last-child td { + border-bottom: none; +} + +.fieldtable th { + background-image:url('nav_f.png'); + background-repeat:repeat-x; + background-color: #E2E8F2; + font-size: 90%; + color: #253555; + padding-bottom: 4px; + padding-top: 5px; + text-align:left; + font-weight: 400; + -moz-border-radius-topleft: 4px; + -moz-border-radius-topright: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + border-top-left-radius: 4px; + border-top-right-radius: 4px; + border-bottom: 1px solid #A8B8D9; +} + + +.tabsearch { + top: 0px; + left: 10px; + height: 36px; + background-image: url('tab_b.png'); + z-index: 101; + overflow: hidden; + font-size: 13px; +} + +.navpath ul +{ + font-size: 11px; + background-image:url('tab_b.png'); + background-repeat:repeat-x; + background-position: 0 -5px; + height:30px; + line-height:30px; + color:#8AA0CC; + border:solid 1px #C2CDE4; + overflow:hidden; + margin:0px; + padding:0px; +} + +.navpath li +{ + list-style-type:none; + float:left; + padding-left:10px; + padding-right:15px; + background-image:url('bc_s.png'); + background-repeat:no-repeat; + background-position:right; + color:#364D7C; +} + +.navpath li.navelem a +{ + height:32px; + display:block; + text-decoration: none; + outline: none; + color: #283A5D; + font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + text-decoration: none; +} + +.navpath li.navelem a:hover +{ + color:#6884BD; +} + +.navpath li.footer +{ + list-style-type:none; + float:right; + padding-left:10px; + padding-right:15px; + background-image:none; + background-repeat:no-repeat; + background-position:right; + color:#364D7C; + font-size: 8pt; +} + + +div.summary +{ + float: right; + font-size: 8pt; + padding-right: 5px; + width: 50%; + text-align: right; +} + +div.summary a +{ + white-space: nowrap; +} + +table.classindex +{ + margin: 10px; + white-space: nowrap; + margin-left: 3%; + margin-right: 3%; + width: 94%; + border: 0; + border-spacing: 0; + padding: 0; +} + +div.ingroups +{ + font-size: 8pt; + width: 50%; + text-align: left; +} + +div.ingroups a +{ + white-space: nowrap; +} + +div.header +{ + background-image:url('nav_h.png'); + background-repeat:repeat-x; + background-color: #F9FAFC; + margin: 0px; + border-bottom: 1px solid #C4CFE5; +} + +div.headertitle +{ + padding: 5px 5px 5px 10px; +} + +dl +{ + padding: 0 0 0 10px; +} + +/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */ +dl.section +{ + margin-left: 0px; + padding-left: 0px; +} + +dl.note +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #D0C000; +} + +dl.warning, dl.attention +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #FF0000; +} + +dl.pre, dl.post, dl.invariant +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00D000; +} + +dl.deprecated +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #505050; +} + +dl.todo +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00C0E0; +} + +dl.test +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #3030E0; +} + +dl.bug +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #C08050; +} + +dl.section dd { + margin-bottom: 6px; +} + + +#projectlogo +{ + text-align: center; + vertical-align: bottom; + border-collapse: separate; +} + +#projectlogo img +{ + border: 0px none; +} + +#projectalign +{ + vertical-align: middle; +} + +#projectname +{ + font: 300% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 2px 0px; +} + +#projectbrief +{ + font: 120% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#projectnumber +{ + font: 50% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#titlearea +{ + padding: 0px; + margin: 0px; + width: 100%; + border-bottom: 1px solid #5373B4; +} + +.image +{ + text-align: center; +} + +.dotgraph +{ + text-align: center; +} + +.mscgraph +{ + text-align: center; +} + +.plantumlgraph +{ + text-align: center; +} + +.diagraph +{ + text-align: center; +} + +.caption +{ + font-weight: bold; +} + +div.zoom +{ + border: 1px solid #90A5CE; +} + +dl.citelist { + margin-bottom:50px; +} + +dl.citelist dt { + color:#334975; + float:left; + font-weight:bold; + margin-right:10px; + padding:5px; +} + +dl.citelist dd { + margin:2px 0; + padding:5px 0; +} + +div.toc { + padding: 14px 25px; + background-color: #F4F6FA; + border: 1px solid #D8DFEE; + border-radius: 7px 7px 7px 7px; + float: right; + height: auto; + margin: 0 8px 10px 10px; + width: 200px; +} + +div.toc li { + background: url("bdwn.png") no-repeat scroll 0 5px transparent; + font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif; + margin-top: 5px; + padding-left: 10px; + padding-top: 2px; +} + +div.toc h3 { + font: bold 12px/1.2 Arial,FreeSans,sans-serif; + color: #4665A2; + border-bottom: 0 none; + margin: 0; +} + +div.toc ul { + list-style: none outside none; + border: medium none; + padding: 0px; +} + +div.toc li.level1 { + margin-left: 0px; +} + +div.toc li.level2 { + margin-left: 15px; +} + +div.toc li.level3 { + margin-left: 30px; +} + +div.toc li.level4 { + margin-left: 45px; +} + +.inherit_header { + font-weight: bold; + color: gray; + cursor: pointer; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.inherit_header td { + padding: 6px 0px 2px 5px; +} + +.inherit { + display: none; +} + +tr.heading h2 { + margin-top: 12px; + margin-bottom: 4px; +} + +/* tooltip related style info */ + +.ttc { + position: absolute; + display: none; +} + +#powerTip { + cursor: default; + white-space: nowrap; + background-color: white; + border: 1px solid gray; + border-radius: 4px 4px 4px 4px; + box-shadow: 1px 1px 7px gray; + display: none; + font-size: smaller; + max-width: 80%; + opacity: 0.9; + padding: 1ex 1em 1em; + position: absolute; + z-index: 2147483647; +} + +#powerTip div.ttdoc { + color: grey; + font-style: italic; +} + +#powerTip div.ttname a { + font-weight: bold; +} + +#powerTip div.ttname { + font-weight: bold; +} + +#powerTip div.ttdeci { + color: #006318; +} + +#powerTip div { + margin: 0px; + padding: 0px; + font: 12px/16px Roboto,sans-serif; +} + +#powerTip:before, #powerTip:after { + content: ""; + position: absolute; + margin: 0px; +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.s:after, #powerTip.s:before, +#powerTip.w:after, #powerTip.w:before, +#powerTip.e:after, #powerTip.e:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.nw:after, #powerTip.nw:before, +#powerTip.sw:after, #powerTip.sw:before { + border: solid transparent; + content: " "; + height: 0; + width: 0; + position: absolute; +} + +#powerTip.n:after, #powerTip.s:after, +#powerTip.w:after, #powerTip.e:after, +#powerTip.nw:after, #powerTip.ne:after, +#powerTip.sw:after, #powerTip.se:after { + border-color: rgba(255, 255, 255, 0); +} + +#powerTip.n:before, #powerTip.s:before, +#powerTip.w:before, #powerTip.e:before, +#powerTip.nw:before, #powerTip.ne:before, +#powerTip.sw:before, #powerTip.se:before { + border-color: rgba(128, 128, 128, 0); +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.nw:after, #powerTip.nw:before { + top: 100%; +} + +#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after { + border-top-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} +#powerTip.n:before { + border-top-color: #808080; + border-width: 11px; + margin: 0px -11px; +} +#powerTip.n:after, #powerTip.n:before { + left: 50%; +} + +#powerTip.nw:after, #powerTip.nw:before { + right: 14px; +} + +#powerTip.ne:after, #powerTip.ne:before { + left: 14px; +} + +#powerTip.s:after, #powerTip.s:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.sw:after, #powerTip.sw:before { + bottom: 100%; +} + +#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after { + border-bottom-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} + +#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before { + border-bottom-color: #808080; + border-width: 11px; + margin: 0px -11px; +} + +#powerTip.s:after, #powerTip.s:before { + left: 50%; +} + +#powerTip.sw:after, #powerTip.sw:before { + right: 14px; +} + +#powerTip.se:after, #powerTip.se:before { + left: 14px; +} + +#powerTip.e:after, #powerTip.e:before { + left: 100%; +} +#powerTip.e:after { + border-left-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.e:before { + border-left-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +#powerTip.w:after, #powerTip.w:before { + right: 100%; +} +#powerTip.w:after { + border-right-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.w:before { + border-right-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +@media print +{ + #top { display: none; } + #side-nav { display: none; } + #nav-path { display: none; } + body { overflow:visible; } + h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } + .summary { display: none; } + .memitem { page-break-inside: avoid; } + #doc-content + { + margin-left:0 !important; + height:auto !important; + width:auto !important; + overflow:inherit; + display:inline; + } +} + +/* @group Markdown */ + +/* +table.markdownTable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.markdownTable td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.markdownTableHead tr { +} + +table.markdownTableBodyLeft td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +th.markdownTableHeadLeft th.markdownTableHeadRight th.markdownTableHeadCenter th.markdownTableHeadNone { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +th.markdownTableHeadLeft { + text-align: left +} + +th.markdownTableHeadRight { + text-align: right +} + +th.markdownTableHeadCenter { + text-align: center +} +*/ + +table.markdownTable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.markdownTable td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.markdownTable tr { +} + +th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +th.markdownTableHeadLeft, td.markdownTableBodyLeft { + text-align: left +} + +th.markdownTableHeadRight, td.markdownTableBodyRight { + text-align: right +} + +th.markdownTableHeadCenter, td.markdownTableBodyCenter { + text-align: center +} + + +/* @end */ diff -r 92e482410453 -r d345541018fa docs/api-2.1/doxygen.png Binary file docs/api-2.1/doxygen.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/dynsections.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/dynsections.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,97 @@ +function toggleVisibility(linkObj) +{ + var base = $(linkObj).attr('id'); + var summary = $('#'+base+'-summary'); + var content = $('#'+base+'-content'); + var trigger = $('#'+base+'-trigger'); + var src=$(trigger).attr('src'); + if (content.is(':visible')===true) { + content.hide(); + summary.show(); + $(linkObj).addClass('closed').removeClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); + } else { + content.show(); + summary.hide(); + $(linkObj).removeClass('closed').addClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); + } + return false; +} + +function updateStripes() +{ + $('table.directory tr'). + removeClass('even').filter(':visible:even').addClass('even'); +} + +function toggleLevel(level) +{ + $('table.directory tr').each(function() { + var l = this.id.split('_').length-1; + var i = $('#img'+this.id.substring(3)); + var a = $('#arr'+this.id.substring(3)); + if (l + + + + + + +ucx: File List + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
File List
+
+
+
Here is a list of all documented files with brief descriptions:
+
[detail level 123]
+ + + + + + + + + + + + + + + + +
 ▼ src
 ▼ ucx
 allocator.hAllocator for custom memory management
 array.hDynamically allocated array implementation
 avl.hAVL tree implementation
 buffer.hAdvanced buffer implementation
 list.hDoubly linked list implementation
 logging.hLogging API
 map.hHash map implementation
 mempool.hMemory pool implementation
 properties.hLoad / store utilities for properties files
 stack.hDefault stack memory allocation implementation
 string.hBounded string implementation
 test.hUCX Test Framework
 ucx.hMain UCX Header providing most common definitions
 utils.hCompare, copy and printf functions
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/folderclosed.png Binary file docs/api-2.1/folderclosed.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/folderopen.png Binary file docs/api-2.1/folderopen.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/functions.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/functions.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,343 @@ + + + + + + + +ucx: Data Fields + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented struct and union fields with links to the struct/union documentation for each field:
+ +

- a -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- e -

+ + +

- f -

+ + +

- h -

+ + +

- i -

+ + +

- k -

+ + +

- l -

+ + +

- m -

+ + +

- n -

+ + +

- p -

+ + +

- r -

+ + +

- s -

+ + +

- t -

+ + +

- u -

+ + +

- v -

+ + +

- w -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/functions_vars.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/functions_vars.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,343 @@ + + + + + + + +ucx: Data Fields - Variables + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  + +

- a -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- e -

+ + +

- f -

+ + +

- h -

+ + +

- i -

+ + +

- k -

+ + +

- l -

+ + +

- m -

+ + +

- n -

+ + +

- p -

+ + +

- r -

+ + +

- s -

+ + +

- t -

+ + +

- u -

+ + +

- v -

+ + +

- w -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,78 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- _ -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_a.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_a.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,87 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- a -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_c.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_c.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,81 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- c -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_d.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_d.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,78 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- d -

    +
  • distance_func +: ucx.h +
    • +
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_defs.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_defs.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,364 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  + +

- _ -

+ + +

- a -

+ + +

- p -

+ + +

- s -

+ + +

- u -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_func.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_func.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,174 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  + +

- s -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_func_u.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_func_u.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,621 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  + +

- u -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_p.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_p.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,78 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- p -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_r.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_r.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,78 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- r -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_s.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_s.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,246 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- s -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_type.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_type.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,130 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  +
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_u.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_u.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,846 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- u -

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/globals_w.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/globals_w.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,78 @@ + + + + + + + +ucx: Globals + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
+ +

- w -

    +
  • write_func +: ucx.h +
    • +
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/index.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/index.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,88 @@ + + + + + + + +ucx: UAP Common Extensions + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
UAP Common Extensions
+
+
+

Library with common and useful functions, macros and data structures.

+

Latest available source:
+ https://sourceforge.net/projects/ucx/files/

+

Repositories:
+ https://sourceforge.net/p/ucx/code - or - https://develop.uap-core.de/hg/ucx

+

LICENCE

+

Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.

+

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

+
    +
  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    2. +
  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
    3. +
+

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/jquery.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/jquery.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,87 @@ +/*! + * jQuery JavaScript Library v1.7.1 + * http://jquery.com/ + * + * Copyright 2011, John Resig + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * + * Date: Mon Nov 21 21:11:03 2011 -0500 + */ +(function(bb,L){var av=bb.document,bu=bb.navigator,bl=bb.location;var b=(function(){var bF=function(b0,b1){return new bF.fn.init(b0,b1,bD)},bU=bb.jQuery,bH=bb.$,bD,bY=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,bM=/\S/,bI=/^\s+/,bE=/\s+$/,bA=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,bN=/^[\],:{}\s]*$/,bW=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,bP=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,bJ=/(?:^|:|,)(?:\s*\[)+/g,by=/(webkit)[ \/]([\w.]+)/,bR=/(opera)(?:.*version)?[ \/]([\w.]+)/,bQ=/(msie) ([\w.]+)/,bS=/(mozilla)(?:.*? rv:([\w.]+))?/,bB=/-([a-z]|[0-9])/ig,bZ=/^-ms-/,bT=function(b0,b1){return(b1+"").toUpperCase()},bX=bu.userAgent,bV,bC,e,bL=Object.prototype.toString,bG=Object.prototype.hasOwnProperty,bz=Array.prototype.push,bK=Array.prototype.slice,bO=String.prototype.trim,bv=Array.prototype.indexOf,bx={};bF.fn=bF.prototype={constructor:bF,init:function(b0,b4,b3){var b2,b5,b1,b6;if(!b0){return this}if(b0.nodeType){this.context=this[0]=b0;this.length=1;return this}if(b0==="body"&&!b4&&av.body){this.context=av;this[0]=av.body;this.selector=b0;this.length=1;return this}if(typeof b0==="string"){if(b0.charAt(0)==="<"&&b0.charAt(b0.length-1)===">"&&b0.length>=3){b2=[null,b0,null]}else{b2=bY.exec(b0)}if(b2&&(b2[1]||!b4)){if(b2[1]){b4=b4 instanceof bF?b4[0]:b4;b6=(b4?b4.ownerDocument||b4:av);b1=bA.exec(b0);if(b1){if(bF.isPlainObject(b4)){b0=[av.createElement(b1[1])];bF.fn.attr.call(b0,b4,true)}else{b0=[b6.createElement(b1[1])]}}else{b1=bF.buildFragment([b2[1]],[b6]);b0=(b1.cacheable?bF.clone(b1.fragment):b1.fragment).childNodes}return bF.merge(this,b0)}else{b5=av.getElementById(b2[2]);if(b5&&b5.parentNode){if(b5.id!==b2[2]){return b3.find(b0)}this.length=1;this[0]=b5}this.context=av;this.selector=b0;return this}}else{if(!b4||b4.jquery){return(b4||b3).find(b0)}else{return this.constructor(b4).find(b0)}}}else{if(bF.isFunction(b0)){return b3.ready(b0)}}if(b0.selector!==L){this.selector=b0.selector;this.context=b0.context}return bF.makeArray(b0,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return bK.call(this,0)},get:function(b0){return b0==null?this.toArray():(b0<0?this[this.length+b0]:this[b0])},pushStack:function(b1,b3,b0){var b2=this.constructor();if(bF.isArray(b1)){bz.apply(b2,b1)}else{bF.merge(b2,b1)}b2.prevObject=this;b2.context=this.context;if(b3==="find"){b2.selector=this.selector+(this.selector?" ":"")+b0}else{if(b3){b2.selector=this.selector+"."+b3+"("+b0+")"}}return b2},each:function(b1,b0){return bF.each(this,b1,b0)},ready:function(b0){bF.bindReady();bC.add(b0);return this},eq:function(b0){b0=+b0;return b0===-1?this.slice(b0):this.slice(b0,b0+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(bK.apply(this,arguments),"slice",bK.call(arguments).join(","))},map:function(b0){return this.pushStack(bF.map(this,function(b2,b1){return b0.call(b2,b1,b2)}))},end:function(){return this.prevObject||this.constructor(null)},push:bz,sort:[].sort,splice:[].splice};bF.fn.init.prototype=bF.fn;bF.extend=bF.fn.extend=function(){var b9,b2,b0,b1,b6,b7,b5=arguments[0]||{},b4=1,b3=arguments.length,b8=false;if(typeof b5==="boolean"){b8=b5;b5=arguments[1]||{};b4=2}if(typeof b5!=="object"&&!bF.isFunction(b5)){b5={}}if(b3===b4){b5=this;--b4}for(;b40){return}bC.fireWith(av,[bF]);if(bF.fn.trigger){bF(av).trigger("ready").off("ready")}}},bindReady:function(){if(bC){return}bC=bF.Callbacks("once memory");if(av.readyState==="complete"){return setTimeout(bF.ready,1)}if(av.addEventListener){av.addEventListener("DOMContentLoaded",e,false);bb.addEventListener("load",bF.ready,false)}else{if(av.attachEvent){av.attachEvent("onreadystatechange",e);bb.attachEvent("onload",bF.ready);var b0=false;try{b0=bb.frameElement==null}catch(b1){}if(av.documentElement.doScroll&&b0){bw()}}}},isFunction:function(b0){return bF.type(b0)==="function"},isArray:Array.isArray||function(b0){return bF.type(b0)==="array"},isWindow:function(b0){return b0&&typeof b0==="object"&&"setInterval" in b0},isNumeric:function(b0){return !isNaN(parseFloat(b0))&&isFinite(b0)},type:function(b0){return b0==null?String(b0):bx[bL.call(b0)]||"object"},isPlainObject:function(b2){if(!b2||bF.type(b2)!=="object"||b2.nodeType||bF.isWindow(b2)){return false}try{if(b2.constructor&&!bG.call(b2,"constructor")&&!bG.call(b2.constructor.prototype,"isPrototypeOf")){return false}}catch(b1){return false}var b0;for(b0 in b2){}return b0===L||bG.call(b2,b0)},isEmptyObject:function(b1){for(var b0 in b1){return false}return true},error:function(b0){throw new Error(b0)},parseJSON:function(b0){if(typeof b0!=="string"||!b0){return null}b0=bF.trim(b0);if(bb.JSON&&bb.JSON.parse){return bb.JSON.parse(b0)}if(bN.test(b0.replace(bW,"@").replace(bP,"]").replace(bJ,""))){return(new Function("return "+b0))()}bF.error("Invalid JSON: "+b0)},parseXML:function(b2){var b0,b1;try{if(bb.DOMParser){b1=new DOMParser();b0=b1.parseFromString(b2,"text/xml")}else{b0=new ActiveXObject("Microsoft.XMLDOM");b0.async="false";b0.loadXML(b2)}}catch(b3){b0=L}if(!b0||!b0.documentElement||b0.getElementsByTagName("parsererror").length){bF.error("Invalid XML: "+b2)}return b0},noop:function(){},globalEval:function(b0){if(b0&&bM.test(b0)){(bb.execScript||function(b1){bb["eval"].call(bb,b1)})(b0)}},camelCase:function(b0){return b0.replace(bZ,"ms-").replace(bB,bT)},nodeName:function(b1,b0){return b1.nodeName&&b1.nodeName.toUpperCase()===b0.toUpperCase()},each:function(b3,b6,b2){var b1,b4=0,b5=b3.length,b0=b5===L||bF.isFunction(b3);if(b2){if(b0){for(b1 in b3){if(b6.apply(b3[b1],b2)===false){break}}}else{for(;b40&&b0[0]&&b0[b1-1])||b1===0||bF.isArray(b0));if(b3){for(;b21?aJ.call(arguments,0):bG;if(!(--bw)){bC.resolveWith(bC,bx)}}}function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(arguments,0):bG;bC.notifyWith(bE,bB)}}if(e>1){for(;bv
a";bI=bv.getElementsByTagName("*");bF=bv.getElementsByTagName("a")[0];if(!bI||!bI.length||!bF){return{}}bG=av.createElement("select");bx=bG.appendChild(av.createElement("option"));bE=bv.getElementsByTagName("input")[0];bJ={leadingWhitespace:(bv.firstChild.nodeType===3),tbody:!bv.getElementsByTagName("tbody").length,htmlSerialize:!!bv.getElementsByTagName("link").length,style:/top/.test(bF.getAttribute("style")),hrefNormalized:(bF.getAttribute("href")==="/a"),opacity:/^0.55/.test(bF.style.opacity),cssFloat:!!bF.style.cssFloat,checkOn:(bE.value==="on"),optSelected:bx.selected,getSetAttribute:bv.className!=="t",enctype:!!av.createElement("form").enctype,html5Clone:av.createElement("nav").cloneNode(true).outerHTML!=="<:nav>",submitBubbles:true,changeBubbles:true,focusinBubbles:false,deleteExpando:true,noCloneEvent:true,inlineBlockNeedsLayout:false,shrinkWrapBlocks:false,reliableMarginRight:true};bE.checked=true;bJ.noCloneChecked=bE.cloneNode(true).checked;bG.disabled=true;bJ.optDisabled=!bx.disabled;try{delete bv.test}catch(bC){bJ.deleteExpando=false}if(!bv.addEventListener&&bv.attachEvent&&bv.fireEvent){bv.attachEvent("onclick",function(){bJ.noCloneEvent=false});bv.cloneNode(true).fireEvent("onclick")}bE=av.createElement("input");bE.value="t";bE.setAttribute("type","radio");bJ.radioValue=bE.value==="t";bE.setAttribute("checked","checked");bv.appendChild(bE);bD=av.createDocumentFragment();bD.appendChild(bv.lastChild);bJ.checkClone=bD.cloneNode(true).cloneNode(true).lastChild.checked;bJ.appendChecked=bE.checked;bD.removeChild(bE);bD.appendChild(bv);bv.innerHTML="";if(bb.getComputedStyle){bA=av.createElement("div");bA.style.width="0";bA.style.marginRight="0";bv.style.width="2px";bv.appendChild(bA);bJ.reliableMarginRight=(parseInt((bb.getComputedStyle(bA,null)||{marginRight:0}).marginRight,10)||0)===0}if(bv.attachEvent){for(by in {submit:1,change:1,focusin:1}){bB="on"+by;bw=(bB in bv);if(!bw){bv.setAttribute(bB,"return;");bw=(typeof bv[bB]==="function")}bJ[by+"Bubbles"]=bw}}bD.removeChild(bv);bD=bG=bx=bA=bv=bE=null;b(function(){var bM,bU,bV,bT,bN,bO,bL,bS,bR,e,bP,bQ=av.getElementsByTagName("body")[0];if(!bQ){return}bL=1;bS="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";bR="visibility:hidden;border:0;";e="style='"+bS+"border:5px solid #000;padding:0;'";bP="
";bM=av.createElement("div");bM.style.cssText=bR+"width:0;height:0;position:static;top:0;margin-top:"+bL+"px";bQ.insertBefore(bM,bQ.firstChild);bv=av.createElement("div");bM.appendChild(bv);bv.innerHTML="
t
";bz=bv.getElementsByTagName("td");bw=(bz[0].offsetHeight===0);bz[0].style.display="";bz[1].style.display="none";bJ.reliableHiddenOffsets=bw&&(bz[0].offsetHeight===0);bv.innerHTML="";bv.style.width=bv.style.paddingLeft="1px";b.boxModel=bJ.boxModel=bv.offsetWidth===2;if(typeof bv.style.zoom!=="undefined"){bv.style.display="inline";bv.style.zoom=1;bJ.inlineBlockNeedsLayout=(bv.offsetWidth===2);bv.style.display="";bv.innerHTML="
";bJ.shrinkWrapBlocks=(bv.offsetWidth!==2)}bv.style.cssText=bS+bR;bv.innerHTML=bP;bU=bv.firstChild;bV=bU.firstChild;bN=bU.nextSibling.firstChild.firstChild;bO={doesNotAddBorder:(bV.offsetTop!==5),doesAddBorderForTableAndCells:(bN.offsetTop===5)};bV.style.position="fixed";bV.style.top="20px";bO.fixedPosition=(bV.offsetTop===20||bV.offsetTop===15);bV.style.position=bV.style.top="";bU.style.overflow="hidden";bU.style.position="relative";bO.subtractsBorderForOverflowNotVisible=(bV.offsetTop===-5);bO.doesNotIncludeMarginInBodyOffset=(bQ.offsetTop!==bL);bQ.removeChild(bM);bv=bM=null;b.extend(bJ,bO)});return bJ})();var aS=/^(?:\{.*\}|\[.*\])$/,aA=/([A-Z])/g;b.extend({cache:{},uuid:0,expando:"jQuery"+(b.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:true,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:true},hasData:function(e){e=e.nodeType?b.cache[e[b.expando]]:e[b.expando];return !!e&&!S(e)},data:function(bx,bv,bz,by){if(!b.acceptData(bx)){return}var bG,bA,bD,bE=b.expando,bC=typeof bv==="string",bF=bx.nodeType,e=bF?b.cache:bx,bw=bF?bx[bE]:bx[bE]&&bE,bB=bv==="events";if((!bw||!e[bw]||(!bB&&!by&&!e[bw].data))&&bC&&bz===L){return}if(!bw){if(bF){bx[bE]=bw=++b.uuid}else{bw=bE}}if(!e[bw]){e[bw]={};if(!bF){e[bw].toJSON=b.noop}}if(typeof bv==="object"||typeof bv==="function"){if(by){e[bw]=b.extend(e[bw],bv)}else{e[bw].data=b.extend(e[bw].data,bv)}}bG=bA=e[bw];if(!by){if(!bA.data){bA.data={}}bA=bA.data}if(bz!==L){bA[b.camelCase(bv)]=bz}if(bB&&!bA[bv]){return bG.events}if(bC){bD=bA[bv];if(bD==null){bD=bA[b.camelCase(bv)]}}else{bD=bA}return bD},removeData:function(bx,bv,by){if(!b.acceptData(bx)){return}var bB,bA,bz,bC=b.expando,bD=bx.nodeType,e=bD?b.cache:bx,bw=bD?bx[bC]:bC;if(!e[bw]){return}if(bv){bB=by?e[bw]:e[bw].data;if(bB){if(!b.isArray(bv)){if(bv in bB){bv=[bv]}else{bv=b.camelCase(bv);if(bv in bB){bv=[bv]}else{bv=bv.split(" ")}}}for(bA=0,bz=bv.length;bA-1){return true}}return false},val:function(bx){var e,bv,by,bw=this[0];if(!arguments.length){if(bw){e=b.valHooks[bw.nodeName.toLowerCase()]||b.valHooks[bw.type];if(e&&"get" in e&&(bv=e.get(bw,"value"))!==L){return bv}bv=bw.value;return typeof bv==="string"?bv.replace(aU,""):bv==null?"":bv}return}by=b.isFunction(bx);return this.each(function(bA){var bz=b(this),bB;if(this.nodeType!==1){return}if(by){bB=bx.call(this,bA,bz.val())}else{bB=bx}if(bB==null){bB=""}else{if(typeof bB==="number"){bB+=""}else{if(b.isArray(bB)){bB=b.map(bB,function(bC){return bC==null?"":bC+""})}}}e=b.valHooks[this.nodeName.toLowerCase()]||b.valHooks[this.type];if(!e||!("set" in e)||e.set(this,bB,"value")===L){this.value=bB}})}});b.extend({valHooks:{option:{get:function(e){var bv=e.attributes.value;return !bv||bv.specified?e.value:e.text}},select:{get:function(e){var bA,bv,bz,bx,by=e.selectedIndex,bB=[],bC=e.options,bw=e.type==="select-one";if(by<0){return null}bv=bw?by:0;bz=bw?by+1:bC.length;for(;bv=0});if(!e.length){bv.selectedIndex=-1}return e}}},attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(bA,bx,bB,bz){var bw,e,by,bv=bA.nodeType;if(!bA||bv===3||bv===8||bv===2){return}if(bz&&bx in b.attrFn){return b(bA)[bx](bB)}if(typeof bA.getAttribute==="undefined"){return b.prop(bA,bx,bB)}by=bv!==1||!b.isXMLDoc(bA);if(by){bx=bx.toLowerCase();e=b.attrHooks[bx]||(ao.test(bx)?aY:be)}if(bB!==L){if(bB===null){b.removeAttr(bA,bx);return}else{if(e&&"set" in e&&by&&(bw=e.set(bA,bB,bx))!==L){return bw}else{bA.setAttribute(bx,""+bB);return bB}}}else{if(e&&"get" in e&&by&&(bw=e.get(bA,bx))!==null){return bw}else{bw=bA.getAttribute(bx);return bw===null?L:bw}}},removeAttr:function(bx,bz){var by,bA,bv,e,bw=0;if(bz&&bx.nodeType===1){bA=bz.toLowerCase().split(af);e=bA.length;for(;bw=0)}}})});var bd=/^(?:textarea|input|select)$/i,n=/^([^\.]*)?(?:\.(.+))?$/,J=/\bhover(\.\S+)?\b/,aO=/^key/,bf=/^(?:mouse|contextmenu)|click/,T=/^(?:focusinfocus|focusoutblur)$/,U=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,Y=function(e){var bv=U.exec(e);if(bv){bv[1]=(bv[1]||"").toLowerCase();bv[3]=bv[3]&&new RegExp("(?:^|\\s)"+bv[3]+"(?:\\s|$)")}return bv},j=function(bw,e){var bv=bw.attributes||{};return((!e[1]||bw.nodeName.toLowerCase()===e[1])&&(!e[2]||(bv.id||{}).value===e[2])&&(!e[3]||e[3].test((bv["class"]||{}).value)))},bt=function(e){return b.event.special.hover?e:e.replace(J,"mouseenter$1 mouseleave$1")};b.event={add:function(bx,bC,bJ,bA,by){var bD,bB,bK,bI,bH,bF,e,bG,bv,bz,bw,bE;if(bx.nodeType===3||bx.nodeType===8||!bC||!bJ||!(bD=b._data(bx))){return}if(bJ.handler){bv=bJ;bJ=bv.handler}if(!bJ.guid){bJ.guid=b.guid++}bK=bD.events;if(!bK){bD.events=bK={}}bB=bD.handle;if(!bB){bD.handle=bB=function(bL){return typeof b!=="undefined"&&(!bL||b.event.triggered!==bL.type)?b.event.dispatch.apply(bB.elem,arguments):L};bB.elem=bx}bC=b.trim(bt(bC)).split(" ");for(bI=0;bI=0){bG=bG.slice(0,-1);bw=true}if(bG.indexOf(".")>=0){bx=bG.split(".");bG=bx.shift();bx.sort()}if((!bA||b.event.customEvent[bG])&&!b.event.global[bG]){return}bv=typeof bv==="object"?bv[b.expando]?bv:new b.Event(bG,bv):new b.Event(bG);bv.type=bG;bv.isTrigger=true;bv.exclusive=bw;bv.namespace=bx.join(".");bv.namespace_re=bv.namespace?new RegExp("(^|\\.)"+bx.join("\\.(?:.*\\.)?")+"(\\.|$)"):null;by=bG.indexOf(":")<0?"on"+bG:"";if(!bA){e=b.cache;for(bC in e){if(e[bC].events&&e[bC].events[bG]){b.event.trigger(bv,bD,e[bC].handle.elem,true)}}return}bv.result=L;if(!bv.target){bv.target=bA}bD=bD!=null?b.makeArray(bD):[];bD.unshift(bv);bF=b.event.special[bG]||{};if(bF.trigger&&bF.trigger.apply(bA,bD)===false){return}bB=[[bA,bF.bindType||bG]];if(!bJ&&!bF.noBubble&&!b.isWindow(bA)){bI=bF.delegateType||bG;bH=T.test(bI+bG)?bA:bA.parentNode;bz=null;for(;bH;bH=bH.parentNode){bB.push([bH,bI]);bz=bH}if(bz&&bz===bA.ownerDocument){bB.push([bz.defaultView||bz.parentWindow||bb,bI])}}for(bC=0;bCbA){bH.push({elem:this,matches:bz.slice(bA)})}for(bC=0;bC0?this.on(e,null,bx,bw):this.trigger(e)};if(b.attrFn){b.attrFn[e]=true}if(aO.test(e)){b.event.fixHooks[e]=b.event.keyHooks}if(bf.test(e)){b.event.fixHooks[e]=b.event.mouseHooks}}); +/*! + * Sizzle CSS Selector Engine + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * More information: http://sizzlejs.com/ + */ +(function(){var bH=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,bC="sizcache"+(Math.random()+"").replace(".",""),bI=0,bL=Object.prototype.toString,bB=false,bA=true,bK=/\\/g,bO=/\r\n/g,bQ=/\W/;[0,0].sort(function(){bA=false;return 0});var by=function(bV,e,bY,bZ){bY=bY||[];e=e||av;var b1=e;if(e.nodeType!==1&&e.nodeType!==9){return[]}if(!bV||typeof bV!=="string"){return bY}var bS,b3,b6,bR,b2,b5,b4,bX,bU=true,bT=by.isXML(e),bW=[],b0=bV;do{bH.exec("");bS=bH.exec(b0);if(bS){b0=bS[3];bW.push(bS[1]);if(bS[2]){bR=bS[3];break}}}while(bS);if(bW.length>1&&bD.exec(bV)){if(bW.length===2&&bE.relative[bW[0]]){b3=bM(bW[0]+bW[1],e,bZ)}else{b3=bE.relative[bW[0]]?[e]:by(bW.shift(),e);while(bW.length){bV=bW.shift();if(bE.relative[bV]){bV+=bW.shift()}b3=bM(bV,b3,bZ)}}}else{if(!bZ&&bW.length>1&&e.nodeType===9&&!bT&&bE.match.ID.test(bW[0])&&!bE.match.ID.test(bW[bW.length-1])){b2=by.find(bW.shift(),e,bT);e=b2.expr?by.filter(b2.expr,b2.set)[0]:b2.set[0]}if(e){b2=bZ?{expr:bW.pop(),set:bF(bZ)}:by.find(bW.pop(),bW.length===1&&(bW[0]==="~"||bW[0]==="+")&&e.parentNode?e.parentNode:e,bT);b3=b2.expr?by.filter(b2.expr,b2.set):b2.set;if(bW.length>0){b6=bF(b3)}else{bU=false}while(bW.length){b5=bW.pop();b4=b5;if(!bE.relative[b5]){b5=""}else{b4=bW.pop()}if(b4==null){b4=e}bE.relative[b5](b6,b4,bT)}}else{b6=bW=[]}}if(!b6){b6=b3}if(!b6){by.error(b5||bV)}if(bL.call(b6)==="[object Array]"){if(!bU){bY.push.apply(bY,b6)}else{if(e&&e.nodeType===1){for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&(b6[bX]===true||b6[bX].nodeType===1&&by.contains(e,b6[bX]))){bY.push(b3[bX])}}}else{for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&b6[bX].nodeType===1){bY.push(b3[bX])}}}}}else{bF(b6,bY)}if(bR){by(bR,b1,bY,bZ);by.uniqueSort(bY)}return bY};by.uniqueSort=function(bR){if(bJ){bB=bA;bR.sort(bJ);if(bB){for(var e=1;e0};by.find=function(bX,e,bY){var bW,bS,bU,bT,bV,bR;if(!bX){return[]}for(bS=0,bU=bE.order.length;bS":function(bW,bR){var bV,bU=typeof bR==="string",bS=0,e=bW.length;if(bU&&!bQ.test(bR)){bR=bR.toLowerCase();for(;bS=0)){if(!bS){e.push(bV)}}else{if(bS){bR[bU]=false}}}}return false},ID:function(e){return e[1].replace(bK,"")},TAG:function(bR,e){return bR[1].replace(bK,"").toLowerCase()},CHILD:function(e){if(e[1]==="nth"){if(!e[2]){by.error(e[0])}e[2]=e[2].replace(/^\+|\s*/g,"");var bR=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(e[2]==="even"&&"2n"||e[2]==="odd"&&"2n+1"||!/\D/.test(e[2])&&"0n+"+e[2]||e[2]);e[2]=(bR[1]+(bR[2]||1))-0;e[3]=bR[3]-0}else{if(e[2]){by.error(e[0])}}e[0]=bI++;return e},ATTR:function(bU,bR,bS,e,bV,bW){var bT=bU[1]=bU[1].replace(bK,"");if(!bW&&bE.attrMap[bT]){bU[1]=bE.attrMap[bT]}bU[4]=(bU[4]||bU[5]||"").replace(bK,"");if(bU[2]==="~="){bU[4]=" "+bU[4]+" "}return bU},PSEUDO:function(bU,bR,bS,e,bV){if(bU[1]==="not"){if((bH.exec(bU[3])||"").length>1||/^\w/.test(bU[3])){bU[3]=by(bU[3],null,null,bR)}else{var bT=by.filter(bU[3],bR,bS,true^bV);if(!bS){e.push.apply(e,bT)}return false}}else{if(bE.match.POS.test(bU[0])||bE.match.CHILD.test(bU[0])){return true}}return bU},POS:function(e){e.unshift(true);return e}},filters:{enabled:function(e){return e.disabled===false&&e.type!=="hidden"},disabled:function(e){return e.disabled===true},checked:function(e){return e.checked===true},selected:function(e){if(e.parentNode){e.parentNode.selectedIndex}return e.selected===true},parent:function(e){return !!e.firstChild},empty:function(e){return !e.firstChild},has:function(bS,bR,e){return !!by(e[3],bS).length},header:function(e){return(/h\d/i).test(e.nodeName)},text:function(bS){var e=bS.getAttribute("type"),bR=bS.type;return bS.nodeName.toLowerCase()==="input"&&"text"===bR&&(e===bR||e===null)},radio:function(e){return e.nodeName.toLowerCase()==="input"&&"radio"===e.type},checkbox:function(e){return e.nodeName.toLowerCase()==="input"&&"checkbox"===e.type},file:function(e){return e.nodeName.toLowerCase()==="input"&&"file"===e.type},password:function(e){return e.nodeName.toLowerCase()==="input"&&"password"===e.type},submit:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"submit"===bR.type},image:function(e){return e.nodeName.toLowerCase()==="input"&&"image"===e.type},reset:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"reset"===bR.type},button:function(bR){var e=bR.nodeName.toLowerCase();return e==="input"&&"button"===bR.type||e==="button"},input:function(e){return(/input|select|textarea|button/i).test(e.nodeName)},focus:function(e){return e===e.ownerDocument.activeElement}},setFilters:{first:function(bR,e){return e===0},last:function(bS,bR,e,bT){return bR===bT.length-1},even:function(bR,e){return e%2===0},odd:function(bR,e){return e%2===1},lt:function(bS,bR,e){return bRe[3]-0},nth:function(bS,bR,e){return e[3]-0===bR},eq:function(bS,bR,e){return e[3]-0===bR}},filter:{PSEUDO:function(bS,bX,bW,bY){var e=bX[1],bR=bE.filters[e];if(bR){return bR(bS,bW,bX,bY)}else{if(e==="contains"){return(bS.textContent||bS.innerText||bw([bS])||"").indexOf(bX[3])>=0}else{if(e==="not"){var bT=bX[3];for(var bV=0,bU=bT.length;bV=0)}}},ID:function(bR,e){return bR.nodeType===1&&bR.getAttribute("id")===e},TAG:function(bR,e){return(e==="*"&&bR.nodeType===1)||!!bR.nodeName&&bR.nodeName.toLowerCase()===e},CLASS:function(bR,e){return(" "+(bR.className||bR.getAttribute("class"))+" ").indexOf(e)>-1},ATTR:function(bV,bT){var bS=bT[1],e=by.attr?by.attr(bV,bS):bE.attrHandle[bS]?bE.attrHandle[bS](bV):bV[bS]!=null?bV[bS]:bV.getAttribute(bS),bW=e+"",bU=bT[2],bR=bT[4];return e==null?bU==="!=":!bU&&by.attr?e!=null:bU==="="?bW===bR:bU==="*="?bW.indexOf(bR)>=0:bU==="~="?(" "+bW+" ").indexOf(bR)>=0:!bR?bW&&e!==false:bU==="!="?bW!==bR:bU==="^="?bW.indexOf(bR)===0:bU==="$="?bW.substr(bW.length-bR.length)===bR:bU==="|="?bW===bR||bW.substr(0,bR.length+1)===bR+"-":false},POS:function(bU,bR,bS,bV){var e=bR[2],bT=bE.setFilters[e];if(bT){return bT(bU,bS,bR,bV)}}}};var bD=bE.match.POS,bx=function(bR,e){return"\\"+(e-0+1)};for(var bz in bE.match){bE.match[bz]=new RegExp(bE.match[bz].source+(/(?![^\[]*\])(?![^\(]*\))/.source));bE.leftMatch[bz]=new RegExp(/(^(?:.|\r|\n)*?)/.source+bE.match[bz].source.replace(/\\(\d+)/g,bx))}var bF=function(bR,e){bR=Array.prototype.slice.call(bR,0);if(e){e.push.apply(e,bR);return e}return bR};try{Array.prototype.slice.call(av.documentElement.childNodes,0)[0].nodeType}catch(bP){bF=function(bU,bT){var bS=0,bR=bT||[];if(bL.call(bU)==="[object Array]"){Array.prototype.push.apply(bR,bU)}else{if(typeof bU.length==="number"){for(var e=bU.length;bS";e.insertBefore(bR,e.firstChild);if(av.getElementById(bS)){bE.find.ID=function(bU,bV,bW){if(typeof bV.getElementById!=="undefined"&&!bW){var bT=bV.getElementById(bU[1]);return bT?bT.id===bU[1]||typeof bT.getAttributeNode!=="undefined"&&bT.getAttributeNode("id").nodeValue===bU[1]?[bT]:L:[]}};bE.filter.ID=function(bV,bT){var bU=typeof bV.getAttributeNode!=="undefined"&&bV.getAttributeNode("id");return bV.nodeType===1&&bU&&bU.nodeValue===bT}}e.removeChild(bR);e=bR=null})();(function(){var e=av.createElement("div");e.appendChild(av.createComment(""));if(e.getElementsByTagName("*").length>0){bE.find.TAG=function(bR,bV){var bU=bV.getElementsByTagName(bR[1]);if(bR[1]==="*"){var bT=[];for(var bS=0;bU[bS];bS++){if(bU[bS].nodeType===1){bT.push(bU[bS])}}bU=bT}return bU}}e.innerHTML="";if(e.firstChild&&typeof e.firstChild.getAttribute!=="undefined"&&e.firstChild.getAttribute("href")!=="#"){bE.attrHandle.href=function(bR){return bR.getAttribute("href",2)}}e=null})();if(av.querySelectorAll){(function(){var e=by,bT=av.createElement("div"),bS="__sizzle__";bT.innerHTML="

";if(bT.querySelectorAll&&bT.querySelectorAll(".TEST").length===0){return}by=function(b4,bV,bZ,b3){bV=bV||av;if(!b3&&!by.isXML(bV)){var b2=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b4);if(b2&&(bV.nodeType===1||bV.nodeType===9)){if(b2[1]){return bF(bV.getElementsByTagName(b4),bZ)}else{if(b2[2]&&bE.find.CLASS&&bV.getElementsByClassName){return bF(bV.getElementsByClassName(b2[2]),bZ)}}}if(bV.nodeType===9){if(b4==="body"&&bV.body){return bF([bV.body],bZ)}else{if(b2&&b2[3]){var bY=bV.getElementById(b2[3]);if(bY&&bY.parentNode){if(bY.id===b2[3]){return bF([bY],bZ)}}else{return bF([],bZ)}}}try{return bF(bV.querySelectorAll(b4),bZ)}catch(b0){}}else{if(bV.nodeType===1&&bV.nodeName.toLowerCase()!=="object"){var bW=bV,bX=bV.getAttribute("id"),bU=bX||bS,b6=bV.parentNode,b5=/^\s*[+~]/.test(b4);if(!bX){bV.setAttribute("id",bU)}else{bU=bU.replace(/'/g,"\\$&")}if(b5&&b6){bV=bV.parentNode}try{if(!b5||b6){return bF(bV.querySelectorAll("[id='"+bU+"'] "+b4),bZ)}}catch(b1){}finally{if(!bX){bW.removeAttribute("id")}}}}}return e(b4,bV,bZ,b3)};for(var bR in e){by[bR]=e[bR]}bT=null})()}(function(){var e=av.documentElement,bS=e.matchesSelector||e.mozMatchesSelector||e.webkitMatchesSelector||e.msMatchesSelector;if(bS){var bU=!bS.call(av.createElement("div"),"div"),bR=false;try{bS.call(av.documentElement,"[test!='']:sizzle")}catch(bT){bR=true}by.matchesSelector=function(bW,bY){bY=bY.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!by.isXML(bW)){try{if(bR||!bE.match.PSEUDO.test(bY)&&!/!=/.test(bY)){var bV=bS.call(bW,bY);if(bV||!bU||bW.document&&bW.document.nodeType!==11){return bV}}}catch(bX){}}return by(bY,null,null,[bW]).length>0}}})();(function(){var e=av.createElement("div");e.innerHTML="
";if(!e.getElementsByClassName||e.getElementsByClassName("e").length===0){return}e.lastChild.className="e";if(e.getElementsByClassName("e").length===1){return}bE.order.splice(1,0,"CLASS");bE.find.CLASS=function(bR,bS,bT){if(typeof bS.getElementsByClassName!=="undefined"&&!bT){return bS.getElementsByClassName(bR[1])}};e=null})();function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT0){bU=e;break}}}e=e[bR]}bZ[bT]=bU}}}if(av.documentElement.contains){by.contains=function(bR,e){return bR!==e&&(bR.contains?bR.contains(e):true)}}else{if(av.documentElement.compareDocumentPosition){by.contains=function(bR,e){return !!(bR.compareDocumentPosition(e)&16)}}else{by.contains=function(){return false}}}by.isXML=function(e){var bR=(e?e.ownerDocument||e:0).documentElement;return bR?bR.nodeName!=="HTML":false};var bM=function(bS,e,bW){var bV,bX=[],bU="",bY=e.nodeType?[e]:e;while((bV=bE.match.PSEUDO.exec(bS))){bU+=bV[0];bS=bS.replace(bE.match.PSEUDO,"")}bS=bE.relative[bS]?bS+"*":bS;for(var bT=0,bR=bY.length;bT0){for(bB=bA;bB=0:b.filter(e,this).length>0:this.filter(e).length>0)},closest:function(by,bx){var bv=[],bw,e,bz=this[0];if(b.isArray(by)){var bB=1;while(bz&&bz.ownerDocument&&bz!==bx){for(bw=0;bw-1:b.find.matchesSelector(bz,by)){bv.push(bz);break}else{bz=bz.parentNode;if(!bz||!bz.ownerDocument||bz===bx||bz.nodeType===11){break}}}}bv=bv.length>1?b.unique(bv):bv;return this.pushStack(bv,"closest",by)},index:function(e){if(!e){return(this[0]&&this[0].parentNode)?this.prevAll().length:-1}if(typeof e==="string"){return b.inArray(this[0],b(e))}return b.inArray(e.jquery?e[0]:e,this)},add:function(e,bv){var bx=typeof e==="string"?b(e,bv):b.makeArray(e&&e.nodeType?[e]:e),bw=b.merge(this.get(),bx);return this.pushStack(C(bx[0])||C(bw[0])?bw:b.unique(bw))},andSelf:function(){return this.add(this.prevObject)}});function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}b.each({parent:function(bv){var e=bv.parentNode;return e&&e.nodeType!==11?e:null},parents:function(e){return b.dir(e,"parentNode")},parentsUntil:function(bv,e,bw){return b.dir(bv,"parentNode",bw)},next:function(e){return b.nth(e,2,"nextSibling")},prev:function(e){return b.nth(e,2,"previousSibling")},nextAll:function(e){return b.dir(e,"nextSibling")},prevAll:function(e){return b.dir(e,"previousSibling")},nextUntil:function(bv,e,bw){return b.dir(bv,"nextSibling",bw)},prevUntil:function(bv,e,bw){return b.dir(bv,"previousSibling",bw)},siblings:function(e){return b.sibling(e.parentNode.firstChild,e)},children:function(e){return b.sibling(e.firstChild)},contents:function(e){return b.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:b.makeArray(e.childNodes)}},function(e,bv){b.fn[e]=function(by,bw){var bx=b.map(this,bv,by);if(!ab.test(e)){bw=by}if(bw&&typeof bw==="string"){bx=b.filter(bw,bx)}bx=this.length>1&&!ay[e]?b.unique(bx):bx;if((this.length>1||a9.test(bw))&&aq.test(e)){bx=bx.reverse()}return this.pushStack(bx,e,P.call(arguments).join(","))}});b.extend({filter:function(bw,e,bv){if(bv){bw=":not("+bw+")"}return e.length===1?b.find.matchesSelector(e[0],bw)?[e[0]]:[]:b.find.matches(bw,e)},dir:function(bw,bv,by){var e=[],bx=bw[bv];while(bx&&bx.nodeType!==9&&(by===L||bx.nodeType!==1||!b(bx).is(by))){if(bx.nodeType===1){e.push(bx)}bx=bx[bv]}return e},nth:function(by,e,bw,bx){e=e||1;var bv=0;for(;by;by=by[bw]){if(by.nodeType===1&&++bv===e){break}}return by},sibling:function(bw,bv){var e=[];for(;bw;bw=bw.nextSibling){if(bw.nodeType===1&&bw!==bv){e.push(bw)}}return e}});function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,function(bz,by){var bA=!!bw.call(bz,by,bz);return bA===e})}else{if(bw.nodeType){return b.grep(bx,function(bz,by){return(bz===bw)===e})}else{if(typeof bw==="string"){var bv=b.grep(bx,function(by){return by.nodeType===1});if(bp.test(bw)){return b.filter(bw,bv,!e)}else{bw=b.filter(bw,bv)}}}}return b.grep(bx,function(bz,by){return(b.inArray(bz,bw)>=0)===e})}function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.createElement){while(bw.length){bv.createElement(bw.pop())}}return bv}var aR="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",ag=/ jQuery\d+="(?:\d+|null)"/g,ar=/^\s+/,R=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,d=/<([\w:]+)/,w=/",""],legend:[1,"
","
"],thead:[1,"","
"],tr:[2,"","
"],td:[3,"","
"],col:[2,"","
"],area:[1,"",""],_default:[0,"",""]},ac=a(av);ax.optgroup=ax.option;ax.tbody=ax.tfoot=ax.colgroup=ax.caption=ax.thead;ax.th=ax.td;if(!b.support.htmlSerialize){ax._default=[1,"div
","
"]}b.fn.extend({text:function(e){if(b.isFunction(e)){return this.each(function(bw){var bv=b(this);bv.text(e.call(this,bw,bv.text()))})}if(typeof e!=="object"&&e!==L){return this.empty().append((this[0]&&this[0].ownerDocument||av).createTextNode(e))}return b.text(this)},wrapAll:function(e){if(b.isFunction(e)){return this.each(function(bw){b(this).wrapAll(e.call(this,bw))})}if(this[0]){var bv=b(e,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){bv.insertBefore(this[0])}bv.map(function(){var bw=this;while(bw.firstChild&&bw.firstChild.nodeType===1){bw=bw.firstChild}return bw}).append(this)}return this},wrapInner:function(e){if(b.isFunction(e)){return this.each(function(bv){b(this).wrapInner(e.call(this,bv))})}return this.each(function(){var bv=b(this),bw=bv.contents();if(bw.length){bw.wrapAll(e)}else{bv.append(e)}})},wrap:function(e){var bv=b.isFunction(e);return this.each(function(bw){b(this).wrapAll(bv?e.call(this,bw):e)})},unwrap:function(){return this.parent().each(function(){if(!b.nodeName(this,"body")){b(this).replaceWith(this.childNodes)}}).end()},append:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.appendChild(e)}})},prepend:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.insertBefore(e,this.firstChild)}})},before:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this)})}else{if(arguments.length){var e=b.clean(arguments);e.push.apply(e,this.toArray());return this.pushStack(e,"before",arguments)}}},after:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this.nextSibling)})}else{if(arguments.length){var e=this.pushStack(this,"after",arguments);e.push.apply(e,b.clean(arguments));return e}}},remove:function(e,bx){for(var bv=0,bw;(bw=this[bv])!=null;bv++){if(!e||b.filter(e,[bw]).length){if(!bx&&bw.nodeType===1){b.cleanData(bw.getElementsByTagName("*"));b.cleanData([bw])}if(bw.parentNode){bw.parentNode.removeChild(bw)}}}return this},empty:function(){for(var e=0,bv;(bv=this[e])!=null;e++){if(bv.nodeType===1){b.cleanData(bv.getElementsByTagName("*"))}while(bv.firstChild){bv.removeChild(bv.firstChild)}}return this},clone:function(bv,e){bv=bv==null?false:bv;e=e==null?bv:e;return this.map(function(){return b.clone(this,bv,e)})},html:function(bx){if(bx===L){return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(ag,""):null}else{if(typeof bx==="string"&&!ae.test(bx)&&(b.support.leadingWhitespace||!ar.test(bx))&&!ax[(d.exec(bx)||["",""])[1].toLowerCase()]){bx=bx.replace(R,"<$1>");try{for(var bw=0,bv=this.length;bw1&&bw0?this.clone(true):this).get();b(bC[bA])[bv](by);bz=bz.concat(by)}return this.pushStack(bz,e,bC.selector)}}});function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e.getElementsByTagName("*")}else{if(typeof e.querySelectorAll!=="undefined"){return e.querySelectorAll("*")}else{return[]}}}function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecked=e.checked}}function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(e)}else{if(bv!=="script"&&typeof e.getElementsByTagName!=="undefined"){b.grep(e.getElementsByTagName("input"),az)}}}function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.innerHTML=e.outerHTML;return bv.firstChild}b.extend({clone:function(by,bA,bw){var e,bv,bx,bz=b.support.html5Clone||!ah.test("<"+by.nodeName)?by.cloneNode(true):al(by);if((!b.support.noCloneEvent||!b.support.noCloneChecked)&&(by.nodeType===1||by.nodeType===11)&&!b.isXMLDoc(by)){ai(by,bz);e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){if(bv[bx]){ai(e[bx],bv[bx])}}}if(bA){t(by,bz);if(bw){e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){t(e[bx],bv[bx])}}}e=bv=null;return bz},clean:function(bw,by,bH,bA){var bF;by=by||av;if(typeof by.createElement==="undefined"){by=by.ownerDocument||by[0]&&by[0].ownerDocument||av}var bI=[],bB;for(var bE=0,bz;(bz=bw[bE])!=null;bE++){if(typeof bz==="number"){bz+=""}if(!bz){continue}if(typeof bz==="string"){if(!W.test(bz)){bz=by.createTextNode(bz)}else{bz=bz.replace(R,"<$1>");var bK=(d.exec(bz)||["",""])[1].toLowerCase(),bx=ax[bK]||ax._default,bD=bx[0],bv=by.createElement("div");if(by===av){ac.appendChild(bv)}else{a(by).appendChild(bv)}bv.innerHTML=bx[1]+bz+bx[2];while(bD--){bv=bv.lastChild}if(!b.support.tbody){var e=w.test(bz),bC=bK==="table"&&!e?bv.firstChild&&bv.firstChild.childNodes:bx[1]===""&&!e?bv.childNodes:[];for(bB=bC.length-1;bB>=0;--bB){if(b.nodeName(bC[bB],"tbody")&&!bC[bB].childNodes.length){bC[bB].parentNode.removeChild(bC[bB])}}}if(!b.support.leadingWhitespace&&ar.test(bz)){bv.insertBefore(by.createTextNode(ar.exec(bz)[0]),bv.firstChild)}bz=bv.childNodes}}var bG;if(!b.support.appendChecked){if(bz[0]&&typeof(bG=bz.length)==="number"){for(bB=0;bB=0){return bx+"px"}}else{return bx}}}});if(!b.support.opacity){b.cssHooks.opacity={get:function(bv,e){return au.test((e&&bv.currentStyle?bv.currentStyle.filter:bv.style.filter)||"")?(parseFloat(RegExp.$1)/100)+"":e?"1":""},set:function(by,bz){var bx=by.style,bv=by.currentStyle,e=b.isNumeric(bz)?"alpha(opacity="+bz*100+")":"",bw=bv&&bv.filter||bx.filter||"";bx.zoom=1;if(bz>=1&&b.trim(bw.replace(ak,""))===""){bx.removeAttribute("filter");if(bv&&!bv.filter){return}}bx.filter=ak.test(bw)?bw.replace(ak,e):bw+" "+e}}}b(function(){if(!b.support.reliableMarginRight){b.cssHooks.marginRight={get:function(bw,bv){var e;b.swap(bw,{display:"inline-block"},function(){if(bv){e=Z(bw,"margin-right","marginRight")}else{e=bw.style.marginRight}});return e}}}});if(av.defaultView&&av.defaultView.getComputedStyle){aI=function(by,bw){var bv,bx,e;bw=bw.replace(z,"-$1").toLowerCase();if((bx=by.ownerDocument.defaultView)&&(e=bx.getComputedStyle(by,null))){bv=e.getPropertyValue(bw);if(bv===""&&!b.contains(by.ownerDocument.documentElement,by)){bv=b.style(by,bw)}}return bv}}if(av.documentElement.currentStyle){aX=function(bz,bw){var bA,e,by,bv=bz.currentStyle&&bz.currentStyle[bw],bx=bz.style;if(bv===null&&bx&&(by=bx[bw])){bv=by}if(!bc.test(bv)&&bn.test(bv)){bA=bx.left;e=bz.runtimeStyle&&bz.runtimeStyle.left;if(e){bz.runtimeStyle.left=bz.currentStyle.left}bx.left=bw==="fontSize"?"1em":(bv||0);bv=bx.pixelLeft+"px";bx.left=bA;if(e){bz.runtimeStyle.left=e}}return bv===""?"auto":bv}}Z=aI||aX;function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,bz=bw==="width"?an:a1,bx=0,e=bz.length;if(bA>0){if(bv!=="border"){for(;bx)<[^<]*)*<\/script>/gi,q=/^(?:select|textarea)/i,h=/\s+/,br=/([?&])_=[^&]*/,K=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,A=b.fn.load,aa={},r={},aE,s,aV=["*/"]+["*"];try{aE=bl.href}catch(aw){aE=av.createElement("a");aE.href="";aE=aE.href}s=K.exec(aE.toLowerCase())||[];function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="*"}if(b.isFunction(bA)){var bx=by.toLowerCase().split(h),bw=0,bz=bx.length,bv,bB,bC;for(;bw=0){var e=bw.slice(by,bw.length);bw=bw.slice(0,by)}var bx="GET";if(bz){if(b.isFunction(bz)){bA=bz;bz=L}else{if(typeof bz==="object"){bz=b.param(bz,b.ajaxSettings.traditional);bx="POST"}}}var bv=this;b.ajax({url:bw,type:bx,dataType:"html",data:bz,complete:function(bC,bB,bD){bD=bC.responseText;if(bC.isResolved()){bC.done(function(bE){bD=bE});bv.html(e?b("
").append(bD.replace(a6,"")).find(e):bD)}if(bA){bv.each(bA,[bD,bB,bC])}}});return this},serialize:function(){return b.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?b.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||q.test(this.nodeName)||aZ.test(this.type))}).map(function(e,bv){var bw=b(this).val();return bw==null?null:b.isArray(bw)?b.map(bw,function(by,bx){return{name:bv.name,value:by.replace(bs,"\r\n")}}):{name:bv.name,value:bw.replace(bs,"\r\n")}}).get()}});b.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(e,bv){b.fn[bv]=function(bw){return this.on(bv,bw)}});b.each(["get","post"],function(e,bv){b[bv]=function(bw,by,bz,bx){if(b.isFunction(by)){bx=bx||bz;bz=by;by=L}return b.ajax({type:bv,url:bw,data:by,success:bz,dataType:bx})}});b.extend({getScript:function(e,bv){return b.get(e,L,bv,"script")},getJSON:function(e,bv,bw){return b.get(e,bv,bw,"json")},ajaxSetup:function(bv,e){if(e){am(bv,b.ajaxSettings)}else{e=bv;bv=b.ajaxSettings}am(bv,e);return bv},ajaxSettings:{url:aE,isLocal:aM.test(s[1]),global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":aV},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":bb.String,"text html":true,"text json":b.parseJSON,"text xml":b.parseXML},flatOptions:{context:true,url:true}},ajaxPrefilter:f(aa),ajaxTransport:f(r),ajax:function(bz,bx){if(typeof bz==="object"){bx=bz;bz=L}bx=bx||{};var bD=b.ajaxSetup({},bx),bS=bD.context||bD,bG=bS!==bD&&(bS.nodeType||bS instanceof b)?b(bS):b.event,bR=b.Deferred(),bN=b.Callbacks("once memory"),bB=bD.statusCode||{},bC,bH={},bO={},bQ,by,bL,bE,bI,bA=0,bw,bK,bJ={readyState:0,setRequestHeader:function(bT,bU){if(!bA){var e=bT.toLowerCase();bT=bO[e]=bO[e]||bT;bH[bT]=bU}return this},getAllResponseHeaders:function(){return bA===2?bQ:null},getResponseHeader:function(bT){var e;if(bA===2){if(!by){by={};while((e=aD.exec(bQ))){by[e[1].toLowerCase()]=e[2]}}e=by[bT.toLowerCase()]}return e===L?null:e},overrideMimeType:function(e){if(!bA){bD.mimeType=e}return this},abort:function(e){e=e||"abort";if(bL){bL.abort(e)}bF(0,e);return this}};function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}bL=L;bQ=bW||"";bJ.readyState=bZ>0?4:0;var bT,b4,b3,bX=bU,bY=b0?bj(bD,bJ,b0):L,bV,b2;if(bZ>=200&&bZ<300||bZ===304){if(bD.ifModified){if((bV=bJ.getResponseHeader("Last-Modified"))){b.lastModified[bC]=bV}if((b2=bJ.getResponseHeader("Etag"))){b.etag[bC]=b2}}if(bZ===304){bX="notmodified";bT=true}else{try{b4=G(bD,bY);bX="success";bT=true}catch(b1){bX="parsererror";b3=b1}}}else{b3=bX;if(!bX||bZ){bX="error";if(bZ<0){bZ=0}}}bJ.status=bZ;bJ.statusText=""+(bU||bX);if(bT){bR.resolveWith(bS,[b4,bX,bJ])}else{bR.rejectWith(bS,[bJ,bX,b3])}bJ.statusCode(bB);bB=L;if(bw){bG.trigger("ajax"+(bT?"Success":"Error"),[bJ,bD,bT?b4:b3])}bN.fireWith(bS,[bJ,bX]);if(bw){bG.trigger("ajaxComplete",[bJ,bD]);if(!(--b.active)){b.event.trigger("ajaxStop")}}}bR.promise(bJ);bJ.success=bJ.done;bJ.error=bJ.fail;bJ.complete=bN.add;bJ.statusCode=function(bT){if(bT){var e;if(bA<2){for(e in bT){bB[e]=[bB[e],bT[e]]}}else{e=bT[bJ.status];bJ.then(e,e)}}return this};bD.url=((bz||bD.url)+"").replace(bq,"").replace(c,s[1]+"//");bD.dataTypes=b.trim(bD.dataType||"*").toLowerCase().split(h);if(bD.crossDomain==null){bI=K.exec(bD.url.toLowerCase());bD.crossDomain=!!(bI&&(bI[1]!=s[1]||bI[2]!=s[2]||(bI[3]||(bI[1]==="http:"?80:443))!=(s[3]||(s[1]==="http:"?80:443))))}if(bD.data&&bD.processData&&typeof bD.data!=="string"){bD.data=b.param(bD.data,bD.traditional)}aW(aa,bD,bx,bJ);if(bA===2){return false}bw=bD.global;bD.type=bD.type.toUpperCase();bD.hasContent=!aQ.test(bD.type);if(bw&&b.active++===0){b.event.trigger("ajaxStart")}if(!bD.hasContent){if(bD.data){bD.url+=(M.test(bD.url)?"&":"?")+bD.data;delete bD.data}bC=bD.url;if(bD.cache===false){var bv=b.now(),bP=bD.url.replace(br,"$1_="+bv);bD.url=bP+((bP===bD.url)?(M.test(bD.url)?"&":"?")+"_="+bv:"")}}if(bD.data&&bD.hasContent&&bD.contentType!==false||bx.contentType){bJ.setRequestHeader("Content-Type",bD.contentType)}if(bD.ifModified){bC=bC||bD.url;if(b.lastModified[bC]){bJ.setRequestHeader("If-Modified-Since",b.lastModified[bC])}if(b.etag[bC]){bJ.setRequestHeader("If-None-Match",b.etag[bC])}}bJ.setRequestHeader("Accept",bD.dataTypes[0]&&bD.accepts[bD.dataTypes[0]]?bD.accepts[bD.dataTypes[0]]+(bD.dataTypes[0]!=="*"?", "+aV+"; q=0.01":""):bD.accepts["*"]);for(bK in bD.headers){bJ.setRequestHeader(bK,bD.headers[bK])}if(bD.beforeSend&&(bD.beforeSend.call(bS,bJ,bD)===false||bA===2)){bJ.abort();return false}for(bK in {success:1,error:1,complete:1}){bJ[bK](bD[bK])}bL=aW(r,bD,bx,bJ);if(!bL){bF(-1,"No Transport")}else{bJ.readyState=1;if(bw){bG.trigger("ajaxSend",[bJ,bD])}if(bD.async&&bD.timeout>0){bE=setTimeout(function(){bJ.abort("timeout")},bD.timeout)}try{bA=1;bL.send(bH,bF)}catch(bM){if(bA<2){bF(-1,bM)}else{throw bM}}}return bJ},param:function(e,bw){var bv=[],by=function(bz,bA){bA=b.isFunction(bA)?bA():bA;bv[bv.length]=encodeURIComponent(bz)+"="+encodeURIComponent(bA)};if(bw===L){bw=b.ajaxSettings.traditional}if(b.isArray(e)||(e.jquery&&!b.isPlainObject(e))){b.each(e,function(){by(this.name,this.value)})}else{for(var bx in e){v(bx,e[bx],bw,by)}}return bv.join("&").replace(k,"+")}});function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(bv||ap.test(bw)){bx(bw,bz)}else{v(bw+"["+(typeof bz==="object"||b.isArray(bz)?bA:"")+"]",bz,bv,bx)}})}else{if(!bv&&by!=null&&typeof by==="object"){for(var e in by){v(bw+"["+e+"]",by[e],bv,bx)}}else{bx(bw,by)}}}b.extend({active:0,lastModified:{},etag:{}});function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseFields,by,bA,bx,e;for(bA in bw){if(bA in bz){bC[bw[bA]]=bz[bA]}}while(bB[0]==="*"){bB.shift();if(by===L){by=bD.mimeType||bC.getResponseHeader("content-type")}}if(by){for(bA in bv){if(bv[bA]&&bv[bA].test(by)){bB.unshift(bA);break}}}if(bB[0] in bz){bx=bB[0]}else{for(bA in bz){if(!bB[0]||bD.converters[bA+" "+bB[0]]){bx=bA;break}if(!e){e=bA}}bx=bx||e}if(bx){if(bx!==bB[0]){bB.unshift(bx)}return bz[bx]}}function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var bD=bH.dataTypes,bG={},bA,bE,bw=bD.length,bB,bC=bD[0],bx,by,bF,bv,e;for(bA=1;bA=bw.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();bw.animatedProperties[this.prop]=true;for(bA in bw.animatedProperties){if(bw.animatedProperties[bA]!==true){e=false}}if(e){if(bw.overflow!=null&&!b.support.shrinkWrapBlocks){b.each(["","X","Y"],function(bC,bD){bz.style["overflow"+bD]=bw.overflow[bC]})}if(bw.hide){b(bz).hide()}if(bw.hide||bw.show){for(bA in bw.animatedProperties){b.style(bz,bA,bw.orig[bA]);b.removeData(bz,"fxshow"+bA,true);b.removeData(bz,"toggle"+bA,true)}}bv=bw.complete;if(bv){bw.complete=false;bv.call(bz)}}return false}else{if(bw.duration==Infinity){this.now=bx}else{bB=bx-this.startTime;this.state=bB/bw.duration;this.pos=b.easing[bw.animatedProperties[this.prop]](this.state,bB,0,1,bw.duration);this.now=this.start+((this.end-this.start)*this.pos)}this.update()}return true}};b.extend(b.fx,{tick:function(){var bw,bv=b.timers,e=0;for(;e").appendTo(e),bw=bv.css("display");bv.remove();if(bw==="none"||bw===""){if(!a8){a8=av.createElement("iframe");a8.frameBorder=a8.width=a8.height=0}e.appendChild(a8);if(!m||!a8.createElement){m=(a8.contentWindow||a8.contentDocument).document;m.write((av.compatMode==="CSS1Compat"?"":"")+"");m.close()}bv=m.createElement(bx);m.body.appendChild(bv);bw=b.css(bv,"display");e.removeChild(a8)}Q[bx]=bw}return Q[bx]}var V=/^t(?:able|d|h)$/i,ad=/^(?:body|html)$/i;if("getBoundingClientRect" in av.documentElement){b.fn.offset=function(bI){var by=this[0],bB;if(bI){return this.each(function(e){b.offset.setOffset(this,bI,e)})}if(!by||!by.ownerDocument){return null}if(by===by.ownerDocument.body){return b.offset.bodyOffset(by)}try{bB=by.getBoundingClientRect()}catch(bF){}var bH=by.ownerDocument,bw=bH.documentElement;if(!bB||!b.contains(bw,by)){return bB?{top:bB.top,left:bB.left}:{top:0,left:0}}var bC=bH.body,bD=aK(bH),bA=bw.clientTop||bC.clientTop||0,bE=bw.clientLeft||bC.clientLeft||0,bv=bD.pageYOffset||b.support.boxModel&&bw.scrollTop||bC.scrollTop,bz=bD.pageXOffset||b.support.boxModel&&bw.scrollLeft||bC.scrollLeft,bG=bB.top+bv-bA,bx=bB.left+bz-bE;return{top:bG,left:bx}}}else{b.fn.offset=function(bF){var bz=this[0];if(bF){return this.each(function(bG){b.offset.setOffset(this,bF,bG)})}if(!bz||!bz.ownerDocument){return null}if(bz===bz.ownerDocument.body){return b.offset.bodyOffset(bz)}var bC,bw=bz.offsetParent,bv=bz,bE=bz.ownerDocument,bx=bE.documentElement,bA=bE.body,bB=bE.defaultView,e=bB?bB.getComputedStyle(bz,null):bz.currentStyle,bD=bz.offsetTop,by=bz.offsetLeft;while((bz=bz.parentNode)&&bz!==bA&&bz!==bx){if(b.support.fixedPosition&&e.position==="fixed"){break}bC=bB?bB.getComputedStyle(bz,null):bz.currentStyle;bD-=bz.scrollTop;by-=bz.scrollLeft;if(bz===bw){bD+=bz.offsetTop;by+=bz.offsetLeft;if(b.support.doesNotAddBorder&&!(b.support.doesAddBorderForTableAndCells&&V.test(bz.nodeName))){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}bv=bw;bw=bz.offsetParent}if(b.support.subtractsBorderForOverflowNotVisible&&bC.overflow!=="visible"){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}e=bC}if(e.position==="relative"||e.position==="static"){bD+=bA.offsetTop;by+=bA.offsetLeft}if(b.support.fixedPosition&&e.position==="fixed"){bD+=Math.max(bx.scrollTop,bA.scrollTop);by+=Math.max(bx.scrollLeft,bA.scrollLeft)}return{top:bD,left:by}}}b.offset={bodyOffset:function(e){var bw=e.offsetTop,bv=e.offsetLeft;if(b.support.doesNotIncludeMarginInBodyOffset){bw+=parseFloat(b.css(e,"marginTop"))||0;bv+=parseFloat(b.css(e,"marginLeft"))||0}return{top:bw,left:bv}},setOffset:function(bx,bG,bA){var bB=b.css(bx,"position");if(bB==="static"){bx.style.position="relative"}var bz=b(bx),bv=bz.offset(),e=b.css(bx,"top"),bE=b.css(bx,"left"),bF=(bB==="absolute"||bB==="fixed")&&b.inArray("auto",[e,bE])>-1,bD={},bC={},bw,by;if(bF){bC=bz.position();bw=bC.top;by=bC.left}else{bw=parseFloat(e)||0;by=parseFloat(bE)||0}if(b.isFunction(bG)){bG=bG.call(bx,bA,bv)}if(bG.top!=null){bD.top=(bG.top-bv.top)+bw}if(bG.left!=null){bD.left=(bG.left-bv.left)+by}if("using" in bG){bG.using.call(bx,bD)}else{bz.css(bD)}}};b.fn.extend({position:function(){if(!this[0]){return null}var bw=this[0],bv=this.offsetParent(),bx=this.offset(),e=ad.test(bv[0].nodeName)?{top:0,left:0}:bv.offset();bx.top-=parseFloat(b.css(bw,"marginTop"))||0;bx.left-=parseFloat(b.css(bw,"marginLeft"))||0;e.top+=parseFloat(b.css(bv[0],"borderTopWidth"))||0;e.left+=parseFloat(b.css(bv[0],"borderLeftWidth"))||0;return{top:bx.top-e.top,left:bx.left-e.left}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||av.body;while(e&&(!ad.test(e.nodeName)&&b.css(e,"position")==="static")){e=e.offsetParent}return e})}});b.each(["Left","Top"],function(bv,e){var bw="scroll"+e;b.fn[bw]=function(bz){var bx,by;if(bz===L){bx=this[0];if(!bx){return null}by=aK(bx);return by?("pageXOffset" in by)?by[bv?"pageYOffset":"pageXOffset"]:b.support.boxModel&&by.document.documentElement[bw]||by.document.body[bw]:bx[bw]}return this.each(function(){by=aK(this);if(by){by.scrollTo(!bv?bz:b(by).scrollLeft(),bv?bz:b(by).scrollTop())}else{this[bw]=bz}})}});function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.parentWindow:false}b.each(["Height","Width"],function(bv,e){var bw=e.toLowerCase();b.fn["inner"+e]=function(){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,"padding")):this[bw]():null};b.fn["outer"+e]=function(by){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,by?"margin":"border")):this[bw]():null};b.fn[bw]=function(bz){var bA=this[0];if(!bA){return bz==null?null:this}if(b.isFunction(bz)){return this.each(function(bE){var bD=b(this);bD[bw](bz.call(this,bE,bD[bw]()))})}if(b.isWindow(bA)){var bB=bA.document.documentElement["client"+e],bx=bA.document.body;return bA.document.compatMode==="CSS1Compat"&&bB||bx&&bx["client"+e]||bB}else{if(bA.nodeType===9){return Math.max(bA.documentElement["client"+e],bA.body["scroll"+e],bA.documentElement["scroll"+e],bA.body["offset"+e],bA.documentElement["offset"+e])}else{if(bz===L){var bC=b.css(bA,bw),by=parseFloat(bC);return b.isNumeric(by)?by:bC}else{return this.css(bw,typeof bz==="string"?bz:bz+"px")}}}}});bb.jQuery=bb.$=b;if(typeof define==="function"&&define.amd&&define.amd.jQuery){define("jquery",[],function(){return b})}})(window);/*! + * jQuery UI 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI + */ +(function(a,d){a.ui=a.ui||{};if(a.ui.version){return}a.extend(a.ui,{version:"1.8.18",keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91}});a.fn.extend({propAttr:a.fn.prop||a.fn.attr,_focus:a.fn.focus,focus:function(e,f){return typeof e==="number"?this.each(function(){var g=this;setTimeout(function(){a(g).focus();if(f){f.call(g)}},e)}):this._focus.apply(this,arguments)},scrollParent:function(){var e;if((a.browser.msie&&(/(static|relative)/).test(this.css("position")))||(/absolute/).test(this.css("position"))){e=this.parents().filter(function(){return(/(relative|absolute|fixed)/).test(a.curCSS(this,"position",1))&&(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}else{e=this.parents().filter(function(){return(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}return(/fixed/).test(this.css("position"))||!e.length?a(document):e},zIndex:function(h){if(h!==d){return this.css("zIndex",h)}if(this.length){var f=a(this[0]),e,g;while(f.length&&f[0]!==document){e=f.css("position");if(e==="absolute"||e==="relative"||e==="fixed"){g=parseInt(f.css("zIndex"),10);if(!isNaN(g)&&g!==0){return g}}f=f.parent()}}return 0},disableSelection:function(){return this.bind((a.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}});a.each(["Width","Height"],function(g,e){var f=e==="Width"?["Left","Right"]:["Top","Bottom"],h=e.toLowerCase(),k={innerWidth:a.fn.innerWidth,innerHeight:a.fn.innerHeight,outerWidth:a.fn.outerWidth,outerHeight:a.fn.outerHeight};function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"padding"+this,true))||0;if(i){l-=parseFloat(a.curCSS(m,"border"+this+"Width",true))||0}if(n){l-=parseFloat(a.curCSS(m,"margin"+this,true))||0}});return l}a.fn["inner"+e]=function(i){if(i===d){return k["inner"+e].call(this)}return this.each(function(){a(this).css(h,j(this,i)+"px")})};a.fn["outer"+e]=function(i,l){if(typeof i!=="number"){return k["outer"+e].call(this,i)}return this.each(function(){a(this).css(h,j(this,i,true,l)+"px")})}});function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.parentNode,h=i.name,f;if(!g.href||!h||i.nodeName.toLowerCase()!=="map"){return false}f=a("img[usemap=#"+h+"]")[0];return !!f&&b(f)}return(/input|select|textarea|button|object/.test(j)?!g.disabled:"a"==j?g.href||e:e)&&b(g)}function b(e){return !a(e).parents().andSelf().filter(function(){return a.curCSS(this,"visibility")==="hidden"||a.expr.filters.hidden(this)}).length}a.extend(a.expr[":"],{data:function(g,f,e){return !!a.data(g,e[3])},focusable:function(e){return c(e,!isNaN(a.attr(e,"tabindex")))},tabbable:function(g){var e=a.attr(g,"tabindex"),f=isNaN(e);return(f||e>=0)&&c(g,!f)}});a(function(){var e=document.body,f=e.appendChild(f=document.createElement("div"));f.offsetHeight;a.extend(f.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0});a.support.minHeight=f.offsetHeight===100;a.support.selectstart="onselectstart" in f;e.removeChild(f).style.display="none"});a.extend(a.ui,{plugin:{add:function(f,g,j){var h=a.ui[f].prototype;for(var e in j){h.plugins[e]=h.plugins[e]||[];h.plugins[e].push([g,j[e]])}},call:function(e,g,f){var j=e.plugins[g];if(!j||!e.element[0].parentNode){return}for(var h=0;h0){return true}h[e]=1;g=(h[e]>0);h[e]=0;return g},isOverAxis:function(f,e,g){return(f>e)&&(f<(e+g))},isOver:function(j,f,i,h,e,g){return a.ui.isOverAxis(j,i,e)&&a.ui.isOverAxis(f,h,g)}})})(jQuery);/*! + * jQuery UI Widget 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI/Widget + */ +(function(b,d){if(b.cleanData){var c=b.cleanData;b.cleanData=function(f){for(var g=0,h;(h=f[g])!=null;g++){try{b(h).triggerHandler("remove")}catch(j){}}c(f)}}else{var a=b.fn.remove;b.fn.remove=function(e,f){return this.each(function(){if(!f){if(!e||b.filter(e,[this]).length){b("*",this).add([this]).each(function(){try{b(this).triggerHandler("remove")}catch(g){}})}}return a.call(b(this),e,f)})}}b.widget=function(f,h,e){var g=f.split(".")[0],j;f=f.split(".")[1];j=g+"-"+f;if(!e){e=h;h=b.Widget}b.expr[":"][j]=function(k){return !!b.data(k,f)};b[g]=b[g]||{};b[g][f]=function(k,l){if(arguments.length){this._createWidget(k,l)}};var i=new h();i.options=b.extend(true,{},i.options);b[g][f].prototype=b.extend(true,i,{namespace:g,widgetName:f,widgetEventPrefix:b[g][f].prototype.widgetEventPrefix||f,widgetBaseClass:j},e);b.widget.bridge(f,b[g][f])};b.widget.bridge=function(f,e){b.fn[f]=function(i){var g=typeof i==="string",h=Array.prototype.slice.call(arguments,1),j=this;i=!g&&h.length?b.extend.apply(null,[true,i].concat(h)):i;if(g&&i.charAt(0)==="_"){return j}if(g){this.each(function(){var k=b.data(this,f),l=k&&b.isFunction(k[i])?k[i].apply(k,h):k;if(l!==k&&l!==d){j=l;return false}})}else{this.each(function(){var k=b.data(this,f);if(k){k.option(i||{})._init()}else{b.data(this,f,new e(i,this))}})}return j}};b.Widget=function(e,f){if(arguments.length){this._createWidget(e,f)}};b.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",options:{disabled:false},_createWidget:function(f,g){b.data(g,this.widgetName,this);this.element=b(g);this.options=b.extend(true,{},this.options,this._getCreateOptions(),f);var e=this;this.element.bind("remove."+this.widgetName,function(){e.destroy()});this._create();this._trigger("create");this._init()},_getCreateOptions:function(){return b.metadata&&b.metadata.get(this.element[0])[this.widgetName]},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(f,g){var e=f;if(arguments.length===0){return b.extend({},this.options)}if(typeof f==="string"){if(g===d){return this.options[f]}e={};e[f]=g}this._setOptions(e);return this},_setOptions:function(f){var e=this;b.each(f,function(g,h){e._setOption(g,h)});return this},_setOption:function(e,f){this.options[e]=f;if(e==="disabled"){this.widget()[f?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",f)}return this},enable:function(){return this._setOption("disabled",false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(e,f,g){var j,i,h=this.options[e];g=g||{};f=b.Event(f);f.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase();f.target=this.element[0];i=f.originalEvent;if(i){for(j in i){if(!(j in f)){f[j]=i[j]}}}this.element.trigger(f,g);return !(b.isFunction(h)&&h.call(this.element[0],f,g)===false||f.isDefaultPrevented())}}})(jQuery);/*! + * jQuery UI Mouse 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI/Mouse + * + * Depends: + * jquery.ui.widget.js + */ +(function(b,c){var a=false;b(document).mouseup(function(d){a=false});b.widget("ui.mouse",{options:{cancel:":input,option",distance:1,delay:0},_mouseInit:function(){var d=this;this.element.bind("mousedown."+this.widgetName,function(e){return d._mouseDown(e)}).bind("click."+this.widgetName,function(e){if(true===b.data(e.target,d.widgetName+".preventClickEvent")){b.removeData(e.target,d.widgetName+".preventClickEvent");e.stopImmediatePropagation();return false}});this.started=false},_mouseDestroy:function(){this.element.unbind("."+this.widgetName)},_mouseDown:function(f){if(a){return}(this._mouseStarted&&this._mouseUp(f));this._mouseDownEvent=f;var e=this,g=(f.which==1),d=(typeof this.options.cancel=="string"&&f.target.nodeName?b(f.target).closest(this.options.cancel).length:false);if(!g||d||!this._mouseCapture(f)){return true}this.mouseDelayMet=!this.options.delay;if(!this.mouseDelayMet){this._mouseDelayTimer=setTimeout(function(){e.mouseDelayMet=true},this.options.delay)}if(this._mouseDistanceMet(f)&&this._mouseDelayMet(f)){this._mouseStarted=(this._mouseStart(f)!==false);if(!this._mouseStarted){f.preventDefault();return true}}if(true===b.data(f.target,this.widgetName+".preventClickEvent")){b.removeData(f.target,this.widgetName+".preventClickEvent")}this._mouseMoveDelegate=function(h){return e._mouseMove(h)};this._mouseUpDelegate=function(h){return e._mouseUp(h)};b(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate);f.preventDefault();a=true;return true},_mouseMove:function(d){if(b.browser.msie&&!(document.documentMode>=9)&&!d.button){return this._mouseUp(d)}if(this._mouseStarted){this._mouseDrag(d);return d.preventDefault()}if(this._mouseDistanceMet(d)&&this._mouseDelayMet(d)){this._mouseStarted=(this._mouseStart(this._mouseDownEvent,d)!==false);(this._mouseStarted?this._mouseDrag(d):this._mouseUp(d))}return !this._mouseStarted},_mouseUp:function(d){b(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate);if(this._mouseStarted){this._mouseStarted=false;if(d.target==this._mouseDownEvent.target){b.data(d.target,this.widgetName+".preventClickEvent",true)}this._mouseStop(d)}return false},_mouseDistanceMet:function(d){return(Math.max(Math.abs(this._mouseDownEvent.pageX-d.pageX),Math.abs(this._mouseDownEvent.pageY-d.pageY))>=this.options.distance)},_mouseDelayMet:function(d){return this.mouseDelayMet},_mouseStart:function(d){},_mouseDrag:function(d){},_mouseStop:function(d){},_mouseCapture:function(d){return true}})})(jQuery);(function(c,d){c.widget("ui.resizable",c.ui.mouse,{widgetEventPrefix:"resize",options:{alsoResize:false,animate:false,animateDuration:"slow",animateEasing:"swing",aspectRatio:false,autoHide:false,containment:false,ghost:false,grid:false,handles:"e,s,se",helper:false,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1000},_create:function(){var f=this,k=this.options;this.element.addClass("ui-resizable");c.extend(this,{_aspectRatio:!!(k.aspectRatio),aspectRatio:k.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:k.helper||k.ghost||k.animate?k.helper||"ui-resizable-helper":null});if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)){this.element.wrap(c('
').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")}));this.element=this.element.parent().data("resizable",this.element.data("resizable"));this.elementIsWrapper=true;this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")});this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0});this.originalResizeStyle=this.originalElement.css("resize");this.originalElement.css("resize","none");this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"}));this.originalElement.css({margin:this.originalElement.css("margin")});this._proportionallyResize()}this.handles=k.handles||(!c(".ui-resizable-handle",this.element).length?"e,s,se":{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"});if(this.handles.constructor==String){if(this.handles=="all"){this.handles="n,e,s,w,se,sw,ne,nw"}var l=this.handles.split(",");this.handles={};for(var g=0;g
');if(/sw|se|ne|nw/.test(j)){h.css({zIndex:++k.zIndex})}if("se"==j){h.addClass("ui-icon ui-icon-gripsmall-diagonal-se")}this.handles[j]=".ui-resizable-"+j;this.element.append(h)}}this._renderAxis=function(q){q=q||this.element;for(var n in this.handles){if(this.handles[n].constructor==String){this.handles[n]=c(this.handles[n],this.element).show()}if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var o=c(this.handles[n],this.element),p=0;p=/sw|ne|nw|se|n|s/.test(n)?o.outerHeight():o.outerWidth();var m=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");q.css(m,p);this._proportionallyResize()}if(!c(this.handles[n]).length){continue}}};this._renderAxis(this.element);this._handles=c(".ui-resizable-handle",this.element).disableSelection();this._handles.mouseover(function(){if(!f.resizing){if(this.className){var i=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)}f.axis=i&&i[1]?i[1]:"se"}});if(k.autoHide){this._handles.hide();c(this.element).addClass("ui-resizable-autohide").hover(function(){if(k.disabled){return}c(this).removeClass("ui-resizable-autohide");f._handles.show()},function(){if(k.disabled){return}if(!f.resizing){c(this).addClass("ui-resizable-autohide");f._handles.hide()}})}this._mouseInit()},destroy:function(){this._mouseDestroy();var e=function(g){c(g).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){e(this.element);var f=this.element;f.after(this.originalElement.css({position:f.css("position"),width:f.outerWidth(),height:f.outerHeight(),top:f.css("top"),left:f.css("left")})).remove()}this.originalElement.css("resize",this.originalResizeStyle);e(this.originalElement);return this},_mouseCapture:function(f){var g=false;for(var e in this.handles){if(c(this.handles[e])[0]==f.target){g=true}}return !this.options.disabled&&g},_mouseStart:function(g){var j=this.options,f=this.element.position(),e=this.element;this.resizing=true;this.documentScroll={top:c(document).scrollTop(),left:c(document).scrollLeft()};if(e.is(".ui-draggable")||(/absolute/).test(e.css("position"))){e.css({position:"absolute",top:f.top,left:f.left})}this._renderProxy();var k=b(this.helper.css("left")),h=b(this.helper.css("top"));if(j.containment){k+=c(j.containment).scrollLeft()||0;h+=c(j.containment).scrollTop()||0}this.offset=this.helper.offset();this.position={left:k,top:h};this.size=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalSize=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalPosition={left:k,top:h};this.sizeDiff={width:e.outerWidth()-e.width(),height:e.outerHeight()-e.height()};this.originalMousePosition={left:g.pageX,top:g.pageY};this.aspectRatio=(typeof j.aspectRatio=="number")?j.aspectRatio:((this.originalSize.width/this.originalSize.height)||1);var i=c(".ui-resizable-"+this.axis).css("cursor");c("body").css("cursor",i=="auto"?this.axis+"-resize":i);e.addClass("ui-resizable-resizing");this._propagate("start",g);return true},_mouseDrag:function(e){var h=this.helper,g=this.options,m={},q=this,j=this.originalMousePosition,n=this.axis;var r=(e.pageX-j.left)||0,p=(e.pageY-j.top)||0;var i=this._change[n];if(!i){return false}var l=i.apply(this,[e,r,p]),k=c.browser.msie&&c.browser.version<7,f=this.sizeDiff;this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey){l=this._updateRatio(l,e)}l=this._respectSize(l,e);this._propagate("resize",e);h.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"});if(!this._helper&&this._proportionallyResizeElements.length){this._proportionallyResize()}this._updateCache(l);this._trigger("resize",e,this.ui());return false},_mouseStop:function(h){this.resizing=false;var i=this.options,m=this;if(this._helper){var g=this._proportionallyResizeElements,e=g.length&&(/textarea/i).test(g[0].nodeName),f=e&&c.ui.hasScroll(g[0],"left")?0:m.sizeDiff.height,k=e?0:m.sizeDiff.width;var n={width:(m.helper.width()-k),height:(m.helper.height()-f)},j=(parseInt(m.element.css("left"),10)+(m.position.left-m.originalPosition.left))||null,l=(parseInt(m.element.css("top"),10)+(m.position.top-m.originalPosition.top))||null;if(!i.animate){this.element.css(c.extend(n,{top:l,left:j}))}m.helper.height(m.size.height);m.helper.width(m.size.width);if(this._helper&&!i.animate){this._proportionallyResize()}}c("body").css("cursor","auto");this.element.removeClass("ui-resizable-resizing");this._propagate("stop",h);if(this._helper){this.helper.remove()}return false},_updateVirtualBoundaries:function(g){var j=this.options,i,h,f,k,e;e={minWidth:a(j.minWidth)?j.minWidth:0,maxWidth:a(j.maxWidth)?j.maxWidth:Infinity,minHeight:a(j.minHeight)?j.minHeight:0,maxHeight:a(j.maxHeight)?j.maxHeight:Infinity};if(this._aspectRatio||g){i=e.minHeight*this.aspectRatio;f=e.minWidth/this.aspectRatio;h=e.maxHeight*this.aspectRatio;k=e.maxWidth/this.aspectRatio;if(i>e.minWidth){e.minWidth=i}if(f>e.minHeight){e.minHeight=f}if(hl.width),s=a(l.height)&&i.minHeight&&(i.minHeight>l.height);if(h){l.width=i.minWidth}if(s){l.height=i.minHeight}if(t){l.width=i.maxWidth}if(m){l.height=i.maxHeight}var f=this.originalPosition.left+this.originalSize.width,p=this.position.top+this.size.height;var k=/sw|nw|w/.test(q),e=/nw|ne|n/.test(q);if(h&&k){l.left=f-i.minWidth}if(t&&k){l.left=f-i.maxWidth}if(s&&e){l.top=p-i.minHeight}if(m&&e){l.top=p-i.maxHeight}var n=!l.width&&!l.height;if(n&&!l.left&&l.top){l.top=null}else{if(n&&!l.top&&l.left){l.left=null}}return l},_proportionallyResize:function(){var k=this.options;if(!this._proportionallyResizeElements.length){return}var g=this.helper||this.element;for(var f=0;f');var e=c.browser.msie&&c.browser.version<7,g=(e?1:0),h=(e?2:-1);this.helper.addClass(this._helper).css({width:this.element.outerWidth()+h,height:this.element.outerHeight()+h,position:"absolute",left:this.elementOffset.left-g+"px",top:this.elementOffset.top-g+"px",zIndex:++i.zIndex});this.helper.appendTo("body").disableSelection()}else{this.helper=this.element}},_change:{e:function(g,f,e){return{width:this.originalSize.width+f}},w:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{left:i.left+f,width:g.width-f}},n:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{top:i.top+e,height:g.height-e}},s:function(g,f,e){return{height:this.originalSize.height+e}},se:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},sw:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[g,f,e]))},ne:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},nw:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[g,f,e]))}},_propagate:function(f,e){c.ui.plugin.call(this,f,[e,this.ui()]);(f!="resize"&&this._trigger(f,e,this.ui()))},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}});c.extend(c.ui.resizable,{version:"1.8.18"});c.ui.plugin.add("resizable","alsoResize",{start:function(f,g){var e=c(this).data("resizable"),i=e.options;var h=function(j){c(j).each(function(){var k=c(this);k.data("resizable-alsoresize",{width:parseInt(k.width(),10),height:parseInt(k.height(),10),left:parseInt(k.css("left"),10),top:parseInt(k.css("top"),10)})})};if(typeof(i.alsoResize)=="object"&&!i.alsoResize.parentNode){if(i.alsoResize.length){i.alsoResize=i.alsoResize[0];h(i.alsoResize)}else{c.each(i.alsoResize,function(j){h(j)})}}else{h(i.alsoResize)}},resize:function(g,i){var f=c(this).data("resizable"),j=f.options,h=f.originalSize,l=f.originalPosition;var k={height:(f.size.height-h.height)||0,width:(f.size.width-h.width)||0,top:(f.position.top-l.top)||0,left:(f.position.left-l.left)||0},e=function(m,n){c(m).each(function(){var q=c(this),r=c(this).data("resizable-alsoresize"),p={},o=n&&n.length?n:q.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];c.each(o,function(s,u){var t=(r[u]||0)+(k[u]||0);if(t&&t>=0){p[u]=t||null}});q.css(p)})};if(typeof(j.alsoResize)=="object"&&!j.alsoResize.nodeType){c.each(j.alsoResize,function(m,n){e(m,n)})}else{e(j.alsoResize)}},stop:function(e,f){c(this).removeData("resizable-alsoresize")}});c.ui.plugin.add("resizable","animate",{stop:function(i,n){var p=c(this).data("resizable"),j=p.options;var h=p._proportionallyResizeElements,e=h.length&&(/textarea/i).test(h[0].nodeName),f=e&&c.ui.hasScroll(h[0],"left")?0:p.sizeDiff.height,l=e?0:p.sizeDiff.width;var g={width:(p.size.width-l),height:(p.size.height-f)},k=(parseInt(p.element.css("left"),10)+(p.position.left-p.originalPosition.left))||null,m=(parseInt(p.element.css("top"),10)+(p.position.top-p.originalPosition.top))||null;p.element.animate(c.extend(g,m&&k?{top:m,left:k}:{}),{duration:j.animateDuration,easing:j.animateEasing,step:function(){var o={width:parseInt(p.element.css("width"),10),height:parseInt(p.element.css("height"),10),top:parseInt(p.element.css("top"),10),left:parseInt(p.element.css("left"),10)};if(h&&h.length){c(h[0]).css({width:o.width,height:o.height})}p._updateCache(o);p._propagate("resize",i)}})}});c.ui.plugin.add("resizable","containment",{start:function(f,r){var t=c(this).data("resizable"),j=t.options,l=t.element;var g=j.containment,k=(g instanceof c)?g.get(0):(/parent/.test(g))?l.parent().get(0):g;if(!k){return}t.containerElement=c(k);if(/document/.test(g)||g==document){t.containerOffset={left:0,top:0};t.containerPosition={left:0,top:0};t.parentData={element:c(document),left:0,top:0,width:c(document).width(),height:c(document).height()||document.body.parentNode.scrollHeight}}else{var n=c(k),i=[];c(["Top","Right","Left","Bottom"]).each(function(p,o){i[p]=b(n.css("padding"+o))});t.containerOffset=n.offset();t.containerPosition=n.position();t.containerSize={height:(n.innerHeight()-i[3]),width:(n.innerWidth()-i[1])};var q=t.containerOffset,e=t.containerSize.height,m=t.containerSize.width,h=(c.ui.hasScroll(k,"left")?k.scrollWidth:m),s=(c.ui.hasScroll(k)?k.scrollHeight:e);t.parentData={element:k,left:q.left,top:q.top,width:h,height:s}}},resize:function(g,q){var t=c(this).data("resizable"),i=t.options,f=t.containerSize,p=t.containerOffset,m=t.size,n=t.position,r=t._aspectRatio||g.shiftKey,e={top:0,left:0},h=t.containerElement;if(h[0]!=document&&(/static/).test(h.css("position"))){e=p}if(n.left<(t._helper?p.left:0)){t.size.width=t.size.width+(t._helper?(t.position.left-p.left):(t.position.left-e.left));if(r){t.size.height=t.size.width/i.aspectRatio}t.position.left=i.helper?p.left:0}if(n.top<(t._helper?p.top:0)){t.size.height=t.size.height+(t._helper?(t.position.top-p.top):t.position.top);if(r){t.size.width=t.size.height*i.aspectRatio}t.position.top=t._helper?p.top:0}t.offset.left=t.parentData.left+t.position.left;t.offset.top=t.parentData.top+t.position.top;var l=Math.abs((t._helper?t.offset.left-e.left:(t.offset.left-e.left))+t.sizeDiff.width),s=Math.abs((t._helper?t.offset.top-e.top:(t.offset.top-p.top))+t.sizeDiff.height);var k=t.containerElement.get(0)==t.element.parent().get(0),j=/relative|absolute/.test(t.containerElement.css("position"));if(k&&j){l-=t.parentData.left}if(l+t.size.width>=t.parentData.width){t.size.width=t.parentData.width-l;if(r){t.size.height=t.size.width/t.aspectRatio}}if(s+t.size.height>=t.parentData.height){t.size.height=t.parentData.height-s;if(r){t.size.width=t.size.height*t.aspectRatio}}},stop:function(f,n){var q=c(this).data("resizable"),g=q.options,l=q.position,m=q.containerOffset,e=q.containerPosition,i=q.containerElement;var j=c(q.helper),r=j.offset(),p=j.outerWidth()-q.sizeDiff.width,k=j.outerHeight()-q.sizeDiff.height;if(q._helper&&!g.animate&&(/relative/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}if(q._helper&&!g.animate&&(/static/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}}});c.ui.plugin.add("resizable","ghost",{start:function(g,h){var e=c(this).data("resizable"),i=e.options,f=e.size;e.ghost=e.originalElement.clone();e.ghost.css({opacity:0.25,display:"block",position:"relative",height:f.height,width:f.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:"");e.ghost.appendTo(e.helper)},resize:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost){e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})}},stop:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost&&e.helper){e.helper.get(0).removeChild(e.ghost.get(0))}}});c.ui.plugin.add("resizable","grid",{resize:function(e,m){var p=c(this).data("resizable"),h=p.options,k=p.size,i=p.originalSize,j=p.originalPosition,n=p.axis,l=h._aspectRatio||e.shiftKey;h.grid=typeof h.grid=="number"?[h.grid,h.grid]:h.grid;var g=Math.round((k.width-i.width)/(h.grid[0]||1))*(h.grid[0]||1),f=Math.round((k.height-i.height)/(h.grid[1]||1))*(h.grid[1]||1);if(/^(se|s|e)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f}else{if(/^(ne)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f}else{if(/^(sw)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.left=j.left-g}else{p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f;p.position.left=j.left-g}}}}});var b=function(e){return parseInt(e,10)||0};var a=function(e){return !isNaN(parseInt(e,10))}})(jQuery);/*! + * jQuery hashchange event - v1.3 - 7/21/2010 + * http://benalman.com/projects/jquery-hashchange-plugin/ + * + * Copyright (c) 2010 "Cowboy" Ben Alman + * Dual licensed under the MIT and GPL licenses. + * http://benalman.com/about/license/ + */ +(function($,e,b){var c="hashchange",h=document,f,g=$.event.special,i=h.documentMode,d="on"+c in e&&(i===b||i>7);function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}$.fn[c]=function(j){return j?this.bind(c,j):this.trigger(c)};$.fn[c].delay=50;g[c]=$.extend(g[c],{setup:function(){if(d){return false}$(f.start)},teardown:function(){if(d){return false}$(f.stop)}});f=(function(){var j={},p,m=a(),k=function(q){return q},l=k,o=k;j.start=function(){p||n()};j.stop=function(){p&&clearTimeout(p);p=b};function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if(q!==m){location.href=location.href.replace(/#.*/,"")+q}}p=setTimeout(n,$.fn[c].delay)}$.browser.msie&&!d&&(function(){var q,r;j.start=function(){if(!q){r=$.fn[c].src;r=r&&r+a();q=$(' + + + + +
+
+Data Structures | +Macros | +Typedefs | +Functions
+
+
list.h File Reference
+
+
+ +

Doubly linked list implementation. +More...

+
#include "ucx.h"
+#include "allocator.h"
+
+

Go to the source code of this file.

+
+ + + + +

+Data Structures

struct  UcxList
 UCX list structure. More...
 
+ + + + +

+Macros

#define UCX_FOREACH(elem, list)   for (UcxList* elem = (UcxList*) list ; elem != NULL ; elem = elem->next)
 Loop statement for UCX lists. More...
 
+ + + + +

+Typedefs

typedef struct UcxList UcxList
 UCX list type. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

UcxList * ucx_list_clone (const UcxList *list, copy_func cpyfnc, void *data)
 Creates an element-wise copy of a list. More...
 
UcxList * ucx_list_clone_a (UcxAllocator *allocator, const UcxList *list, copy_func cpyfnc, void *data)
 Creates an element-wise copy of a list using a UcxAllocator. More...
 
int ucx_list_equals (const UcxList *list1, const UcxList *list2, cmp_func cmpfnc, void *data)
 Compares two UCX lists element-wise by using a compare function. More...
 
void ucx_list_free (UcxList *list)
 Destroys the entire list. More...
 
void ucx_list_free_a (UcxAllocator *allocator, UcxList *list)
 Destroys the entire list using a UcxAllocator. More...
 
void ucx_list_free_content (UcxList *list, ucx_destructor destr)
 Destroys the contents of the specified list by calling the specified destructor on each of them. More...
 
UcxList * ucx_list_append (UcxList *list, void *data)
 Inserts an element at the end of the list. More...
 
UcxList * ucx_list_append_a (UcxAllocator *allocator, UcxList *list, void *data)
 Inserts an element at the end of the list using a UcxAllocator. More...
 
UcxList * ucx_list_prepend (UcxList *list, void *data)
 Inserts an element at the beginning of the list. More...
 
UcxList * ucx_list_prepend_a (UcxAllocator *allocator, UcxList *list, void *data)
 Inserts an element at the beginning of the list using a UcxAllocator. More...
 
UcxList * ucx_list_concat (UcxList *list1, UcxList *list2)
 Concatenates two lists. More...
 
UcxList * ucx_list_first (const UcxList *elem)
 Returns the first element of a list. More...
 
UcxList * ucx_list_last (const UcxList *elem)
 Returns the last element of a list. More...
 
UcxList * ucx_list_get (const UcxList *list, size_t index)
 Returns the list element at the specified index. More...
 
ssize_t ucx_list_indexof (const UcxList *list, const UcxList *elem)
 Returns the index of an element. More...
 
size_t ucx_list_size (const UcxList *list)
 Returns the element count of the list. More...
 
ssize_t ucx_list_find (const UcxList *list, void *elem, cmp_func cmpfnc, void *data)
 Returns the index of an element containing the specified data. More...
 
int ucx_list_contains (const UcxList *list, void *elem, cmp_func cmpfnc, void *data)
 Checks, if a list contains a specific element. More...
 
UcxList * ucx_list_sort (UcxList *list, cmp_func cmpfnc, void *data)
 Sorts a UcxList with natural merge sort. More...
 
UcxList * ucx_list_remove (UcxList *list, UcxList *element)
 Removes an element from the list. More...
 
UcxList * ucx_list_remove_a (UcxAllocator *allocator, UcxList *list, UcxList *element)
 Removes an element from the list using a UcxAllocator. More...
 
UcxList * ucx_list_union (const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the union of two lists. More...
 
UcxList * ucx_list_union_a (UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the union of two lists. More...
 
UcxList * ucx_list_intersection (const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the intersection of two lists. More...
 
UcxList * ucx_list_intersection_a (UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the intersection of two lists. More...
 
UcxList * ucx_list_difference (const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the difference of two lists. More...
 
UcxList * ucx_list_difference_a (UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
 Returns the difference of two lists. More...
 
+

Detailed Description

+

Doubly linked list implementation.

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ UCX_FOREACH

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define UCX_FOREACH( elem,
 list 
)   for (UcxList* elem = (UcxList*) list ; elem != NULL ; elem = elem->next)
+
+ +

Loop statement for UCX lists.

+

The first argument is the name of the iteration variable. The scope of this variable is limited to the UCX_FOREACH statement.

+

The second argument is a pointer to the list. In most cases this will be the pointer to the first element of the list, but it may also be an arbitrary element of the list. The iteration will then start with that element.

+
Parameters
+ + + +
listThe first element of the list
elemThe variable name of the element
+
+
+ +
+
+

Typedef Documentation

+ +

◆ UcxList

+ +
+
+ + + + +
typedef struct UcxList UcxList
+
+ +

UCX list type.

+
See also
UcxList
+ +
+
+

Function Documentation

+ +

◆ ucx_list_append()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_append (UcxList * list,
void * data 
)
+
+ +

Inserts an element at the end of the list.

+

This is generally an O(n) operation, as the end of the list is retrieved with ucx_list_last().

+
Parameters
+ + + +
listthe list where to append the data, or NULL to create a new list
datathe data to insert
+
+
+
Returns
list, if it is not NULL or a pointer to the newly created list otherwise
+ +
+
+ +

◆ ucx_list_append_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_append_a (UcxAllocator * allocator,
UcxList * list,
void * data 
)
+
+ +

Inserts an element at the end of the list using a UcxAllocator.

+

See ucx_list_append() for details.

+
Parameters
+ + + + +
allocatorthe allocator to use
listthe list where to append the data, or NULL to create a new list
datathe data to insert
+
+
+
Returns
list, if it is not NULL or a pointer to the newly created list otherwise
+
See also
ucx_list_append()
+ +
+
+ +

◆ ucx_list_clone()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_clone (const UcxList * list,
copy_func cpyfnc,
void * data 
)
+
+ +

Creates an element-wise copy of a list.

+

This function clones the specified list by creating new list elements and copying the data with the specified copy_func(). If no copy_func() is specified, a shallow copy is created and the new list will reference the same data as the source list.

+
Parameters
+ + + + +
listthe list to copy
cpyfnca pointer to the function that shall copy an element (may be NULL)
dataadditional data for the copy_func()
+
+
+
Returns
a pointer to the copy
+ +
+
+ +

◆ ucx_list_clone_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_clone_a (UcxAllocator * allocator,
const UcxList * list,
copy_func cpyfnc,
void * data 
)
+
+ +

Creates an element-wise copy of a list using a UcxAllocator.

+

See ucx_list_clone() for details.

+

You might want to pass the allocator via the data parameter, to access it within the copy function for making deep copies.

+
Parameters
+ + + + + +
allocatorthe allocator to use
listthe list to copy
cpyfnca pointer to the function that shall copy an element (may be NULL)
dataadditional data for the copy_func()
+
+
+
Returns
a pointer to the copy
+
See also
ucx_list_clone()
+ +
+
+ +

◆ ucx_list_concat()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_concat (UcxList * list1,
UcxList * list2 
)
+
+ +

Concatenates two lists.

+

Either of the two arguments may be NULL.

+

This function modifies the references to the next/previous element of the last/first element of list1/ list2.

+
Parameters
+ + + +
list1first list
list2second list
+
+
+
Returns
if list1 is NULL, list2 is returned, otherwise list1 is returned
+ +
+
+ +

◆ ucx_list_contains()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_list_contains (const UcxList * list,
void * elem,
cmp_func cmpfnc,
void * data 
)
+
+ +

Checks, if a list contains a specific element.

+

An element is found, if ucx_list_find() returns a value greater than -1.

+
Parameters
+ + + + + +
listthe list where to search for the data
elemthe element data
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
1, if and only if the list contains the specified element data
+
See also
ucx_list_find()
+ +
+
+ +

◆ ucx_list_difference()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_difference (const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the difference of two lists.

+

The difference contains all elements of the left list (including duplicates) that are not equal to any element of the right list.

+
Parameters
+ + + + + + + +
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the difference
+ +
+
+ +

◆ ucx_list_difference_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_difference_a (UcxAllocator * allocator,
const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the difference of two lists.

+

The difference contains all elements of the left list (including duplicates) that are not equal to any element of the right list.

+
Parameters
+ + + + + + + + +
allocatorallocates the new list elements
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the difference
+ +
+
+ +

◆ ucx_list_equals()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_list_equals (const UcxList * list1,
const UcxList * list2,
cmp_func cmpfnc,
void * data 
)
+
+ +

Compares two UCX lists element-wise by using a compare function.

+

Each element of the two specified lists are compared by using the specified compare function and the additional data. The type and content of this additional data depends on the cmp_func() used.

+

If the list pointers denote elements within a list, the lists are compared starting with the denoted elements. Thus any previous elements are not taken into account. This might be useful to check, if certain list tails match each other.

+
Parameters
+ + + + + +
list1the first list
list2the second list
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
1, if and only if the two lists equal element-wise, 0 otherwise
+ +
+
+ +

◆ ucx_list_find()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ssize_t ucx_list_find (const UcxList * list,
void * elem,
cmp_func cmpfnc,
void * data 
)
+
+ +

Returns the index of an element containing the specified data.

+

This function uses a cmp_func() to compare the data of each list element with the specified data. If no cmp_func is provided, the pointers are compared.

+

If the list contains the data more than once, the index of the first occurrence is returned.

+
Parameters
+ + + + + +
listthe list where to search for the data
elemthe element data
cmpfncthe compare function
dataadditional data for the compare function
+
+
+
Returns
the index of the element containing the specified data or -1 if the data is not found in this list
+ +
+
+ +

◆ ucx_list_first()

+ +
+
+ + + + + + + + +
UcxList* ucx_list_first (const UcxList * elem)
+
+ +

Returns the first element of a list.

+

If the argument is the list pointer, it is directly returned. Otherwise this function traverses to the first element of the list and returns the list pointer.

+
Parameters
+ + +
elemone element of the list
+
+
+
Returns
the first element of the list, the specified element is a member of
+ +
+
+ +

◆ ucx_list_free()

+ +
+
+ + + + + + + + +
void ucx_list_free (UcxList * list)
+
+ +

Destroys the entire list.

+

The members of the list are not automatically freed, so ensure they are otherwise referenced or destroyed by ucx_list_free_contents(). Otherwise, a memory leak is likely to occur.

+

Caution: the argument MUST denote an entire list (i.e. a call to ucx_list_first() on the argument must return the argument itself)

+
Parameters
+ + +
listthe list to free
+
+
+
See also
ucx_list_free_contents()
+ +
+
+ +

◆ ucx_list_free_a()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_list_free_a (UcxAllocator * allocator,
UcxList * list 
)
+
+ +

Destroys the entire list using a UcxAllocator.

+

See ucx_list_free() for details.

+
Parameters
+ + + +
allocatorthe allocator to use
listthe list to free
+
+
+
See also
ucx_list_free()
+ +
+
+ +

◆ ucx_list_free_content()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_list_free_content (UcxList * list,
ucx_destructor destr 
)
+
+ +

Destroys the contents of the specified list by calling the specified destructor on each of them.

+

Note, that the contents are not usable afterwards and the list should be destroyed with ucx_list_free().

+

If no destructor is specified (NULL), stdlib's free() is used.

+
Parameters
+ + + +
listthe list for which the contents shall be freed
destroptional destructor function
+
+
+
See also
ucx_list_free()
+ +
+
+ +

◆ ucx_list_get()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_get (const UcxList * list,
size_t index 
)
+
+ +

Returns the list element at the specified index.

+
Parameters
+ + + +
listthe list to retrieve the element from
indexindex of the element to return
+
+
+
Returns
the element at the specified index or NULL, if the index is greater than the list size
+ +
+
+ +

◆ ucx_list_indexof()

+ +
+
+ + + + + + + + + + + + + + + + + + +
ssize_t ucx_list_indexof (const UcxList * list,
const UcxList * elem 
)
+
+ +

Returns the index of an element.

+
Parameters
+ + + +
listthe list where to search for the element
elemthe element to find
+
+
+
Returns
the index of the element or -1 if the list does not contain the element
+ +
+
+ +

◆ ucx_list_intersection()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_intersection (const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the intersection of two lists.

+

The intersection contains all elements of the left list (including duplicates) that can be found in the right list.

+
Parameters
+ + + + + + + +
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the intersection
+ +
+
+ +

◆ ucx_list_intersection_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_intersection_a (UcxAllocator * allocator,
const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the intersection of two lists.

+

The intersection contains all elements of the left list (including duplicates) that can be found in the right list.

+
Parameters
+ + + + + + + + +
allocatorallocates the new list elements
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the intersection
+ +
+
+ +

◆ ucx_list_last()

+ +
+
+ + + + + + + + +
UcxList* ucx_list_last (const UcxList * elem)
+
+ +

Returns the last element of a list.

+

If the argument has no successor, it is the last element and therefore directly returned. Otherwise this function traverses to the last element of the list and returns it.

+
Parameters
+ + +
elemone element of the list
+
+
+
Returns
the last element of the list, the specified element is a member of
+ +
+
+ +

◆ ucx_list_prepend()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_prepend (UcxList * list,
void * data 
)
+
+ +

Inserts an element at the beginning of the list.

+

You should overwrite the old list pointer by calling mylist = ucx_list_prepend(mylist, mydata);. However, you may also perform successive calls of ucx_list_prepend() on the same list pointer, as this function always searchs for the head of the list with ucx_list_first().

+
Parameters
+ + + +
listthe list where to insert the data or NULL to create a new list
datathe data to insert
+
+
+
Returns
a pointer to the new list head
+ +
+
+ +

◆ ucx_list_prepend_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_prepend_a (UcxAllocator * allocator,
UcxList * list,
void * data 
)
+
+ +

Inserts an element at the beginning of the list using a UcxAllocator.

+

See ucx_list_prepend() for details.

+
Parameters
+ + + + +
allocatorthe allocator to use
listthe list where to insert the data or NULL to create a new list
datathe data to insert
+
+
+
Returns
a pointer to the new list head
+
See also
ucx_list_prepend()
+ +
+
+ +

◆ ucx_list_remove()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_remove (UcxList * list,
UcxList * element 
)
+
+ +

Removes an element from the list.

+

If the first element is removed, the list pointer changes. So it is highly recommended to always update the pointer by calling mylist = ucx_list_remove(mylist, myelem);.

+
Parameters
+ + + +
listthe list from which the element shall be removed
elementthe element to remove
+
+
+
Returns
returns the updated list pointer or NULL, if the list is now empty
+ +
+
+ +

◆ ucx_list_remove_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_remove_a (UcxAllocator * allocator,
UcxList * list,
UcxList * element 
)
+
+ +

Removes an element from the list using a UcxAllocator.

+

See ucx_list_remove() for details.

+
Parameters
+ + + + +
allocatorthe allocator to use
listthe list from which the element shall be removed
elementthe element to remove
+
+
+
Returns
returns the updated list pointer or NULL, if the list
+
See also
ucx_list_remove()
+ +
+
+ +

◆ ucx_list_size()

+ +
+
+ + + + + + + + +
size_t ucx_list_size (const UcxList * list)
+
+ +

Returns the element count of the list.

+
Parameters
+ + +
listthe list whose elements are counted
+
+
+
Returns
the element count
+ +
+
+ +

◆ ucx_list_sort()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_sort (UcxList * list,
cmp_func cmpfnc,
void * data 
)
+
+ +

Sorts a UcxList with natural merge sort.

+

This function uses O(n) additional temporary memory for merge operations that is automatically freed after each merge.

+

As the head of the list might change, you MUST call this function as follows: mylist = ucx_list_sort(mylist, mycmpfnc, mydata);.

+
Parameters
+ + + + +
listthe list to sort
cmpfncthe function that shall be used to compare the element data
dataadditional data for the cmp_func()
+
+
+
Returns
the sorted list
+ +
+
+ +

◆ ucx_list_union()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_union (const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the union of two lists.

+

The union is a list of unique elements regarding cmpfnc obtained from both source lists.

+
Parameters
+ + + + + + + +
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the union
+ +
+
+ +

◆ ucx_list_union_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxList* ucx_list_union_a (UcxAllocator * allocator,
const UcxList * left,
const UcxList * right,
cmp_func cmpfnc,
void * cmpdata,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the union of two lists.

+

The union is a list of unique elements regarding cmpfnc obtained from both source lists.

+
Parameters
+ + + + + + + + +
allocatorallocates the new list elements
leftthe left source list
rightthe right source list
cmpfnca function to compare elements
cmpdataadditional data for the compare function
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the union
+ +
+
+ + +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/list_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/list_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,116 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/list.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
list.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
36 #ifndef UCX_LIST_H
37 #define UCX_LIST_H
38 
39 #include "ucx.h"
40 #include "allocator.h"
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
59 #define UCX_FOREACH(elem,list) \
60  for (UcxList* elem = (UcxList*) list ; elem != NULL ; elem = elem->next)
61 
66 typedef struct UcxList UcxList;
67 
71 struct UcxList {
75  void *data;
80  UcxList *next;
85  UcxList *prev;
86 };
87 
102 UcxList *ucx_list_clone(const UcxList *list, copy_func cpyfnc, void* data);
103 
120 UcxList *ucx_list_clone_a(UcxAllocator *allocator, const UcxList *list,
121  copy_func cpyfnc, void* data);
122 
141 int ucx_list_equals(const UcxList *list1, const UcxList *list2,
142  cmp_func cmpfnc, void* data);
143 
157 void ucx_list_free(UcxList *list);
158 
168 void ucx_list_free_a(UcxAllocator *allocator, UcxList *list);
169 
183 void ucx_list_free_content(UcxList* list, ucx_destructor destr);
184 
185 
198 UcxList *ucx_list_append(UcxList *list, void *data);
199 
213 UcxList *ucx_list_append_a(UcxAllocator *allocator, UcxList *list, void *data);
214 
215 
230 UcxList *ucx_list_prepend(UcxList *list, void *data);
231 
244 UcxList *ucx_list_prepend_a(UcxAllocator *allocator, UcxList *list, void *data);
245 
260 UcxList *ucx_list_concat(UcxList *list1, UcxList *list2);
261 
272 UcxList *ucx_list_first(const UcxList *elem);
273 
284 UcxList *ucx_list_last(const UcxList *elem);
285 
294 UcxList *ucx_list_get(const UcxList *list, size_t index);
295 
304 ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem);
305 
312 size_t ucx_list_size(const UcxList *list);
313 
331 ssize_t ucx_list_find(const UcxList *list, void *elem,
332  cmp_func cmpfnc, void *data);
333 
346 int ucx_list_contains(const UcxList *list, void *elem,
347  cmp_func cmpfnc, void *data);
348 
363 UcxList *ucx_list_sort(UcxList *list, cmp_func cmpfnc, void *data);
364 
377 UcxList *ucx_list_remove(UcxList *list, UcxList *element);
378 
390 UcxList *ucx_list_remove_a(UcxAllocator *allocator, UcxList *list,
391  UcxList *element);
392 
407 UcxList* ucx_list_union(const UcxList *left, const UcxList *right,
408  cmp_func cmpfnc, void* cmpdata,
409  copy_func cpfnc, void* cpdata);
410 
426 UcxList* ucx_list_union_a(UcxAllocator *allocator,
427  const UcxList *left, const UcxList *right,
428  cmp_func cmpfnc, void* cmpdata,
429  copy_func cpfnc, void* cpdata);
430 
445 UcxList* ucx_list_intersection(const UcxList *left, const UcxList *right,
446  cmp_func cmpfnc, void* cmpdata,
447  copy_func cpfnc, void* cpdata);
448 
464 UcxList* ucx_list_intersection_a(UcxAllocator *allocator,
465  const UcxList *left, const UcxList *right,
466  cmp_func cmpfnc, void* cmpdata,
467  copy_func cpfnc, void* cpdata);
468 
483 UcxList* ucx_list_difference(const UcxList *left, const UcxList *right,
484  cmp_func cmpfnc, void* cmpdata,
485  copy_func cpfnc, void* cpdata);
486 
502 UcxList* ucx_list_difference_a(UcxAllocator *allocator,
503  const UcxList *left, const UcxList *right,
504  cmp_func cmpfnc, void* cmpdata,
505  copy_func cpfnc, void* cpdata);
506 
507 #ifdef __cplusplus
508 }
509 #endif
510 
511 #endif /* UCX_LIST_H */
512 
copy_func
void *(* copy_func)(const void *, void *)
Function pointer to a copy function.
Definition: ucx.h:106
+
ucx_list_append_a
UcxList * ucx_list_append_a(UcxAllocator *allocator, UcxList *list, void *data)
Inserts an element at the end of the list using a UcxAllocator.
Definition: list.c:91
+
ucx_list_get
UcxList * ucx_list_get(const UcxList *list, size_t index)
Returns the list element at the specified index.
Definition: list.c:163
+
ucx_list_append
UcxList * ucx_list_append(UcxList *list, void *data)
Inserts an element at the end of the list.
Definition: list.c:87
+
cmp_func
int(* cmp_func)(const void *, const void *, void *)
Function pointer to a compare function.
Definition: ucx.h:84
+
ucx_list_prepend
UcxList * ucx_list_prepend(UcxList *list, void *data)
Inserts an element at the beginning of the list.
Definition: list.c:110
+
ucx.h
Main UCX Header providing most common definitions.
+
ucx_list_first
UcxList * ucx_list_first(const UcxList *elem)
Returns the first element of a list.
Definition: list.c:307
+
ucx_list_free_a
void ucx_list_free_a(UcxAllocator *allocator, UcxList *list)
Destroys the entire list using a UcxAllocator.
Definition: list.c:70
+
UcxList
UCX list structure.
Definition: list.h:71
+
ucx_list_find
ssize_t ucx_list_find(const UcxList *list, void *elem, cmp_func cmpfnc, void *data)
Returns the index of an element containing the specified data.
Definition: list.c:175
+
ucx_list_difference_a
UcxList * ucx_list_difference_a(UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the difference of two lists.
Definition: list.c:421
+
ucx_list_clone_a
UcxList * ucx_list_clone_a(UcxAllocator *allocator, const UcxList *list, copy_func cpyfnc, void *data)
Creates an element-wise copy of a list using a UcxAllocator.
Definition: list.c:35
+
ucx_list_union
UcxList * ucx_list_union(const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the union of two lists.
Definition: list.c:382
+
ucx_list_concat
UcxList * ucx_list_concat(UcxList *list1, UcxList *list2)
Concatenates two lists.
Definition: list.c:128
+
ucx_list_last
UcxList * ucx_list_last(const UcxList *elem)
Returns the last element of a list.
Definition: list.c:141
+
ucx_list_remove
UcxList * ucx_list_remove(UcxList *list, UcxList *element)
Removes an element from the list.
Definition: list.c:319
+
UcxList::data
void * data
List element payload.
Definition: list.h:75
+
ucx_list_indexof
ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem)
Returns the index of an element.
Definition: list.c:151
+
ucx_list_remove_a
UcxList * ucx_list_remove_a(UcxAllocator *allocator, UcxList *list, UcxList *element)
Removes an element from the list using a UcxAllocator.
Definition: list.c:323
+
ucx_list_difference
UcxList * ucx_list_difference(const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the difference of two lists.
Definition: list.c:414
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
ucx_list_free_content
void ucx_list_free_content(UcxList *list, ucx_destructor destr)
Destroys the contents of the specified list by calling the specified destructor on each of them...
Definition: list.c:79
+
UcxList::next
UcxList * next
Pointer to the next list element or NULL, if this is the last element.
Definition: list.h:80
+
ucx_list_intersection_a
UcxList * ucx_list_intersection_a(UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the intersection of two lists.
Definition: list.c:405
+
ucx_list_intersection
UcxList * ucx_list_intersection(const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the intersection of two lists.
Definition: list.c:398
+
ucx_list_sort
UcxList * ucx_list_sort(UcxList *list, cmp_func cmpfnc, void *data)
Sorts a UcxList with natural merge sort.
Definition: list.c:254
+
ucx_list_clone
UcxList * ucx_list_clone(const UcxList *list, copy_func cpyfnc, void *data)
Creates an element-wise copy of a list.
Definition: list.c:31
+
allocator.h
Allocator for custom memory management.
+
ucx_list_prepend_a
UcxList * ucx_list_prepend_a(UcxAllocator *allocator, UcxList *list, void *data)
Inserts an element at the beginning of the list using a UcxAllocator.
Definition: list.c:114
+
ucx_list_free
void ucx_list_free(UcxList *list)
Destroys the entire list.
Definition: list.c:66
+
UcxList::prev
UcxList * prev
Pointer to the previous list element or NULL, if this is the first element.
Definition: list.h:85
+
ucx_list_union_a
UcxList * ucx_list_union_a(UcxAllocator *allocator, const UcxList *left, const UcxList *right, cmp_func cmpfnc, void *cmpdata, copy_func cpfnc, void *cpdata)
Returns the union of two lists.
Definition: list.c:389
+
ucx_list_equals
int ucx_list_equals(const UcxList *list1, const UcxList *list2, cmp_func cmpfnc, void *data)
Compares two UCX lists element-wise by using a compare function.
Definition: list.c:49
+
ucx_list_contains
int ucx_list_contains(const UcxList *list, void *elem, cmp_func cmpfnc, void *data)
Checks, if a list contains a specific element.
Definition: list.c:193
+
ucx_list_size
size_t ucx_list_size(const UcxList *list)
Returns the element count of the list.
Definition: list.c:198
+
ucx_destructor
void(* ucx_destructor)(void *)
A function pointer to a destructor function.
Definition: ucx.h:72
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/logging_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/logging_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,716 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/logging.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Functions
+
+
logging.h File Reference
+
+
+ +

Logging API. +More...

+
#include "ucx.h"
+#include "map.h"
+#include "string.h"
+#include <stdio.h>
+
+

Go to the source code of this file.

+ + + + + +

+Data Structures

struct  UcxLogger
 The UCX Logger object. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Macros

#define UCX_LOGGER_ERROR   0x00
 Log level for error messages. More...
 
#define UCX_LOGGER_WARN   0x10
 Log level for warning messages. More...
 
#define UCX_LOGGER_INFO   0x20
 Log level for information messages. More...
 
#define UCX_LOGGER_DEBUG   0x30
 Log level for debug messages. More...
 
#define UCX_LOGGER_TRACE   0x40
 Log level for trace messages. More...
 
#define UCX_LOGGER_LEVEL   0x01
 Output flag for the log level. More...
 
#define UCX_LOGGER_TIMESTAMP   0x02
 Output flag for the timestmap. More...
 
#define UCX_LOGGER_SOURCE   0x04
 Output flag for the source. More...
 
#define ucx_logger_register_level(logger, level, name)
 Registers a custom log level. More...
 
#define ucx_logger_log(logger, level, ...)   ucx_logger_logf(logger, level, __FILE__, __LINE__, __VA_ARGS__)
 Logs a message at the specified level. More...
 
#define ucx_logger_error(logger, ...)   ucx_logger_log(logger, UCX_LOGGER_ERROR, __VA_ARGS__)
 Shortcut for logging an error message. More...
 
#define ucx_logger_info(logger, ...)   ucx_logger_log(logger, UCX_LOGGER_INFO, __VA_ARGS__)
 Shortcut for logging an information message. More...
 
#define ucx_logger_warn(logger, ...)   ucx_logger_log(logger, UCX_LOGGER_WARN, __VA_ARGS__)
 Shortcut for logging a warning message. More...
 
#define ucx_logger_debug(logger, ...)   ucx_logger_log(logger, UCX_LOGGER_DEBUG, __VA_ARGS__)
 Shortcut for logging a debug message. More...
 
#define ucx_logger_trace(logger, ...)   ucx_logger_log(logger, UCX_LOGGER_TRACE, __VA_ARGS__)
 Shortcut for logging a trace message. More...
 
+ + + + + + + + + + +

+Functions

UcxLogger * ucx_logger_new (void *stream, unsigned int level, unsigned int mask)
 Creates a new logger. More...
 
void ucx_logger_free (UcxLogger *logger)
 Destroys the logger. More...
 
void ucx_logger_logf (UcxLogger *logger, unsigned int level, const char *file, const unsigned int line, const char *format,...)
 Internal log function - use macros instead. More...
 
+

Detailed Description

+

Logging API.

+
Author
Mike Becker, Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ UCX_LOGGER_DEBUG

+ +
+
+ + + + +
#define UCX_LOGGER_DEBUG   0x30
+
+ +

Log level for debug messages.

+ +
+
+ +

◆ ucx_logger_debug

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_logger_debug( logger,
 ... 
)   ucx_logger_log(logger, UCX_LOGGER_DEBUG, __VA_ARGS__)
+
+ +

Shortcut for logging a debug message.

+
Parameters
+ + + +
loggerthe logger to use
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+ +

◆ UCX_LOGGER_ERROR

+ +
+
+ + + + +
#define UCX_LOGGER_ERROR   0x00
+
+ +

Log level for error messages.

+ +
+
+ +

◆ ucx_logger_error

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_logger_error( logger,
 ... 
)   ucx_logger_log(logger, UCX_LOGGER_ERROR, __VA_ARGS__)
+
+ +

Shortcut for logging an error message.

+
Parameters
+ + + +
loggerthe logger to use
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+ +

◆ UCX_LOGGER_INFO

+ +
+
+ + + + +
#define UCX_LOGGER_INFO   0x20
+
+ +

Log level for information messages.

+ +
+
+ +

◆ ucx_logger_info

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_logger_info( logger,
 ... 
)   ucx_logger_log(logger, UCX_LOGGER_INFO, __VA_ARGS__)
+
+ +

Shortcut for logging an information message.

+
Parameters
+ + + +
loggerthe logger to use
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+ +

◆ UCX_LOGGER_LEVEL

+ +
+
+ + + + +
#define UCX_LOGGER_LEVEL   0x01
+
+ +

Output flag for the log level.

+

If this flag is set, the log message will contain the log level.

See also
UcxLogger.mask
+ +
+
+ +

◆ ucx_logger_log

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_logger_log( logger,
 level,
 ... 
)   ucx_logger_logf(logger, level, __FILE__, __LINE__, __VA_ARGS__)
+
+ +

Logs a message at the specified level.

+
Parameters
+ + + + +
loggerthe logger to use
levelthe level to log the message on
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+ +

◆ ucx_logger_register_level

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_logger_register_level( logger,
 level,
 name 
)
+
+Value:
{\
unsigned int l; \
l = level; \
ucx_map_int_put(logger->levels, l, (void*) "[" name "]"); \
} while (0);
+

Registers a custom log level.

+
Parameters
+ + + + +
loggerthe logger
levelthe log level as unsigned integer
namea string literal describing the level
+
+
+ +
+
+ +

◆ UCX_LOGGER_SOURCE

+ +
+
+ + + + +
#define UCX_LOGGER_SOURCE   0x04
+
+ +

Output flag for the source.

+

If this flag is set, the log message will contain the source file and line number.

See also
UcxLogger.mask
+ +
+
+ +

◆ UCX_LOGGER_TIMESTAMP

+ +
+
+ + + + +
#define UCX_LOGGER_TIMESTAMP   0x02
+
+ +

Output flag for the timestmap.

+

If this flag is set, the log message will contain the timestmap.

See also
UcxLogger.mask
+ +
+
+ +

◆ UCX_LOGGER_TRACE

+ +
+
+ + + + +
#define UCX_LOGGER_TRACE   0x40
+
+ +

Log level for trace messages.

+ +
+
+ +

◆ ucx_logger_trace

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_logger_trace( logger,
 ... 
)   ucx_logger_log(logger, UCX_LOGGER_TRACE, __VA_ARGS__)
+
+ +

Shortcut for logging a trace message.

+
Parameters
+ + + +
loggerthe logger to use
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+ +

◆ UCX_LOGGER_WARN

+ +
+
+ + + + +
#define UCX_LOGGER_WARN   0x10
+
+ +

Log level for warning messages.

+ +
+
+ +

◆ ucx_logger_warn

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_logger_warn( logger,
 ... 
)   ucx_logger_log(logger, UCX_LOGGER_WARN, __VA_ARGS__)
+
+ +

Shortcut for logging a warning message.

+
Parameters
+ + + +
loggerthe logger to use
...format string and arguments
+
+
+
See also
ucx_logger_logf()
+ +
+
+

Function Documentation

+ +

◆ ucx_logger_free()

+ +
+
+ + + + + + + + +
void ucx_logger_free (UcxLogger * logger)
+
+ +

Destroys the logger.

+

The map containing the valid log levels is also automatically destroyed.

+
Parameters
+ + +
loggerthe logger to destroy
+
+
+ +
+
+ +

◆ ucx_logger_logf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ucx_logger_logf (UcxLogger * logger,
unsigned int level,
const char * file,
const unsigned int line,
const char * format,
 ... 
)
+
+ +

Internal log function - use macros instead.

+

This function uses the format and variadic arguments for a printf()-style output of the log message.

+

Dependent on the UcxLogger.mask some information is prepended. The complete format is:

+

[LEVEL] [TIMESTAMP] [SOURCEFILE]:[LINENO] message

+

Attention: the message (including automatically generated information) is limited to 4096 characters. The level description is limited to 256 characters and the timestamp string is limited to 128 characters.

+
Parameters
+ + + + + + + +
loggerthe logger to use
levelthe level to log on
fileinformation about the source file
lineinformation about the source line number
formatformat string
...arguments
+
+
+
See also
ucx_logger_log()
+ +
+
+ +

◆ ucx_logger_new()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxLogger* ucx_logger_new (void * stream,
unsigned int level,
unsigned int mask 
)
+
+ +

Creates a new logger.

+
Parameters
+ + + + +
streamthe stream, which the logger shall write to
levelthe level on which the logger shall operate
maskconfiguration mask (cf. UcxLogger.mask)
+
+
+
Returns
a new logger object
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/logging_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/logging_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,94 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/logging.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
logging.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
34 #ifndef UCX_LOGGING_H
35 #define UCX_LOGGING_H
36 
37 #include "ucx.h"
38 #include "map.h"
39 #include "string.h"
40 #include <stdio.h>
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 /* leave enough space for custom log levels */
47 
49 #define UCX_LOGGER_ERROR 0x00
50 
52 #define UCX_LOGGER_WARN 0x10
53 
55 #define UCX_LOGGER_INFO 0x20
56 
58 #define UCX_LOGGER_DEBUG 0x30
59 
61 #define UCX_LOGGER_TRACE 0x40
62 
68 #define UCX_LOGGER_LEVEL 0x01
69 
75 #define UCX_LOGGER_TIMESTAMP 0x02
76 
83 #define UCX_LOGGER_SOURCE 0x04
84 
88 typedef struct {
90  void *stream;
91 
97  write_func writer;
98 
104  char *dateformat;
105 
111  unsigned int level;
112 
119  unsigned int mask;
120 
132  UcxMap* levels;
133 } UcxLogger;
134 
142 UcxLogger *ucx_logger_new(void *stream, unsigned int level, unsigned int mask);
143 
151 void ucx_logger_free(UcxLogger* logger);
152 
176 void ucx_logger_logf(UcxLogger *logger, unsigned int level, const char* file,
177  const unsigned int line, const char* format, ...);
178 
185 #define ucx_logger_register_level(logger, level, name) {\
186  unsigned int l; \
187  l = level; \
188  ucx_map_int_put(logger->levels, l, (void*) "[" name "]"); \
189  } while (0);
190 
198 #define ucx_logger_log(logger, level, ...) \
199  ucx_logger_logf(logger, level, __FILE__, __LINE__, __VA_ARGS__)
200 
207 #define ucx_logger_error(logger, ...) \
208  ucx_logger_log(logger, UCX_LOGGER_ERROR, __VA_ARGS__)
209 
216 #define ucx_logger_info(logger, ...) \
217  ucx_logger_log(logger, UCX_LOGGER_INFO, __VA_ARGS__)
218 
225 #define ucx_logger_warn(logger, ...) \
226  ucx_logger_log(logger, UCX_LOGGER_WARN, __VA_ARGS__)
227 
234 #define ucx_logger_debug(logger, ...) \
235  ucx_logger_log(logger, UCX_LOGGER_DEBUG, __VA_ARGS__)
236 
243 #define ucx_logger_trace(logger, ...) \
244  ucx_logger_log(logger, UCX_LOGGER_TRACE, __VA_ARGS__)
245 
246 #ifdef __cplusplus
247 }
248 #endif
249 
250 #endif /* UCX_LOGGING_H */
UcxLogger::writer
write_func writer
The write function that shall be used.
Definition: logging.h:97
+
string.h
Bounded string implementation.
+
ucx.h
Main UCX Header providing most common definitions.
+
UcxLogger
The UCX Logger object.
Definition: logging.h:88
+
UcxLogger::dateformat
char * dateformat
The date format for timestamp outputs including the delimiter (default: "%F %T %z ")...
Definition: logging.h:104
+
UcxLogger::mask
unsigned int mask
A configuration mask for automatic output.
Definition: logging.h:119
+
ucx_logger_new
UcxLogger * ucx_logger_new(void *stream, unsigned int level, unsigned int mask)
Creates a new logger.
Definition: logging.c:36
+
UcxLogger::stream
void * stream
The stream this logger writes its messages to.
Definition: logging.h:90
+
UcxMap
Structure for the UCX map.
Definition: map.h:81
+
map.h
Hash map implementation.
+
write_func
size_t(* write_func)(const void *, size_t, size_t, void *)
Function pointer to a write function.
Definition: ucx.h:119
+
UcxLogger::levels
UcxMap * levels
A map of valid log levels for this logger.
Definition: logging.h:132
+
UcxLogger::level
unsigned int level
The level, this logger operates on.
Definition: logging.h:111
+
ucx_logger_logf
void ucx_logger_logf(UcxLogger *logger, unsigned int level, const char *file, const unsigned int line, const char *format,...)
Internal log function - use macros instead.
Definition: logging.c:70
+
ucx_logger_free
void ucx_logger_free(UcxLogger *logger)
Destroys the logger.
Definition: logging.c:62
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/map_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/map_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,1689 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/map.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Typedefs | +Functions
+
+
map.h File Reference
+
+
+ +

Hash map implementation. +More...

+
#include "ucx.h"
+#include "string.h"
+#include "allocator.h"
+#include <stdio.h>
+
+

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + +

+Data Structures

struct  UcxMap
 Structure for the UCX map. More...
 
struct  UcxKey
 Structure to publicly denote a key of a UcxMap. More...
 
struct  UcxMapKey
 Internal structure for a key of a UcxMap. More...
 
struct  UcxMapElement
 Structure for an element of a UcxMap. More...
 
struct  UcxMapIterator
 Structure for an iterator over a UcxMap. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Macros

#define UCX_MAP_FOREACH(key, value, iter)   for(UcxKey key;ucx_map_iter_next(&iter,&key, (void**)&value);)
 Loop statement for UCX maps. More...
 
#define ucx_map_sstr_put(map, key, value)   ucx_map_put(map, ucx_key(key.ptr, key.length), (void*)value)
 Shorthand for putting data with a sstr_t key into the map. More...
 
#define ucx_map_cstr_put(map, key, value)   ucx_map_put(map, ucx_key(key, strlen(key)), (void*)value)
 Shorthand for putting data with a C string key into the map. More...
 
#define ucx_map_int_put(map, key, value)   ucx_map_put(map, ucx_key(&key, sizeof(key)), (void*)value)
 Shorthand for putting data with an integer key into the map. More...
 
#define ucx_map_sstr_get(map, key)   ucx_map_get(map, ucx_key(key.ptr, key.length))
 Shorthand for getting data from the map with a sstr_t key. More...
 
#define ucx_map_cstr_get(map, key)   ucx_map_get(map, ucx_key(key, strlen(key)))
 Shorthand for getting data from the map with a C string key. More...
 
#define ucx_map_int_get(map, key)   ucx_map_get(map, ucx_key(&key, sizeof(int)))
 Shorthand for getting data from the map with an integer key. More...
 
#define ucx_map_sstr_remove(map, key)   ucx_map_remove(map, ucx_key(key.ptr, key.length))
 Shorthand for removing data from the map with a sstr_t key. More...
 
#define ucx_map_cstr_remove(map, key)   ucx_map_remove(map, ucx_key(key, strlen(key)))
 Shorthand for removing data from the map with a C string key. More...
 
#define ucx_map_int_remove(map, key)   ucx_map_remove(map, ucx_key(&key, sizeof(key)))
 Shorthand for removing data from the map with an integer key. More...
 
+ + + + + + + + + + + + + +

+Typedefs

typedef struct UcxMap UcxMap
 Type for the UCX map. More...
 
typedef struct UcxKey UcxKey
 Type for a key of a UcxMap. More...
 
typedef struct UcxMapElement UcxMapElement
 Type for an element of a UcxMap. More...
 
typedef struct UcxMapIterator UcxMapIterator
 Type for an iterator over a UcxMap. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

UcxMap * ucx_map_new (size_t size)
 Creates a new hash map with the specified size. More...
 
UcxMap * ucx_map_new_a (UcxAllocator *allocator, size_t size)
 Creates a new hash map with the specified size using a UcxAllocator. More...
 
void ucx_map_free (UcxMap *map)
 Frees a hash map. More...
 
void ucx_map_free_content (UcxMap *map, ucx_destructor destr)
 Frees the contents of a hash map. More...
 
void ucx_map_clear (UcxMap *map)
 Clears a hash map. More...
 
int ucx_map_copy (UcxMap const *from, UcxMap *to, copy_func fnc, void *data)
 Copies contents from a map to another map using a copy function. More...
 
UcxMap * ucx_map_clone (UcxMap const *map, copy_func fnc, void *data)
 Clones the map and rehashes if necessary. More...
 
UcxMap * ucx_map_clone_a (UcxAllocator *allocator, UcxMap const *map, copy_func fnc, void *data)
 Clones the map and rehashes if necessary. More...
 
int ucx_map_rehash (UcxMap *map)
 Increases size of the hash map, if necessary. More...
 
int ucx_map_put (UcxMap *map, UcxKey key, void *value)
 Puts a key/value-pair into the map. More...
 
void * ucx_map_get (UcxMap const *map, UcxKey key)
 Retrieves a value by using a key. More...
 
void * ucx_map_remove (UcxMap *map, UcxKey key)
 Removes a key/value-pair from the map by using the key. More...
 
UcxKey ucx_key (const void *data, size_t len)
 Creates a UcxKey based on the given data. More...
 
int ucx_hash (const char *data, size_t len)
 Computes a murmur hash-2. More...
 
UcxMapIterator ucx_map_iterator (UcxMap const *map)
 Creates an iterator for a map. More...
 
int ucx_map_iter_next (UcxMapIterator *iterator, UcxKey *key, void **value)
 Proceeds to the next element of the map (if any). More...
 
UcxMap * ucx_map_union (const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the union of two maps. More...
 
UcxMap * ucx_map_union_a (UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the union of two maps. More...
 
UcxMap * ucx_map_intersection (const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the intersection of two maps. More...
 
UcxMap * ucx_map_intersection_a (UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the intersection of two maps. More...
 
UcxMap * ucx_map_difference (const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the difference of two maps. More...
 
UcxMap * ucx_map_difference_a (UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
 Returns the difference of two maps. More...
 
+

Detailed Description

+

Hash map implementation.

+

This implementation uses murmur hash 2 and separate chaining with linked lists.

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ ucx_map_cstr_get

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_cstr_get( map,
 key 
)   ucx_map_get(map, ucx_key(key, strlen(key)))
+
+ +

Shorthand for getting data from the map with a C string key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the value
+
See also
ucx_map_get()
+ +
+
+ +

◆ ucx_map_cstr_put

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_map_cstr_put( map,
 key,
 value 
)   ucx_map_put(map, ucx_key(key, strlen(key)), (void*)value)
+
+ +

Shorthand for putting data with a C string key into the map.

+
Parameters
+ + + + +
mapthe map
keythe key
valuethe value
+
+
+
Returns
0 on success, non-zero value on failure
+
See also
ucx_map_put()
+ +
+
+ +

◆ ucx_map_cstr_remove

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_cstr_remove( map,
 key 
)   ucx_map_remove(map, ucx_key(key, strlen(key)))
+
+ +

Shorthand for removing data from the map with a C string key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the removed value
+
See also
ucx_map_remove()
+ +
+
+ +

◆ UCX_MAP_FOREACH

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define UCX_MAP_FOREACH( key,
 value,
 iter 
)   for(UcxKey key;ucx_map_iter_next(&iter,&key, (void**)&value);)
+
+ +

Loop statement for UCX maps.

+

The key variable is implicitly defined, but the value variable must be already declared as type information cannot be inferred.

+
Parameters
+ + + + +
keythe variable name for the key
valuethe variable name for the value
itera UcxMapIterator
+
+
+
See also
ucx_map_iterator()
+ +
+
+ +

◆ ucx_map_int_get

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_int_get( map,
 key 
)   ucx_map_get(map, ucx_key(&key, sizeof(int)))
+
+ +

Shorthand for getting data from the map with an integer key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the value
+
See also
ucx_map_get()
+ +
+
+ +

◆ ucx_map_int_put

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_map_int_put( map,
 key,
 value 
)   ucx_map_put(map, ucx_key(&key, sizeof(key)), (void*)value)
+
+ +

Shorthand for putting data with an integer key into the map.

+
Parameters
+ + + + +
mapthe map
keythe key
valuethe value
+
+
+
Returns
0 on success, non-zero value on failure
+
See also
ucx_map_put()
+ +
+
+ +

◆ ucx_map_int_remove

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_int_remove( map,
 key 
)   ucx_map_remove(map, ucx_key(&key, sizeof(key)))
+
+ +

Shorthand for removing data from the map with an integer key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the removed value
+
See also
ucx_map_remove()
+ +
+
+ +

◆ ucx_map_sstr_get

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_sstr_get( map,
 key 
)   ucx_map_get(map, ucx_key(key.ptr, key.length))
+
+ +

Shorthand for getting data from the map with a sstr_t key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the value
+
See also
ucx_map_get()
+ +
+
+ +

◆ ucx_map_sstr_put

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define ucx_map_sstr_put( map,
 key,
 value 
)   ucx_map_put(map, ucx_key(key.ptr, key.length), (void*)value)
+
+ +

Shorthand for putting data with a sstr_t key into the map.

+
Parameters
+ + + + +
mapthe map
keythe key
valuethe value
+
+
+
Returns
0 on success, non-zero value on failure
+
See also
ucx_map_put()
+ +
+
+ +

◆ ucx_map_sstr_remove

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define ucx_map_sstr_remove( map,
 key 
)   ucx_map_remove(map, ucx_key(key.ptr, key.length))
+
+ +

Shorthand for removing data from the map with a sstr_t key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the removed value
+
See also
ucx_map_remove()
+ +
+
+

Typedef Documentation

+ +

◆ UcxKey

+ +
+
+ + + + +
typedef struct UcxKey UcxKey
+
+ +

Type for a key of a UcxMap.

+
See also
UcxKey
+ +
+
+ +

◆ UcxMap

+ +
+
+ + + + +
typedef struct UcxMap UcxMap
+
+ +

Type for the UCX map.

+
See also
UcxMap
+ +
+
+ +

◆ UcxMapElement

+ +
+
+ + + + +
typedef struct UcxMapElement UcxMapElement
+
+ +

Type for an element of a UcxMap.

+
See also
UcxMapElement
+ +
+
+ +

◆ UcxMapIterator

+ +
+
+ + + + +
typedef struct UcxMapIterator UcxMapIterator
+
+ +

Type for an iterator over a UcxMap.

+
See also
UcxMapIterator
+ +
+
+

Function Documentation

+ +

◆ ucx_hash()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_hash (const char * data,
size_t len 
)
+
+ +

Computes a murmur hash-2.

+
Parameters
+ + + +
datathe data to hash
lenthe length of the data
+
+
+
Returns
the murmur hash-2 of the data
+ +
+
+ +

◆ ucx_key()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxKey ucx_key (const void * data,
size_t len 
)
+
+ +

Creates a UcxKey based on the given data.

+

This function implicitly computes the hash.

+
Parameters
+ + + +
datathe data for the key
lenthe length of the data
+
+
+
Returns
a UcxKey with implicitly computed hash
+
See also
ucx_hash()
+ +
+
+ +

◆ ucx_map_clear()

+ +
+
+ + + + + + + + +
void ucx_map_clear (UcxMap * map)
+
+ +

Clears a hash map.

+

Note: the contents are not freed, use ucx_map_free_content() before calling this function to achieve that.

+
Parameters
+ + +
mapthe map to be cleared
+
+
+
See also
ucx_map_free_content()
+ +
+
+ +

◆ ucx_map_clone()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_clone (UcxMap const * map,
copy_func fnc,
void * data 
)
+
+ +

Clones the map and rehashes if necessary.

+

Note: In contrast to ucx_map_rehash() the load factor is irrelevant. This function always ensures a new UcxMap.size of at least 2.5*UcxMap.count.

+
Parameters
+ + + + +
mapthe map to clone
fncthe copy function to use or NULL if the new and the old map shall share the data pointers
dataadditional data for the copy function
+
+
+
Returns
the cloned map
+
See also
ucx_map_copy()
+ +
+
+ +

◆ ucx_map_clone_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_clone_a (UcxAllocator * allocator,
UcxMap const * map,
copy_func fnc,
void * data 
)
+
+ +

Clones the map and rehashes if necessary.

+

Note: In contrast to ucx_map_rehash() the load factor is irrelevant. This function always ensures a new UcxMap.size of at least 2.5*UcxMap.count.

+
Parameters
+ + + + + +
allocatorthe allocator to use for the cloned map
mapthe map to clone
fncthe copy function to use or NULL if the new and the old map shall share the data pointers
dataadditional data for the copy function
+
+
+
Returns
the cloned map
+
See also
ucx_map_copy()
+ +
+
+ +

◆ ucx_map_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_map_copy (UcxMap const * from,
UcxMap * to,
copy_func fnc,
void * data 
)
+
+ +

Copies contents from a map to another map using a copy function.

+

Note: The destination map does not need to be empty. However, if it contains data with keys that are also present in the source map, the contents are overwritten.

+
Parameters
+ + + + + +
fromthe source map
tothe destination map
fncthe copy function or NULL if the pointer address shall be copied
dataadditional data for the copy function
+
+
+
Returns
0 on success or a non-zero value on memory allocation errors
+ +
+
+ +

◆ ucx_map_difference()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_difference (const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the difference of two maps.

+

The difference contains a copy of all elements of the first map for which the corresponding keys cannot be found in the second map.

+
Parameters
+ + + + + +
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the difference
+ +
+
+ +

◆ ucx_map_difference_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_difference_a (UcxAllocator * allocator,
const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the difference of two maps.

+

The difference contains a copy of all elements of the first map for which the corresponding keys cannot be found in the second map.

+
Parameters
+ + + + + + +
allocatorthe allocator that shall be used by the new map
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new list containing the difference
+ +
+
+ +

◆ ucx_map_free()

+ +
+
+ + + + + + + + +
void ucx_map_free (UcxMap * map)
+
+ +

Frees a hash map.

+

Note: the contents are not freed, use ucx_map_free_content() before calling this function to achieve that.

+
Parameters
+ + +
mapthe map to be freed
+
+
+
See also
ucx_map_free_content()
+ +
+
+ +

◆ ucx_map_free_content()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_map_free_content (UcxMap * map,
ucx_destructor destr 
)
+
+ +

Frees the contents of a hash map.

+

This is a convenience function that iterates over the map and passes all values to the specified destructor function.

+

If no destructor is specified (NULL), the free() function of the map's own allocator is used.

+

You must ensure, that it is valid to pass each value in the map to the same destructor function.

+

You should free or clear the map afterwards, as the contents will be invalid.

+
Parameters
+ + + +
mapfor which the contents shall be freed
destroptional pointer to a destructor function
+
+
+
See also
ucx_map_free()
+
+ucx_map_clear()
+ +
+
+ +

◆ ucx_map_get()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_map_get (UcxMap const * map,
UcxKey key 
)
+
+ +

Retrieves a value by using a key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the value
+ +
+
+ +

◆ ucx_map_intersection()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_intersection (const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the intersection of two maps.

+

The intersection is defined as a copy of the first map with every element removed that has no valid key in the second map.

+
Parameters
+ + + + + +
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new map containing the intersection
+ +
+
+ +

◆ ucx_map_intersection_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_intersection_a (UcxAllocator * allocator,
const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the intersection of two maps.

+

The intersection is defined as a copy of the first map with every element removed that has no valid key in the second map.

+
Parameters
+ + + + + + +
allocatorthe allocator that shall be used by the new map
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new map containing the intersection
+ +
+
+ +

◆ ucx_map_iter_next()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_map_iter_next (UcxMapIterator * iterator,
UcxKey * key,
void ** value 
)
+
+ +

Proceeds to the next element of the map (if any).

+

Subsequent calls on the same iterator proceed to the next element and store the key/value-pair into the memory specified as arguments of this function.

+

If no further elements are found, this function returns zero and leaves the last found key/value-pair in memory.

+
Parameters
+ + + + +
iteratorthe iterator to use
keya pointer to the memory where to store the key
valuea pointer to the memory where to store the value
+
+
+
Returns
1, if another element was found, 0 if all elements has been processed
+
See also
ucx_map_iterator()
+ +
+
+ +

◆ ucx_map_iterator()

+ +
+
+ + + + + + + + +
UcxMapIterator ucx_map_iterator (UcxMap const * map)
+
+ +

Creates an iterator for a map.

+

Note: A UcxMapIterator iterates over all elements in all element lists successively. Therefore the order highly depends on the key hashes and may vary under different map sizes. So generally you may NOT rely on the iteration order.

+

Note: The iterator is NOT initialized. You need to call ucx_map_iter_next() at least once before accessing any information. However, it is not recommended to access the fields of a UcxMapIterator directly.

+
Parameters
+ + +
mapthe map to create the iterator for
+
+
+
Returns
an iterator initialized on the first element of the first element list
+
See also
ucx_map_iter_next()
+ +
+
+ +

◆ ucx_map_new()

+ +
+
+ + + + + + + + +
UcxMap* ucx_map_new (size_t size)
+
+ +

Creates a new hash map with the specified size.

+
Parameters
+ + +
sizethe size of the hash map
+
+
+
Returns
a pointer to the new hash map
+ +
+
+ +

◆ ucx_map_new_a()

+ +
+
+ + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_new_a (UcxAllocator * allocator,
size_t size 
)
+
+ +

Creates a new hash map with the specified size using a UcxAllocator.

+
Parameters
+ + + +
allocatorthe allocator to use
sizethe size of the hash map
+
+
+
Returns
a pointer to the new hash map
+ +
+
+ +

◆ ucx_map_put()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int ucx_map_put (UcxMap * map,
UcxKey key,
void * value 
)
+
+ +

Puts a key/value-pair into the map.

+
Parameters
+ + + + +
mapthe map
keythe key
valuethe value
+
+
+
Returns
0 on success, non-zero value on failure
+ +
+
+ +

◆ ucx_map_rehash()

+ +
+
+ + + + + + + + +
int ucx_map_rehash (UcxMap * map)
+
+ +

Increases size of the hash map, if necessary.

+

The load value is 0.75*UcxMap.size. If the element count exceeds the load value, the map needs to be rehashed. Otherwise no action is performed and this function simply returns 0.

+

The rehashing process ensures, that the UcxMap.size is at least 2.5*UcxMap.count. So there is enough room for additional elements without the need of another soon rehashing.

+

You can use this function to dramatically increase access performance.

+
Parameters
+ + +
mapthe map to rehash
+
+
+
Returns
1, if a memory allocation error occurred, 0 otherwise
+ +
+
+ +

◆ ucx_map_remove()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_map_remove (UcxMap * map,
UcxKey key 
)
+
+ +

Removes a key/value-pair from the map by using the key.

+
Parameters
+ + + +
mapthe map
keythe key
+
+
+
Returns
the removed value
+ +
+
+ +

◆ ucx_map_union()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_union (const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the union of two maps.

+

The union is a fresh map which is filled by two successive calls of ucx_map_copy() on the two input maps.

+
Parameters
+ + + + + +
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new map containing the union
+ +
+
+ +

◆ ucx_map_union_a()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UcxMap* ucx_map_union_a (UcxAllocator * allocator,
const UcxMap * first,
const UcxMap * second,
copy_func cpfnc,
void * cpdata 
)
+
+ +

Returns the union of two maps.

+

The union is a fresh map which is filled by two successive calls of ucx_map_copy() on the two input maps.

+
Parameters
+ + + + + + +
allocatorthe allocator that shall be used by the new map
firstthe first source map
secondthe second source map
cpfnca function to copy the elements
cpdataadditional data for the copy function
+
+
+
Returns
a new map containing the union
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/map_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/map_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,127 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/map.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
map.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
41 #ifndef UCX_MAP_H
42 #define UCX_MAP_H
43 
44 #include "ucx.h"
45 #include "string.h"
46 #include "allocator.h"
47 #include <stdio.h>
48 
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52 
65 #define UCX_MAP_FOREACH(key,value,iter) \
66  for(UcxKey key;ucx_map_iter_next(&iter,&key, (void**)&value);)
67 
69 typedef struct UcxMap UcxMap;
70 
72 typedef struct UcxKey UcxKey;
73 
75 typedef struct UcxMapElement UcxMapElement;
76 
78 typedef struct UcxMapIterator UcxMapIterator;
79 
81 struct UcxMap {
83  UcxAllocator *allocator;
85  UcxMapElement **map;
87  size_t size;
89  size_t count;
90 };
91 
93 struct UcxKey {
95  const void *data;
97  size_t len;
99  int hash;
100 };
101 
103 struct UcxMapKey {
105  void *data;
107  size_t len;
109  int hash;
110 };
111 
113 struct UcxMapElement {
115  void *data;
116 
118  UcxMapElement *next;
119 
121  struct UcxMapKey key;
122 };
123 
125 struct UcxMapIterator {
127  UcxMap const *map;
128 
130  UcxMapElement *cur;
131 
138  size_t index;
139 };
140 
146 UcxMap *ucx_map_new(size_t size);
147 
154 UcxMap *ucx_map_new_a(UcxAllocator *allocator, size_t size);
155 
165 void ucx_map_free(UcxMap *map);
166 
186 void ucx_map_free_content(UcxMap *map, ucx_destructor destr);
187 
197 void ucx_map_clear(UcxMap *map);
198 
199 
214 int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data);
215 
230 UcxMap *ucx_map_clone(UcxMap const *map, copy_func fnc, void *data);
231 
247 UcxMap *ucx_map_clone_a(UcxAllocator *allocator,
248  UcxMap const *map, copy_func fnc, void *data);
249 
266 int ucx_map_rehash(UcxMap *map);
267 
276 int ucx_map_put(UcxMap *map, UcxKey key, void *value);
277 
285 void* ucx_map_get(UcxMap const *map, UcxKey key);
286 
294 void* ucx_map_remove(UcxMap *map, UcxKey key);
295 
304 #define ucx_map_sstr_put(map, key, value) \
305  ucx_map_put(map, ucx_key(key.ptr, key.length), (void*)value)
306 
315 #define ucx_map_cstr_put(map, key, value) \
316  ucx_map_put(map, ucx_key(key, strlen(key)), (void*)value)
317 
326 #define ucx_map_int_put(map, key, value) \
327  ucx_map_put(map, ucx_key(&key, sizeof(key)), (void*)value)
328 
336 #define ucx_map_sstr_get(map, key) \
337  ucx_map_get(map, ucx_key(key.ptr, key.length))
338 
346 #define ucx_map_cstr_get(map, key) \
347  ucx_map_get(map, ucx_key(key, strlen(key)))
348 
356 #define ucx_map_int_get(map, key) \
357  ucx_map_get(map, ucx_key(&key, sizeof(int)))
358 
366 #define ucx_map_sstr_remove(map, key) \
367  ucx_map_remove(map, ucx_key(key.ptr, key.length))
368 
376 #define ucx_map_cstr_remove(map, key) \
377  ucx_map_remove(map, ucx_key(key, strlen(key)))
378 
386 #define ucx_map_int_remove(map, key) \
387  ucx_map_remove(map, ucx_key(&key, sizeof(key)))
388 
399 UcxKey ucx_key(const void *data, size_t len);
400 
408 int ucx_hash(const char *data, size_t len);
409 
427 UcxMapIterator ucx_map_iterator(UcxMap const *map);
428 
445 int ucx_map_iter_next(UcxMapIterator *iterator, UcxKey *key, void **value);
446 
459 UcxMap* ucx_map_union(const UcxMap *first, const UcxMap *second,
460  copy_func cpfnc, void* cpdata);
461 
475 UcxMap* ucx_map_union_a(UcxAllocator *allocator,
476  const UcxMap *first, const UcxMap *second,
477  copy_func cpfnc, void* cpdata);
478 
491 UcxMap* ucx_map_intersection(const UcxMap *first, const UcxMap *second,
492  copy_func cpfnc, void* cpdata);
493 
507 UcxMap* ucx_map_intersection_a(UcxAllocator *allocator,
508  const UcxMap *first, const UcxMap *second,
509  copy_func cpfnc, void* cpdata);
510 
523 UcxMap* ucx_map_difference(const UcxMap *first, const UcxMap *second,
524  copy_func cpfnc, void* cpdata);
525 
539 UcxMap* ucx_map_difference_a(UcxAllocator *allocator,
540  const UcxMap *first, const UcxMap *second,
541  copy_func cpfnc, void* cpdata);
542 
543 
544 #ifdef __cplusplus
545 }
546 #endif
547 
548 #endif /* UCX_MAP_H */
549 
copy_func
void *(* copy_func)(const void *, void *)
Function pointer to a copy function.
Definition: ucx.h:106
+
UcxMapIterator::index
size_t index
The current index of the element list array.
Definition: map.h:138
+
UcxMapKey::len
size_t len
The length of the key data.
Definition: map.h:107
+
ucx_map_difference_a
UcxMap * ucx_map_difference_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the difference of two maps.
Definition: map.c:386
+
string.h
Bounded string implementation.
+
ucx.h
Main UCX Header providing most common definitions.
+
ucx_hash
int ucx_hash(const char *data, size_t len)
Computes a murmur hash-2.
Definition: map.c:260
+
UcxMapKey::hash
int hash
The hash value of the key data.
Definition: map.h:109
+
ucx_map_free_content
void ucx_map_free_content(UcxMap *map, ucx_destructor destr)
Frees the contents of a hash map.
Definition: map.c:85
+
ucx_map_get
void * ucx_map_get(UcxMap const *map, UcxKey key)
Retrieves a value by using a key.
Definition: map.c:243
+
ucx_map_iterator
UcxMapIterator ucx_map_iterator(UcxMap const *map)
Creates an iterator for a map.
Definition: map.c:302
+
ucx_map_union
UcxMap * ucx_map_union(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the union of two maps.
Definition: map.c:343
+
UcxKey::hash
int hash
A cache for the hash value of the key data.
Definition: map.h:99
+
ucx_map_clear
void ucx_map_clear(UcxMap *map)
Clears a hash map.
Definition: map.c:97
+
ucx_map_difference
UcxMap * ucx_map_difference(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the difference of two maps.
Definition: map.c:380
+
UcxMapElement
Structure for an element of a UcxMap.
Definition: map.h:113
+
UcxKey
Structure to publicly denote a key of a UcxMap.
Definition: map.h:93
+
UcxMap::count
size_t count
The count of elements currently stored in this map.
Definition: map.h:89
+
UcxMapElement::next
UcxMapElement * next
A pointer to the next element in the current list.
Definition: map.h:118
+
ucx_map_union_a
UcxMap * ucx_map_union_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the union of two maps.
Definition: map.c:349
+
UcxMapIterator::map
UcxMap const * map
The map to iterate over.
Definition: map.h:127
+
UcxMapIterator
Structure for an iterator over a UcxMap.
Definition: map.h:125
+
UcxMapElement::data
void * data
The value data.
Definition: map.h:115
+
ucx_map_copy
int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data)
Copies contents from a map to another map using a copy function.
Definition: map.c:106
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
ucx_key
UcxKey ucx_key(const void *data, size_t len)
Creates a UcxKey based on the given data.
Definition: map.c:251
+
ucx_map_new
UcxMap * ucx_map_new(size_t size)
Creates a new hash map with the specified size.
Definition: map.c:34
+
UcxMapIterator::cur
UcxMapElement * cur
The current map element.
Definition: map.h:130
+
ucx_map_new_a
UcxMap * ucx_map_new_a(UcxAllocator *allocator, size_t size)
Creates a new hash map with the specified size using a UcxAllocator.
Definition: map.c:38
+
UcxMap::allocator
UcxAllocator * allocator
An allocator that is used for the map elements.
Definition: map.h:83
+
UcxMapKey
Internal structure for a key of a UcxMap.
Definition: map.h:103
+
ucx_map_put
int ucx_map_put(UcxMap *map, UcxKey key, void *value)
Puts a key/value-pair into the map.
Definition: map.c:158
+
ucx_map_clone_a
UcxMap * ucx_map_clone_a(UcxAllocator *allocator, UcxMap const *map, copy_func fnc, void *data)
Clones the map and rehashes if necessary.
Definition: map.c:121
+
UcxMap::size
size_t size
The size of the map is the length of the element list array.
Definition: map.h:87
+
ucx_map_iter_next
int ucx_map_iter_next(UcxMapIterator *iterator, UcxKey *key, void **value)
Proceeds to the next element of the map (if any).
Definition: map.c:310
+
UcxKey::data
const void * data
The key data.
Definition: map.h:95
+
allocator.h
Allocator for custom memory management.
+
UcxMap
Structure for the UCX map.
Definition: map.h:81
+
ucx_map_remove
void * ucx_map_remove(UcxMap *map, UcxKey key)
Removes a key/value-pair from the map by using the key.
Definition: map.c:247
+
UcxKey::len
size_t len
The length of the key data.
Definition: map.h:97
+
ucx_map_intersection
UcxMap * ucx_map_intersection(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the intersection of two maps.
Definition: map.c:357
+
ucx_map_rehash
int ucx_map_rehash(UcxMap *map)
Increases size of the hash map, if necessary.
Definition: map.c:132
+
ucx_map_free
void ucx_map_free(UcxMap *map)
Frees a hash map.
Definition: map.c:79
+
ucx_map_clone
UcxMap * ucx_map_clone(UcxMap const *map, copy_func fnc, void *data)
Clones the map and rehashes if necessary.
Definition: map.c:117
+
UcxMap::map
UcxMapElement ** map
The array of map element lists.
Definition: map.h:85
+
ucx_map_intersection_a
UcxMap * ucx_map_intersection_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the intersection of two maps.
Definition: map.c:363
+
UcxMapKey::data
void * data
The key data.
Definition: map.h:105
+
ucx_destructor
void(* ucx_destructor)(void *)
A function pointer to a destructor function.
Definition: ucx.h:72
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/mempool_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/mempool_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,517 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/mempool.h File Reference + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Data Structures | +Macros | +Functions
+
+
mempool.h File Reference
+
+
+ +

Memory pool implementation. +More...

+
#include "ucx.h"
+#include "allocator.h"
+#include <stddef.h>
+
+

Go to the source code of this file.

+ + + + + +

+Data Structures

struct  UcxMempool
 UCX mempool structure. More...
 
+ + + + +

+Macros

#define ucx_mempool_new_default()   ucx_mempool_new(16)
 Shorthand for a new default memory pool with a capacity of 16 elements. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

UcxMempool * ucx_mempool_new (size_t n)
 Creates a memory pool with the specified initial size. More...
 
int ucx_mempool_chcap (UcxMempool *pool, size_t newcap)
 Resizes a memory pool. More...
 
void * ucx_mempool_malloc (UcxMempool *pool, size_t n)
 Allocates pooled memory. More...
 
void * ucx_mempool_calloc (UcxMempool *pool, size_t nelem, size_t elsize)
 Allocates a pooled memory array. More...
 
void * ucx_mempool_realloc (UcxMempool *pool, void *ptr, size_t n)
 Reallocates pooled memory. More...
 
void ucx_mempool_free (UcxMempool *pool, void *ptr)
 Frees pooled memory. More...
 
void ucx_mempool_destroy (UcxMempool *pool)
 Destroys a memory pool. More...
 
void ucx_mempool_set_destr (void *ptr, ucx_destructor func)
 Sets a destructor function for the specified memory. More...
 
void ucx_mempool_reg_destr (UcxMempool *pool, void *ptr, ucx_destructor destr)
 Registers a destructor function for the specified (non-pooled) memory. More...
 
+

Detailed Description

+

Memory pool implementation.

+
Author
Mike Becker
+
+Olaf Wintermann
+

Macro Definition Documentation

+ +

◆ ucx_mempool_new_default

+ +
+
+ + + + + + + +
#define ucx_mempool_new_default()   ucx_mempool_new(16)
+
+ +

Shorthand for a new default memory pool with a capacity of 16 elements.

+ +
+
+

Function Documentation

+ +

◆ ucx_mempool_calloc()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void* ucx_mempool_calloc (UcxMempool * pool,
size_t nelem,
size_t elsize 
)
+
+ +

Allocates a pooled memory array.

+

The content of the allocated memory is set to zero.

+
Parameters
+ + + + +
poolthe memory pool
nelemamount of elements to allocate
elsizeamount of memory per element
+
+
+
Returns
a pointer to the allocated memory
+
See also
ucx_allocator_calloc()
+ +
+
+ +

◆ ucx_mempool_chcap()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int ucx_mempool_chcap (UcxMempool * pool,
size_t newcap 
)
+
+ +

Resizes a memory pool.

+

This function will fail if the new capacity is not sufficient for the present data.

+
Parameters
+ + + +
poolthe pool to resize
newcapthe new capacity
+
+
+
Returns
zero on success or non-zero on failure
+ +
+
+ +

◆ ucx_mempool_destroy()

+ +
+
+ + + + + + + + +
void ucx_mempool_destroy (UcxMempool * pool)
+
+ +

Destroys a memory pool.

+

For each element the destructor function (if any) is called and the element is freed.

+

Each of the registered destructor function that has no corresponding element within the pool (namely those registered by ucx_mempool_reg_destr) is called interleaving with the element destruction, but with guarantee to the order in which they were registered (FIFO order).

+
Parameters
+ + +
poolthe mempool to destroy
+
+
+ +
+
+ +

◆ ucx_mempool_free()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_mempool_free (UcxMempool * pool,
void * ptr 
)
+
+ +

Frees pooled memory.

+

Before freeing the memory, the specified destructor function (if any) is called.

+

If you specify memory, that is not pooled by the specified memory pool, the program will terminate with a call to abort().

+
Parameters
+ + + +
poolthe memory pool
ptra pointer to the memory that shall be freed
+
+
+
See also
ucx_mempool_set_destr()
+ +
+
+ +

◆ ucx_mempool_malloc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* ucx_mempool_malloc (UcxMempool * pool,
size_t n 
)
+
+ +

Allocates pooled memory.

+
Parameters
+ + + +
poolthe memory pool
namount of memory to allocate
+
+
+
Returns
a pointer to the allocated memory
+
See also
ucx_allocator_malloc()
+ +
+
+ +

◆ ucx_mempool_new()

+ +
+
+ + + + + + + + +
UcxMempool* ucx_mempool_new (size_t n)
+
+ +

Creates a memory pool with the specified initial size.

+

As the created memory pool automatically grows in size by factor two when trying to allocate memory on a full pool, it is recommended that you use a power of two for the initial size.

+
Parameters
+ + +
ninitial pool size (should be a power of two, e.g. 16)
+
+
+
Returns
a pointer to the new memory pool
+
See also
ucx_mempool_new_default()
+ +
+
+ +

◆ ucx_mempool_realloc()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void* ucx_mempool_realloc (UcxMempool * pool,
void * ptr,
size_t n 
)
+
+ +

Reallocates pooled memory.

+

If the memory to be reallocated is not contained by the specified pool, the behavior is undefined.

+
Parameters
+ + + + +
poolthe memory pool
ptra pointer to the memory that shall be reallocated
nthe new size of the memory
+
+
+
Returns
a pointer to the new location of the memory
+
See also
ucx_allocator_realloc()
+ +
+
+ +

◆ ucx_mempool_reg_destr()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ucx_mempool_reg_destr (UcxMempool * pool,
void * ptr,
ucx_destructor destr 
)
+
+ +

Registers a destructor function for the specified (non-pooled) memory.

+

This is useful, if you have memory that has not been allocated by a mempool, but shall be managed by a mempool.

+

This function creates an entry in the specified mempool and the memory will therefore (logically) convert to pooled memory. However, this does not cause the memory to be freed automatically!. If you want to use this function, make the memory pool free non-pooled memory, the specified destructor function must call free() by itself. But keep in mind, that you then MUST NOT use this destructor function with pooled memory (e.g. in ucx_mempool_set_destr()), as it would cause a double-free.

+
Parameters
+ + + + +
poolthe memory pool
ptrdata the destructor is registered for
destra pointer to the destructor function
+
+
+ +
+
+ +

◆ ucx_mempool_set_destr()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void ucx_mempool_set_destr (void * ptr,
ucx_destructor func 
)
+
+ +

Sets a destructor function for the specified memory.

+

The destructor is automatically called when the memory is freed or the pool is destroyed. A destructor for pooled memory MUST NOT free the memory itself, as this is done by the pool. Use a destructor to free any resources managed by the pooled object.

+

The only requirement for the specified memory is, that it MUST be pooled memory by a UcxMempool or an element-compatible mempool. The pointer to the destructor function is saved in a reserved area before the actual memory.

+
Parameters
+ + + +
ptrpooled memory
funca pointer to the destructor function
+
+
+
See also
ucx_mempool_free()
+
+ucx_mempool_destroy()
+ +
+
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/mempool_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/mempool_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,97 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/mempool.h Source File + + + + + + + + + +
+
+ + + + + + + +
+
ucx +
+
UAP Common Extensions
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
mempool.h
+
+
+Go to the documentation of this file.
1 /*
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3  *
4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
38 #ifndef UCX_MEMPOOL_H
39 #define UCX_MEMPOOL_H
40 
41 #include "ucx.h"
42 #include "allocator.h"
43 #include <stddef.h>
44 
45 #ifdef __cplusplus
46 extern "C" {
47 #endif
48 
52 typedef struct {
54  UcxAllocator *allocator;
55 
57  void **data;
58 
60  size_t ndata;
61 
63  size_t size;
64 } UcxMempool;
65 
67 #define ucx_mempool_new_default() ucx_mempool_new(16)
68 
69 
81 UcxMempool *ucx_mempool_new(size_t n);
82 
93 int ucx_mempool_chcap(UcxMempool *pool, size_t newcap);
94 
103 void *ucx_mempool_malloc(UcxMempool *pool, size_t n);
115 void *ucx_mempool_calloc(UcxMempool *pool, size_t nelem, size_t elsize);
116 
129 void *ucx_mempool_realloc(UcxMempool *pool, void *ptr, size_t n);
130 
144 void ucx_mempool_free(UcxMempool *pool, void *ptr);
145 
160 void ucx_mempool_destroy(UcxMempool *pool);
161 
181 void ucx_mempool_set_destr(void *ptr, ucx_destructor func);
182 
202 void ucx_mempool_reg_destr(UcxMempool *pool, void *ptr, ucx_destructor destr);
203 
204 #ifdef __cplusplus
205 }
206 #endif
207 
208 #endif /* UCX_MEMPOOL_H */
209 
ucx_mempool_free
void ucx_mempool_free(UcxMempool *pool, void *ptr)
Frees pooled memory.
Definition: mempool.c:187
+
UcxMempool
UCX mempool structure.
Definition: mempool.h:52
+
ucx_mempool_destroy
void ucx_mempool_destroy(UcxMempool *pool)
Destroys a memory pool.
Definition: mempool.c:209
+
ucx.h
Main UCX Header providing most common definitions.
+
ucx_mempool_chcap
int ucx_mempool_chcap(UcxMempool *pool, size_t newcap)
Resizes a memory pool.
Definition: mempool.c:103
+
ucx_mempool_reg_destr
void ucx_mempool_reg_destr(UcxMempool *pool, void *ptr, ucx_destructor destr)
Registers a destructor function for the specified (non-pooled) memory.
Definition: mempool.c:229
+
ucx_mempool_malloc
void * ucx_mempool_malloc(UcxMempool *pool, size_t n)
Allocates pooled memory.
Definition: mempool.c:123
+
UcxMempool::size
size_t size
Memory pool size.
Definition: mempool.h:63
+
UcxMempool::ndata
size_t ndata
Count of pooled memory items.
Definition: mempool.h:60
+
UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88
+
ucx_mempool_calloc
void * ucx_mempool_calloc(UcxMempool *pool, size_t nelem, size_t elsize)
Allocates a pooled memory array.
Definition: mempool.c:148
+
UcxMempool::data
void ** data
List of pointers to pooled memory.
Definition: mempool.h:57
+
ucx_mempool_new
UcxMempool * ucx_mempool_new(size_t n)
Creates a memory pool with the specified initial size.
Definition: mempool.c:67
+
ucx_mempool_realloc
void * ucx_mempool_realloc(UcxMempool *pool, void *ptr, size_t n)
Reallocates pooled memory.
Definition: mempool.c:162
+
allocator.h
Allocator for custom memory management.
+
UcxMempool::allocator
UcxAllocator * allocator
UcxAllocator based on this pool.
Definition: mempool.h:54
+
ucx_mempool_set_destr
void ucx_mempool_set_destr(void *ptr, ucx_destructor func)
Sets a destructor function for the specified memory.
Definition: mempool.c:225
+
ucx_destructor
void(* ucx_destructor)(void *)
A function pointer to a destructor function.
Definition: ucx.h:72
+
+ +
+Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
+ + diff -r 92e482410453 -r d345541018fa docs/api-2.1/menu.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/menu.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ +function initMenu(relPath,searchEnabled,serverSide,searchPage,search) { + function makeTree(data,relPath) { + var result=''; + if ('children' in data) { + result+=''; + } + return result; + } + + $('#main-nav').append(makeTree(menudata,relPath)); + $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu'); + if (searchEnabled) { + if (serverSide) { + $('#main-menu').append('
    • '); + } else { + $('#main-menu').append('
    • '); + } + } + $('#main-menu').smartmenus(); +} diff -r 92e482410453 -r d345541018fa docs/api-2.1/menudata.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/menudata.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,69 @@ +var menudata={children:[ +{text:"Main Page",url:"index.html"}, +{text:"Data Structures",url:"annotated.html",children:[ +{text:"Data Structures",url:"annotated.html"}, +{text:"Data Structure Index",url:"classes.html"}, +{text:"Data Fields",url:"functions.html",children:[ +{text:"All",url:"functions.html",children:[ +{text:"a",url:"functions.html#index_a"}, +{text:"b",url:"functions.html#index_b"}, +{text:"c",url:"functions.html#index_c"}, +{text:"d",url:"functions.html#index_d"}, +{text:"e",url:"functions.html#index_e"}, +{text:"f",url:"functions.html#index_f"}, +{text:"h",url:"functions.html#index_h"}, +{text:"i",url:"functions.html#index_i"}, +{text:"k",url:"functions.html#index_k"}, +{text:"l",url:"functions.html#index_l"}, +{text:"m",url:"functions.html#index_m"}, +{text:"n",url:"functions.html#index_n"}, +{text:"p",url:"functions.html#index_p"}, +{text:"r",url:"functions.html#index_r"}, +{text:"s",url:"functions.html#index_s"}, +{text:"t",url:"functions.html#index_t"}, +{text:"u",url:"functions.html#index_u"}, +{text:"v",url:"functions.html#index_v"}, +{text:"w",url:"functions.html#index_w"}]}, +{text:"Variables",url:"functions_vars.html",children:[ +{text:"a",url:"functions_vars.html#index_a"}, +{text:"b",url:"functions_vars.html#index_b"}, +{text:"c",url:"functions_vars.html#index_c"}, +{text:"d",url:"functions_vars.html#index_d"}, +{text:"e",url:"functions_vars.html#index_e"}, +{text:"f",url:"functions_vars.html#index_f"}, +{text:"h",url:"functions_vars.html#index_h"}, +{text:"i",url:"functions_vars.html#index_i"}, +{text:"k",url:"functions_vars.html#index_k"}, +{text:"l",url:"functions_vars.html#index_l"}, +{text:"m",url:"functions_vars.html#index_m"}, +{text:"n",url:"functions_vars.html#index_n"}, +{text:"p",url:"functions_vars.html#index_p"}, +{text:"r",url:"functions_vars.html#index_r"}, +{text:"s",url:"functions_vars.html#index_s"}, +{text:"t",url:"functions_vars.html#index_t"}, +{text:"u",url:"functions_vars.html#index_u"}, +{text:"v",url:"functions_vars.html#index_v"}, +{text:"w",url:"functions_vars.html#index_w"}]}]}]}, +{text:"Files",url:"files.html",children:[ +{text:"File List",url:"files.html"}, +{text:"Globals",url:"globals.html",children:[ +{text:"All",url:"globals.html",children:[ +{text:"_",url:"globals.html#index__"}, +{text:"a",url:"globals_a.html#index_a"}, +{text:"c",url:"globals_c.html#index_c"}, +{text:"d",url:"globals_d.html#index_d"}, +{text:"p",url:"globals_p.html#index_p"}, +{text:"r",url:"globals_r.html#index_r"}, +{text:"s",url:"globals_s.html#index_s"}, +{text:"u",url:"globals_u.html#index_u"}, +{text:"w",url:"globals_w.html#index_w"}]}, +{text:"Functions",url:"globals_func.html",children:[ +{text:"s",url:"globals_func.html#index_s"}, +{text:"u",url:"globals_func_u.html#index_u"}]}, +{text:"Typedefs",url:"globals_type.html"}, +{text:"Macros",url:"globals_defs.html",children:[ +{text:"_",url:"globals_defs.html#index__"}, +{text:"a",url:"globals_defs.html#index_a"}, +{text:"p",url:"globals_defs.html#index_p"}, +{text:"s",url:"globals_defs.html#index_s"}, +{text:"u",url:"globals_defs.html#index_u"}]}]}]}]} diff -r 92e482410453 -r d345541018fa docs/api-2.1/nav_f.png Binary file docs/api-2.1/nav_f.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/nav_g.png Binary file docs/api-2.1/nav_g.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/nav_h.png Binary file docs/api-2.1/nav_h.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/open.png Binary file docs/api-2.1/open.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/properties_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/properties_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,393 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/properties.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Data Structures | +Functions
    +
    +
    properties.h File Reference
    +
    +
    + +

    Load / store utilities for properties files. +More...

    +
    #include "ucx.h"
    +#include "map.h"
    +
    +

    Go to the source code of this file.

    + + + + + +

    +Data Structures

    struct  UcxProperties
     UcxProperties object for parsing properties data. More...
     
    + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    UcxProperties * ucx_properties_new ()
     Constructs a new UcxProperties object. More...
     
    void ucx_properties_free (UcxProperties *prop)
     Destroys a UcxProperties object. More...
     
    void ucx_properties_fill (UcxProperties *prop, char *buf, size_t len)
     Sets the input buffer for the properties parser. More...
     
    int ucx_properties_next (UcxProperties *prop, sstr_t *name, sstr_t *value)
     Retrieves the next key/value-pair. More...
     
    int ucx_properties2map (UcxProperties *prop, UcxMap *map)
     Retrieves all available key/value-pairs and puts them into a UcxMap. More...
     
    int ucx_properties_load (UcxMap *map, FILE *file)
     Loads a properties file to a UcxMap. More...
     
    int ucx_properties_store (UcxMap *map, FILE *file)
     Stores a UcxMap to a file. More...
     
    +

    Detailed Description

    +

    Load / store utilities for properties files.

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Function Documentation

    + +

    ◆ ucx_properties2map()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int ucx_properties2map (UcxProperties * prop,
    UcxMap * map 
    )
    +
    + +

    Retrieves all available key/value-pairs and puts them into a UcxMap.

    +

    This is done by successive calls to ucx_properties_next() until no more key/value-pairs can be retrieved.

    +

    The memory for the map values is allocated by the map's own allocator.

    +
    Parameters
    + + + +
    propthe UcxProperties object
    mapthe target map
    +
    +
    +
    Returns
    The UcxProperties.error code (i.e. 0 on success).
    +
    See also
    ucx_properties_fill()
    +
    +UcxMap.allocator
    + +
    +
    + +

    ◆ ucx_properties_fill()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void ucx_properties_fill (UcxProperties * prop,
    char * buf,
    size_t len 
    )
    +
    + +

    Sets the input buffer for the properties parser.

    +

    After calling this function, you may parse the data by calling ucx_properties_next() until it returns 0. The function ucx_properties2map() is a convenience function that reads as much data as possible by using this function.

    +
    Parameters
    + + + + +
    propthe UcxProperties object
    bufa pointer to the new buffer
    lenthe payload length of the buffer
    +
    +
    +
    See also
    ucx_properties_next()
    +
    +ucx_properties2map()
    + +
    +
    + +

    ◆ ucx_properties_free()

    + +
    +
    + + + + + + + + +
    void ucx_properties_free (UcxProperties * prop)
    +
    + +

    Destroys a UcxProperties object.

    +
    Parameters
    + + +
    propthe UcxProperties object to destroy
    +
    +
    + +
    +
    + +

    ◆ ucx_properties_load()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int ucx_properties_load (UcxMap * map,
    FILE * file 
    )
    +
    + +

    Loads a properties file to a UcxMap.

    +

    This is a convenience function that reads data from an input stream until the end of the stream is reached.

    +
    Parameters
    + + + +
    mapthe map object to write the key/value-pairs to
    filethe FILE* stream to read from
    +
    +
    +
    Returns
    0 on success, or a non-zero value on error
    +
    See also
    ucx_properties_fill()
    +
    +ucx_properties2map()
    + +
    +
    + +

    ◆ ucx_properties_new()

    + +
    +
    + + + + + + + +
    UcxProperties* ucx_properties_new ()
    +
    + +

    Constructs a new UcxProperties object.

    +
    Returns
    a pointer to the new UcxProperties object
    + +
    +
    + +

    ◆ ucx_properties_next()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_properties_next (UcxProperties * prop,
    sstr_t * name,
    sstr_t * value 
    )
    +
    + +

    Retrieves the next key/value-pair.

    +

    This function returns a nonzero value as long as there are key/value-pairs found. If no more key/value-pairs are found, you may refill the input buffer with ucx_properties_fill().

    +

    Attention: the sstr_t.ptr pointers of the output parameters point to memory within the input buffer of the parser and will get invalid some time. If you want long term copies of the key/value-pairs, use sstrdup() after calling this function.

    +
    Parameters
    + + + + +
    propthe UcxProperties object
    namea pointer to the sstr_t that shall contain the property name
    valuea pointer to the sstr_t that shall contain the property value
    +
    +
    +
    Returns
    Nonzero, if a key/value-pair was successfully retrieved
    +
    See also
    ucx_properties_fill()
    + +
    +
    + +

    ◆ ucx_properties_store()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int ucx_properties_store (UcxMap * map,
    FILE * file 
    )
    +
    + +

    Stores a UcxMap to a file.

    +

    The key/value-pairs are written by using the following format:

    +

    [key] = [value]\n

    +
    Parameters
    + + + +
    mapthe map to store
    filethe FILE* stream to write to
    +
    +
    +
    Returns
    0 on success, or a non-zero value on error
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/properties_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/properties_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,102 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/properties.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    properties.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    37 #ifndef UCX_PROPERTIES_H
    38 #define UCX_PROPERTIES_H
    39 
    40 #include "ucx.h"
    41 #include "map.h"
    42 
    43 #ifdef __cplusplus
    44 extern "C" {
    45 #endif
    46 
    53 typedef struct {
    58  char *buffer;
    59 
    64  size_t buflen;
    65 
    70  size_t pos;
    71 
    76  char *tmp;
    77 
    82  size_t tmplen;
    83 
    88  size_t tmpcap;
    89 
    95  int error;
    96 
    101  char delimiter;
    102 
    107  char comment1;
    108 
    113  char comment2;
    114 
    119  char comment3;
    120 } UcxProperties;
    121 
    122 
    127 UcxProperties *ucx_properties_new();
    128 
    133 void ucx_properties_free(UcxProperties *prop);
    134 
    150 void ucx_properties_fill(UcxProperties *prop, char *buf, size_t len);
    151 
    170 int ucx_properties_next(UcxProperties *prop, sstr_t *name, sstr_t *value);
    171 
    186 int ucx_properties2map(UcxProperties *prop, UcxMap *map);
    187 
    201 int ucx_properties_load(UcxMap *map, FILE *file);
    202 
    214 int ucx_properties_store(UcxMap *map, FILE *file);
    215 
    216 #ifdef __cplusplus
    217 }
    218 #endif
    219 
    220 #endif /* UCX_PROPERTIES_H */
    221 
    sstr_t
    The UCX string structure.
    Definition: string.h:90
    +
    ucx_properties_new
    UcxProperties * ucx_properties_new()
    Constructs a new UcxProperties object.
    Definition: properties.c:35
    +
    UcxProperties::comment3
    char comment3
    The third comment character.
    Definition: properties.h:119
    +
    ucx.h
    Main UCX Header providing most common definitions.
    +
    UcxProperties::pos
    size_t pos
    Current buffer position (don&#39;t set manually).
    Definition: properties.h:70
    +
    UcxProperties::comment2
    char comment2
    The second comment character.
    Definition: properties.h:113
    +
    ucx_properties_load
    int ucx_properties_load(UcxMap *map, FILE *file)
    Loads a properties file to a UcxMap.
    Definition: properties.c:222
    +
    UcxProperties
    UcxProperties object for parsing properties data.
    Definition: properties.h:53
    +
    UcxProperties::buflen
    size_t buflen
    Length of the input buffer (don&#39;t set manually).
    Definition: properties.h:64
    +
    UcxProperties::buffer
    char * buffer
    Input buffer (don&#39;t set manually).
    Definition: properties.h:58
    +
    UcxProperties::error
    int error
    Parser error code.
    Definition: properties.h:95
    +
    UcxProperties::tmplen
    size_t tmplen
    Internal temporary buffer length (don&#39;t set manually).
    Definition: properties.h:82
    +
    UcxProperties::comment1
    char comment1
    The first comment character.
    Definition: properties.h:107
    +
    ucx_properties_next
    int ucx_properties_next(UcxProperties *prop, sstr_t *name, sstr_t *value)
    Retrieves the next key/value-pair.
    Definition: properties.c:80
    +
    ucx_properties2map
    int ucx_properties2map(UcxProperties *prop, UcxMap *map)
    Retrieves all available key/value-pairs and puts them into a UcxMap.
    Definition: properties.c:200
    +
    UcxProperties::delimiter
    char delimiter
    The delimiter that shall be used.
    Definition: properties.h:101
    +
    UcxProperties::tmp
    char * tmp
    Internal temporary buffer (don&#39;t set manually).
    Definition: properties.h:76
    +
    UcxMap
    Structure for the UCX map.
    Definition: map.h:81
    +
    UcxProperties::tmpcap
    size_t tmpcap
    Internal temporary buffer capacity (don&#39;t set manually).
    Definition: properties.h:88
    +
    map.h
    Hash map implementation.
    +
    ucx_properties_fill
    void ucx_properties_fill(UcxProperties *prop, char *buf, size_t len)
    Sets the input buffer for the properties parser.
    Definition: properties.c:64
    +
    ucx_properties_store
    int ucx_properties_store(UcxMap *map, FILE *file)
    Stores a UcxMap to a file.
    Definition: properties.c:242
    +
    ucx_properties_free
    void ucx_properties_free(UcxProperties *prop)
    Destroys a UcxProperties object.
    Definition: properties.c:57
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['_5f_5ffunction_5f_5f',['__FUNCTION__',['../test_8h.html#a828bb1dfda1afd67ca795075903d227d',1,'test.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,11 @@ +var searchData= +[ + ['alcalloc',['alcalloc',['../allocator_8h.html#a8d71470816f88f78cb9a9686c57e1b10',1,'allocator.h']]], + ['alfree',['alfree',['../allocator_8h.html#acd775785b54e97dc2b33a432c12c8fb2',1,'allocator.h']]], + ['allocator',['allocator',['../structUcxArray.html#a2ef31303b7548b9aa8e2b9187e295212',1,'UcxArray::allocator()'],['../structUcxAVLTree.html#a30652776b540156ad54c7d52833e4e28',1,'UcxAVLTree::allocator()'],['../structUcxMap.html#a531f3e481c1c331cf037b916192e974d',1,'UcxMap::allocator()'],['../structUcxMempool.html#ac45fd1e9269399e4c434d6bdaa770d92',1,'UcxMempool::allocator()'],['../structUcxStack.html#a33cda4f6890ac56ab31701598bc1ae10',1,'UcxStack::allocator()']]], + ['allocator_2eh',['allocator.h',['../allocator_8h.html',1,'']]], + ['almalloc',['almalloc',['../allocator_8h.html#ae1bc218fea8a35f4a3706f0beefcfb19',1,'allocator.h']]], + ['alrealloc',['alrealloc',['../allocator_8h.html#a029ee5c9bcbb3f873571553f788c5820',1,'allocator.h']]], + ['array_2eh',['array.h',['../array_8h.html',1,'']]], + ['avl_2eh',['avl.h',['../avl_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_10.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_10.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_10.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_10.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,10 @@ +var searchData= +[ + ['test',['test',['../structUcxTestList.html#a6022faa52e772b073141ca0a2f5a56c9',1,'UcxTestList']]], + ['test_2eh',['test.h',['../test_8h.html',1,'']]], + ['tests',['tests',['../structUcxTestSuite.html#a630677a70ebc2c3296704cda3196492b',1,'UcxTestSuite']]], + ['tmp',['tmp',['../structUcxProperties.html#a68556d4260153f58dde44e4c365edce6',1,'UcxProperties']]], + ['tmpcap',['tmpcap',['../structUcxProperties.html#a5af10131ea9f679b4ee174499f92e210',1,'UcxProperties']]], + ['tmplen',['tmplen',['../structUcxProperties.html#a8a81853d5903bee2f4e1fa53fdffae6e',1,'UcxProperties']]], + ['top',['top',['../structUcxStack.html#af0ff6f58edce469f17683013b86ade27',1,'UcxStack']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_11.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_11.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_11.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_11.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,271 @@ +var searchData= +[ + ['uap_20common_20extensions',['UAP Common Extensions',['../index.html',1,'']]], + ['ucx_2eh',['ucx.h',['../ucx_8h.html',1,'']]], + ['ucx_5fallocator_5fcalloc',['ucx_allocator_calloc',['../allocator_8h.html#a2c0aba4221c1ac6801f03ed799f15b12',1,'allocator.h']]], + ['ucx_5fallocator_5fdefault',['UCX_ALLOCATOR_DEFAULT',['../allocator_8h.html#a1283a8f875f90a7af3aba5e031fc2e3f',1,'allocator.h']]], + ['ucx_5fallocator_5ffree',['ucx_allocator_free',['../allocator_8h.html#aaf2387ddaddd8ab4b267e6b00e5d6f7e',1,'allocator.h']]], + ['ucx_5fallocator_5fmalloc',['ucx_allocator_malloc',['../allocator_8h.html#a29f0f6a23a70db3b60635cd6dc384473',1,'allocator.h']]], + ['ucx_5fallocator_5frealloc',['ucx_allocator_realloc',['../allocator_8h.html#a6d7cf038a806e327c5da37321d04e426',1,'allocator.h']]], + ['ucx_5farray_5fappend_5ffrom',['ucx_array_append_from',['../array_8h.html#aea01731ad94ea73c0c8fb1d1b7a35fcf',1,'array.c']]], + ['ucx_5farray_5fat',['ucx_array_at',['../array_8h.html#aa698085fd1a8b70d6b709999c51b49e8',1,'array.c']]], + ['ucx_5farray_5fclone',['ucx_array_clone',['../array_8h.html#a4a8c273370e4a3a3e2624e364f5ab410',1,'array.c']]], + ['ucx_5farray_5fconcat',['ucx_array_concat',['../array_8h.html#aa5a0bf3d3f0df6406beb0e569021cc28',1,'array.c']]], + ['ucx_5farray_5fcontains',['ucx_array_contains',['../array_8h.html#a5241058cd2329147bc5b1593ae7e51dc',1,'array.c']]], + ['ucx_5farray_5fdestroy',['ucx_array_destroy',['../array_8h.html#a8e83681d8d5d8cddbf10f63ce5be4c10',1,'array.c']]], + ['ucx_5farray_5fequals',['ucx_array_equals',['../array_8h.html#a43292b448adb1741677aa8c578bcc201',1,'array.c']]], + ['ucx_5farray_5ffind',['ucx_array_find',['../array_8h.html#ae7bdbed94afee9b20b38b95e3ab470f0',1,'array.c']]], + ['ucx_5farray_5ffree',['ucx_array_free',['../array_8h.html#ac01ee914468a16f470bf3071fffbe438',1,'array.c']]], + ['ucx_5farray_5fgrow',['ucx_array_grow',['../array_8h.html#ab0cbf243824aaebee48277315e03afce',1,'array.c']]], + ['ucx_5farray_5finit',['ucx_array_init',['../array_8h.html#ad921e85c28ffae32230777a53c5037e5',1,'array.c']]], + ['ucx_5farray_5finit_5fa',['ucx_array_init_a',['../array_8h.html#a2451e61ebb15a7ba1c1319267ba75b8c',1,'array.c']]], + ['ucx_5farray_5fnew',['ucx_array_new',['../array_8h.html#a994a2fbf1c33a3833e2a70cd9a4352b7',1,'array.c']]], + ['ucx_5farray_5fnew_5fa',['ucx_array_new_a',['../array_8h.html#a177170258c215eb2e4f5a32e59f0cb1b',1,'array.c']]], + ['ucx_5farray_5fprepend_5ffrom',['ucx_array_prepend_from',['../array_8h.html#a95b52acc2193b5c33cf0eaa4f2082477',1,'array.c']]], + ['ucx_5farray_5fremove',['ucx_array_remove',['../array_8h.html#aa45eac6b697f83adac81c0860cf306b8',1,'array.c']]], + ['ucx_5farray_5fremove_5ffast',['ucx_array_remove_fast',['../array_8h.html#a548d81b07612bae3ba8c4c4b49104b8e',1,'array.c']]], + ['ucx_5farray_5freserve',['ucx_array_reserve',['../array_8h.html#a1c3bf8433c1de3c933f3854ab297fe1d',1,'array.c']]], + ['ucx_5farray_5fresize',['ucx_array_resize',['../array_8h.html#a27762e7c06a6c781015e3c8ceeee0ce3',1,'array.c']]], + ['ucx_5farray_5fset_5ffrom',['ucx_array_set_from',['../array_8h.html#a1bb545d065358d265d80d815ba382a28',1,'array.c']]], + ['ucx_5farray_5fshrink',['ucx_array_shrink',['../array_8h.html#a2daf50e80aee9bccebee876a7efd2dfc',1,'array.c']]], + ['ucx_5farray_5fsort',['ucx_array_sort',['../array_8h.html#add773514569b872a6624381b4b6af52c',1,'array.c']]], + ['ucx_5farray_5futil_5fset',['ucx_array_util_set',['../array_8h.html#a1d959c29af3125bdd37cde3a554e729c',1,'array.h']]], + ['ucx_5farray_5futil_5fset_5fa',['ucx_array_util_set_a',['../array_8h.html#ad0a8d76980cf1c1910e64a245803fb9a',1,'array.c']]], + ['ucx_5farray_5futil_5fsetptr',['ucx_array_util_setptr',['../array_8h.html#a59a5b342965e790945f9c7a3f86b99f9',1,'array.h']]], + ['ucx_5farray_5futil_5fsetptr_5fa',['ucx_array_util_setptr_a',['../array_8h.html#ad708b333c0c1b02c998309a58ea65e31',1,'array.c']]], + ['ucx_5fasprintf',['ucx_asprintf',['../utils_8h.html#a9f9cf0e89ffdc256ecb35429907f51f5',1,'utils.c']]], + ['ucx_5favl_5fcount',['ucx_avl_count',['../avl_8h.html#a92c1d41c2b22fe4a029a486ab2153e35',1,'avl.c']]], + ['ucx_5favl_5fdefault_5fnew',['ucx_avl_default_new',['../avl_8h.html#ac2886d4b79b48c9fabf6408873f84cd2',1,'avl.h']]], + ['ucx_5favl_5ffind',['ucx_avl_find',['../avl_8h.html#a51770e1614b28d7d22dea096c3704f83',1,'avl.c']]], + ['ucx_5favl_5ffind_5fclosest',['UCX_AVL_FIND_CLOSEST',['../avl_8h.html#af16f24d74fd6af0154de041566c6603b',1,'avl.h']]], + ['ucx_5favl_5ffind_5fexact',['UCX_AVL_FIND_EXACT',['../avl_8h.html#aaaf4a6f6f661cda7791db239212285d9',1,'avl.h']]], + ['ucx_5favl_5ffind_5flower_5fbounded',['UCX_AVL_FIND_LOWER_BOUNDED',['../avl_8h.html#abd2446d544d5412b6997ee8a17bd368c',1,'avl.h']]], + ['ucx_5favl_5ffind_5fnode',['ucx_avl_find_node',['../avl_8h.html#a664986f64d6865605199fbff06e19cd5',1,'avl.c']]], + ['ucx_5favl_5ffind_5fupper_5fbounded',['UCX_AVL_FIND_UPPER_BOUNDED',['../avl_8h.html#ac74ee7649c1e206b08b31f37dd68ca5e',1,'avl.h']]], + ['ucx_5favl_5ffree',['ucx_avl_free',['../avl_8h.html#a2f92db538f25fce908d2cb3e5590944c',1,'avl.c']]], + ['ucx_5favl_5ffree_5fcontent',['ucx_avl_free_content',['../avl_8h.html#a31ad7fb196ca211f1fc39f4e15f72279',1,'avl.c']]], + ['ucx_5favl_5fget',['ucx_avl_get',['../avl_8h.html#adbcf7ceb3f014a30c7214f7304519efe',1,'avl.c']]], + ['ucx_5favl_5fget_5fnode',['ucx_avl_get_node',['../avl_8h.html#acf42da9a4168e47dc10b4ba0d27ceb4e',1,'avl.c']]], + ['ucx_5favl_5fnew',['ucx_avl_new',['../avl_8h.html#a11b043d65a11b7092d5d98b298e5ede3',1,'avl.c']]], + ['ucx_5favl_5fnew_5fa',['ucx_avl_new_a',['../avl_8h.html#af0f868d67e9dc08b4867c02a06c23ee2',1,'avl.c']]], + ['ucx_5favl_5fpred',['ucx_avl_pred',['../avl_8h.html#a0e739aeb66dda6a6a3f6eb51b50cf346',1,'avl.c']]], + ['ucx_5favl_5fput',['ucx_avl_put',['../avl_8h.html#aec401fab4a24a7edffa734f9baf88577',1,'avl.c']]], + ['ucx_5favl_5fput_5fs',['ucx_avl_put_s',['../avl_8h.html#a32cf8955cc0226a82bacfc7b76d6474c',1,'avl.c']]], + ['ucx_5favl_5fremove',['ucx_avl_remove',['../avl_8h.html#a1d821119c805d7fbb7e424bc3effeba9',1,'avl.c']]], + ['ucx_5favl_5fremove_5fnode',['ucx_avl_remove_node',['../avl_8h.html#a9a792b7d9e58073deef74a341f8bc720',1,'avl.c']]], + ['ucx_5favl_5fremove_5fs',['ucx_avl_remove_s',['../avl_8h.html#a01aeeecd6415f0cc2b623486eb28f254',1,'avl.c']]], + ['ucx_5favl_5fsucc',['ucx_avl_succ',['../avl_8h.html#aab1ad9b027ff5e50671aa0ee84e2d541',1,'avl.c']]], + ['ucx_5fbprintf',['ucx_bprintf',['../utils_8h.html#a9d7d65a420f026fcb6982803d5120519',1,'utils.h']]], + ['ucx_5fbuffer_5fautoextend',['UCX_BUFFER_AUTOEXTEND',['../buffer_8h.html#a05f9565f2d04399168c3b1c152a632be',1,'buffer.h']]], + ['ucx_5fbuffer_5fautofree',['UCX_BUFFER_AUTOFREE',['../buffer_8h.html#a8bab11ad8a76719228b9ee91e2e45535',1,'buffer.h']]], + ['ucx_5fbuffer_5fclear',['ucx_buffer_clear',['../buffer_8h.html#a374abd5aabfcc3ee0777a79d5fe651ab',1,'buffer.h']]], + ['ucx_5fbuffer_5fclone',['ucx_buffer_clone',['../buffer_8h.html#a828353846428c2c2f695f9938f059e52',1,'buffer.h']]], + ['ucx_5fbuffer_5fdefault',['UCX_BUFFER_DEFAULT',['../buffer_8h.html#acc77c8ed7b26854f555d4a5d11e49ea2',1,'buffer.h']]], + ['ucx_5fbuffer_5feof',['ucx_buffer_eof',['../buffer_8h.html#abad7fd9ad5061224c780b8d1d4c55f09',1,'buffer.c']]], + ['ucx_5fbuffer_5fextend',['ucx_buffer_extend',['../buffer_8h.html#afaf97d2cd7e9faad79a9d35fe33e30c6',1,'buffer.c']]], + ['ucx_5fbuffer_5fextract',['ucx_buffer_extract',['../buffer_8h.html#a33fa7bb35fe08bbb3542f227514332ef',1,'buffer.c']]], + ['ucx_5fbuffer_5ffree',['ucx_buffer_free',['../buffer_8h.html#a2af8646d8905c22c7322e7540b0440af',1,'buffer.c']]], + ['ucx_5fbuffer_5fgetc',['ucx_buffer_getc',['../buffer_8h.html#a396339022159ce4ca6d069de9f9209b0',1,'buffer.c']]], + ['ucx_5fbuffer_5fnew',['ucx_buffer_new',['../buffer_8h.html#aacea876d692193ec6f859ce98da7351c',1,'buffer.c']]], + ['ucx_5fbuffer_5fputc',['ucx_buffer_putc',['../buffer_8h.html#a7d6f01b9d631b0123475dfb98fb849ac',1,'buffer.c']]], + ['ucx_5fbuffer_5fputs',['ucx_buffer_puts',['../buffer_8h.html#af1d4b478e04b3ae0bf30e7c2ea964ea2',1,'buffer.c']]], + ['ucx_5fbuffer_5fread',['ucx_buffer_read',['../buffer_8h.html#ae5c3430759f0059547b35d5a254d4da5',1,'buffer.c']]], + ['ucx_5fbuffer_5fseek',['ucx_buffer_seek',['../buffer_8h.html#a47d98482662073c74f35deb0957d15d1',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift',['ucx_buffer_shift',['../buffer_8h.html#a12a0c6a2379ef080043e6286bb8bad69',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift_5fleft',['ucx_buffer_shift_left',['../buffer_8h.html#a20431dd0ed6a6fe9f15333bd72afe4db',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift_5fright',['ucx_buffer_shift_right',['../buffer_8h.html#a4fa10b6471495547eb981248fd4f1bc2',1,'buffer.c']]], + ['ucx_5fbuffer_5fto_5fsstr',['ucx_buffer_to_sstr',['../buffer_8h.html#a0f4b64f1b3a74c4f6c5d9409d6b6086a',1,'buffer.h']]], + ['ucx_5fbuffer_5fwrite',['ucx_buffer_write',['../buffer_8h.html#af8aacc7401814392b58c1b7b81bffc05',1,'buffer.c']]], + ['ucx_5fcmp_5fdouble',['ucx_cmp_double',['../utils_8h.html#ab804b7c27d0bfcd7bf3a3583140825b6',1,'utils.c']]], + ['ucx_5fcmp_5ffloat',['ucx_cmp_float',['../utils_8h.html#ad1196b561bcdad76c393885819769a97',1,'utils.c']]], + ['ucx_5fcmp_5fint',['ucx_cmp_int',['../utils_8h.html#a8ce7e11e6b3deafe89a32a091fde7f16',1,'utils.c']]], + ['ucx_5fcmp_5fint16',['ucx_cmp_int16',['../utils_8h.html#aa29e6e559946375e34113e34e0b0bd0d',1,'utils.c']]], + ['ucx_5fcmp_5fint32',['ucx_cmp_int32',['../utils_8h.html#a858b2ac443fb202643b71f6a7e9218dd',1,'utils.c']]], + ['ucx_5fcmp_5fint64',['ucx_cmp_int64',['../utils_8h.html#a54701aea6a89fed1402dfb0bf56bc7f6',1,'utils.c']]], + ['ucx_5fcmp_5flongint',['ucx_cmp_longint',['../utils_8h.html#aeb57a2b9a6aaa0460c7a6bec29accf2c',1,'utils.c']]], + ['ucx_5fcmp_5flonglong',['ucx_cmp_longlong',['../utils_8h.html#a366b57def20f86a41eaedf575eea5375',1,'utils.c']]], + ['ucx_5fcmp_5fmem',['ucx_cmp_mem',['../utils_8h.html#aff7d2bcded71196831a8c0664333f8e7',1,'utils.c']]], + ['ucx_5fcmp_5fptr',['ucx_cmp_ptr',['../utils_8h.html#aa174d539de3ea59be4f9640f17ce53d8',1,'utils.c']]], + ['ucx_5fcmp_5fsstr',['ucx_cmp_sstr',['../utils_8h.html#adee0739589166d272f8cb7c23aabf8ba',1,'utils.c']]], + ['ucx_5fcmp_5fstr',['ucx_cmp_str',['../utils_8h.html#aa6a37b9d172b6a5b2803d152f9e1b258',1,'utils.c']]], + ['ucx_5fcmp_5fstrn',['ucx_cmp_strn',['../utils_8h.html#ac6b354a878f551a3a5b20a167db3f308',1,'utils.c']]], + ['ucx_5fcmp_5fuint',['ucx_cmp_uint',['../utils_8h.html#abd83a5da91c3dd026a6931bd80c12f1e',1,'utils.c']]], + ['ucx_5fcmp_5fuint16',['ucx_cmp_uint16',['../utils_8h.html#acde5366437e886a459b7468f7a9e11f0',1,'utils.c']]], + ['ucx_5fcmp_5fuint32',['ucx_cmp_uint32',['../utils_8h.html#a5879d1722330355914d8c9146fa549d3',1,'utils.c']]], + ['ucx_5fcmp_5fuint64',['ucx_cmp_uint64',['../utils_8h.html#a1572a78b5b42f7151a5b2a5a7283d62d',1,'utils.c']]], + ['ucx_5fcmp_5fulongint',['ucx_cmp_ulongint',['../utils_8h.html#a3f3cbae2594d6f722bae29acb0408a24',1,'utils.c']]], + ['ucx_5fcmp_5fulonglong',['ucx_cmp_ulonglong',['../utils_8h.html#a6acfc359421f21f9a042a654ff7faac5',1,'utils.c']]], + ['ucx_5fdefault_5fallocator',['ucx_default_allocator',['../allocator_8h.html#a98d2f1b341118b7a0e341fda5d8b2ebf',1,'allocator.c']]], + ['ucx_5fdefault_5fcalloc',['ucx_default_calloc',['../allocator_8h.html#a3a0bfdd13d887012309c459b339f338f',1,'allocator.c']]], + ['ucx_5fdefault_5ffree',['ucx_default_free',['../allocator_8h.html#a646d83aaaadfe33ae414c0fad8bfc52a',1,'allocator.c']]], + ['ucx_5fdefault_5fmalloc',['ucx_default_malloc',['../allocator_8h.html#a96403ebf3d2312d95f2fe7627a1cdbc0',1,'allocator.c']]], + ['ucx_5fdefault_5frealloc',['ucx_default_realloc',['../allocator_8h.html#a47cfc8af626a86fcb93a2b14b90498ed',1,'allocator.c']]], + ['ucx_5fdestructor',['ucx_destructor',['../ucx_8h.html#ad2b370c2809914c8b7fedab163c266b3',1,'ucx.h']]], + ['ucx_5fdist_5fint',['ucx_dist_int',['../utils_8h.html#a4ab6753739d56c09cdf6079fdcabf7c6',1,'utils.c']]], + ['ucx_5fdist_5fint16',['ucx_dist_int16',['../utils_8h.html#a81fb8434b70ca11bf2c14abfa21d16a9',1,'utils.c']]], + ['ucx_5fdist_5fint32',['ucx_dist_int32',['../utils_8h.html#ab4a659cc46096f0490c1dafa57726476',1,'utils.c']]], + ['ucx_5fdist_5fint64',['ucx_dist_int64',['../utils_8h.html#a54e7d06585bad3a899befc4e9c13853f',1,'utils.c']]], + ['ucx_5fdist_5flongint',['ucx_dist_longint',['../utils_8h.html#a43e73d288b1553a0078bf4c98dd341f5',1,'utils.c']]], + ['ucx_5fdist_5flonglong',['ucx_dist_longlong',['../utils_8h.html#a306778414a2427951ea263be92368627',1,'utils.c']]], + ['ucx_5fdist_5fuint',['ucx_dist_uint',['../utils_8h.html#a37b7d471ca1679992afc11a0deda45f4',1,'utils.c']]], + ['ucx_5fdist_5fuint16',['ucx_dist_uint16',['../utils_8h.html#a66e00a0703cbcde050ec922578e2f080',1,'utils.c']]], + ['ucx_5fdist_5fuint32',['ucx_dist_uint32',['../utils_8h.html#add2b5c5507caba59d894b84e056b079b',1,'utils.c']]], + ['ucx_5fdist_5fuint64',['ucx_dist_uint64',['../utils_8h.html#a3ba75e2e0b2479eef2b22fb219b42da7',1,'utils.c']]], + ['ucx_5fdist_5fulongint',['ucx_dist_ulongint',['../utils_8h.html#abb13476228d0c16bfaba08469adbae2d',1,'utils.c']]], + ['ucx_5fdist_5fulonglong',['ucx_dist_ulonglong',['../utils_8h.html#a59a5859272cb4b43cbdd58208c41e32b',1,'utils.c']]], + ['ucx_5fforeach',['UCX_FOREACH',['../list_8h.html#a4b143b6526a410aa4d22cb3bb9365d70',1,'list.h']]], + ['ucx_5ffprintf',['ucx_fprintf',['../utils_8h.html#aa0bec80e1c67f769ff5e112a7d4ce72a',1,'utils.c']]], + ['ucx_5fhash',['ucx_hash',['../map_8h.html#aea3be97254c05595d986ef6a9faae87b',1,'map.c']]], + ['ucx_5fkey',['ucx_key',['../map_8h.html#a3e540bb46b8ee19789aed63fd8919200',1,'map.c']]], + ['ucx_5flist_5fappend',['ucx_list_append',['../list_8h.html#a00c122c8a26d35b60676939df4161621',1,'list.c']]], + ['ucx_5flist_5fappend_5fa',['ucx_list_append_a',['../list_8h.html#adf3b3e2e0ff977d8928671d6bd82fc60',1,'list.c']]], + ['ucx_5flist_5fclone',['ucx_list_clone',['../list_8h.html#ae7054a41c289b24e6caf5cb07ac850ed',1,'list.c']]], + ['ucx_5flist_5fclone_5fa',['ucx_list_clone_a',['../list_8h.html#a08ca1ba0d2e82258b0408714c1f4c425',1,'list.c']]], + ['ucx_5flist_5fconcat',['ucx_list_concat',['../list_8h.html#a77163a0cc82fae52bec26c8c0c3674d9',1,'list.c']]], + ['ucx_5flist_5fcontains',['ucx_list_contains',['../list_8h.html#a8b0fa051fcfe12e1a82cca1087973852',1,'list.c']]], + ['ucx_5flist_5fdifference',['ucx_list_difference',['../list_8h.html#a6c5db5d1d11ad28b6fe1a80ee1c1e449',1,'list.c']]], + ['ucx_5flist_5fdifference_5fa',['ucx_list_difference_a',['../list_8h.html#a4a2a2fc5cc41073c516db6235bbc51d5',1,'list.c']]], + ['ucx_5flist_5fequals',['ucx_list_equals',['../list_8h.html#adc435447cecf885bc63d232191085bbe',1,'list.c']]], + ['ucx_5flist_5ffind',['ucx_list_find',['../list_8h.html#a9b3b6842d3be572e06a7f519e198cb83',1,'list.c']]], + ['ucx_5flist_5ffirst',['ucx_list_first',['../list_8h.html#a6aa0e34ebc5f0dca6f52d0f7626b4bd5',1,'list.c']]], + ['ucx_5flist_5ffree',['ucx_list_free',['../list_8h.html#a1a0fa2c5b1e478a96da19b0c3f013668',1,'list.c']]], + ['ucx_5flist_5ffree_5fa',['ucx_list_free_a',['../list_8h.html#a944e11f76c38767cd1100d72a4e3b25b',1,'list.c']]], + ['ucx_5flist_5ffree_5fcontent',['ucx_list_free_content',['../list_8h.html#a4ba6c96642f72ea046cc22627c72979c',1,'list.c']]], + ['ucx_5flist_5fget',['ucx_list_get',['../list_8h.html#a2509ffe19bce6a8708c77f89480c75fb',1,'list.c']]], + ['ucx_5flist_5findexof',['ucx_list_indexof',['../list_8h.html#ae2ff2974812ca185870f80bc4ed9337e',1,'list.c']]], + ['ucx_5flist_5fintersection',['ucx_list_intersection',['../list_8h.html#a259f9b754978aeca23dfabba16e20f39',1,'list.c']]], + ['ucx_5flist_5fintersection_5fa',['ucx_list_intersection_a',['../list_8h.html#a1d0b00514dbb81ba6270b58da0c5b9a8',1,'list.c']]], + ['ucx_5flist_5flast',['ucx_list_last',['../list_8h.html#add5ec40c5006e29c629d23c2eb5a6553',1,'list.c']]], + ['ucx_5flist_5fprepend',['ucx_list_prepend',['../list_8h.html#a8fcb68e4556395b15180eec2d0b77aa4',1,'list.c']]], + ['ucx_5flist_5fprepend_5fa',['ucx_list_prepend_a',['../list_8h.html#a54654e6dc60e1c3de9e886c150e404ec',1,'list.c']]], + ['ucx_5flist_5fremove',['ucx_list_remove',['../list_8h.html#a410cb3e8260037ba56c72d14b899b468',1,'list.c']]], + ['ucx_5flist_5fremove_5fa',['ucx_list_remove_a',['../list_8h.html#aca687b7c4e7170175f447e549125aa52',1,'list.c']]], + ['ucx_5flist_5fsize',['ucx_list_size',['../list_8h.html#ae88001cc8ae40b946560f31434abed8f',1,'list.c']]], + ['ucx_5flist_5fsort',['ucx_list_sort',['../list_8h.html#ac74962d9bd7cfc9d3e2e09651469377b',1,'list.c']]], + ['ucx_5flist_5funion',['ucx_list_union',['../list_8h.html#a94ecdb0cea1633ad7074f027fa8485fa',1,'list.c']]], + ['ucx_5flist_5funion_5fa',['ucx_list_union_a',['../list_8h.html#a65b4355536f4ebc4130211b46469f4c1',1,'list.c']]], + ['ucx_5flogger_5fdebug',['ucx_logger_debug',['../logging_8h.html#a2936402799892db5138e5f1f8c25db0c',1,'ucx_logger_debug(): logging.h'],['../logging_8h.html#acff01d1ef919ea997cfce755fc1b83d8',1,'UCX_LOGGER_DEBUG(): logging.h']]], + ['ucx_5flogger_5ferror',['ucx_logger_error',['../logging_8h.html#a6a9e472e14d6768e59d96d245e065397',1,'ucx_logger_error(): logging.h'],['../logging_8h.html#aa254c07fe3a907613e2256a318d5c9a8',1,'UCX_LOGGER_ERROR(): logging.h']]], + ['ucx_5flogger_5ffree',['ucx_logger_free',['../logging_8h.html#ac4697b784e01ec990d2acea192e21658',1,'logging.c']]], + ['ucx_5flogger_5finfo',['UCX_LOGGER_INFO',['../logging_8h.html#a4b0178bf60a6129373ffc59114ca4c9b',1,'UCX_LOGGER_INFO(): logging.h'],['../logging_8h.html#a98464d8d51376ce2716dcc4eca00d5da',1,'ucx_logger_info(): logging.h']]], + ['ucx_5flogger_5flevel',['UCX_LOGGER_LEVEL',['../logging_8h.html#aee18bc20e58ffb69910121512c350839',1,'logging.h']]], + ['ucx_5flogger_5flog',['ucx_logger_log',['../logging_8h.html#aa0245325031d95799b28def177fd14ec',1,'logging.h']]], + ['ucx_5flogger_5flogf',['ucx_logger_logf',['../logging_8h.html#ac337e5d02ebea565012d4c11bd643801',1,'logging.c']]], + ['ucx_5flogger_5fnew',['ucx_logger_new',['../logging_8h.html#ac560f8517d2172794c9d2691735ec48c',1,'logging.c']]], + ['ucx_5flogger_5fregister_5flevel',['ucx_logger_register_level',['../logging_8h.html#a5cffc19502c4c90bfb3bd3bbcd18170a',1,'logging.h']]], + ['ucx_5flogger_5fsource',['UCX_LOGGER_SOURCE',['../logging_8h.html#a0e0d72b12616c1e49ff8834eaf4cb8a2',1,'logging.h']]], + ['ucx_5flogger_5ftimestamp',['UCX_LOGGER_TIMESTAMP',['../logging_8h.html#a38607008268b4f776ee500fb95d2e823',1,'logging.h']]], + ['ucx_5flogger_5ftrace',['UCX_LOGGER_TRACE',['../logging_8h.html#a55b88d1fec7036d841b3ddd6195c5586',1,'UCX_LOGGER_TRACE(): logging.h'],['../logging_8h.html#a3031b7ff13f4cfae9c2916543be2877c',1,'ucx_logger_trace(): logging.h']]], + ['ucx_5flogger_5fwarn',['UCX_LOGGER_WARN',['../logging_8h.html#abd01ca11486226ba34e8f7028d9fffba',1,'UCX_LOGGER_WARN(): logging.h'],['../logging_8h.html#aca7bd861b646892813fd7310c0aa69af',1,'ucx_logger_warn(): logging.h']]], + ['ucx_5fmap_5fclear',['ucx_map_clear',['../map_8h.html#a285e90e40681c6d9631c935dda0967f2',1,'map.c']]], + ['ucx_5fmap_5fclone',['ucx_map_clone',['../map_8h.html#a62c6c30cbb0d824ba710f5030ff9a4e4',1,'map.c']]], + ['ucx_5fmap_5fclone_5fa',['ucx_map_clone_a',['../map_8h.html#a9aea9103703d5c168420bb6bf85549ea',1,'map.c']]], + ['ucx_5fmap_5fcopy',['ucx_map_copy',['../map_8h.html#adfeb2d61003fd2896bcfdc9a57f36425',1,'map.c']]], + ['ucx_5fmap_5fcstr_5fget',['ucx_map_cstr_get',['../map_8h.html#a64e1fb55498fa502dd2ed8ed69062cdd',1,'map.h']]], + ['ucx_5fmap_5fcstr_5fput',['ucx_map_cstr_put',['../map_8h.html#ad9356b01425b934ab237b52339ac0cc3',1,'map.h']]], + ['ucx_5fmap_5fcstr_5fremove',['ucx_map_cstr_remove',['../map_8h.html#a9c4405a5a75ecf64e2ef3d0c6501a9fe',1,'map.h']]], + ['ucx_5fmap_5fdifference',['ucx_map_difference',['../map_8h.html#a774fcff87d1e58b6c5af77dd19a8c3dc',1,'map.c']]], + ['ucx_5fmap_5fdifference_5fa',['ucx_map_difference_a',['../map_8h.html#ad0ba103494247d798ac3037c50fc8831',1,'map.c']]], + ['ucx_5fmap_5fforeach',['UCX_MAP_FOREACH',['../map_8h.html#a940896c4aa1b13e54c55c04c3efc186b',1,'map.h']]], + ['ucx_5fmap_5ffree',['ucx_map_free',['../map_8h.html#abe3d9688e4224bf7bb962abf25ff8c2e',1,'map.c']]], + ['ucx_5fmap_5ffree_5fcontent',['ucx_map_free_content',['../map_8h.html#a750f3d9d83e2f3788a14c17a9d160618',1,'map.c']]], + ['ucx_5fmap_5fget',['ucx_map_get',['../map_8h.html#ab61192c5af2e06ecb9ad73880d1c95a6',1,'map.c']]], + ['ucx_5fmap_5fint_5fget',['ucx_map_int_get',['../map_8h.html#aa1681bd2178553cd092fd24c4d681d3c',1,'map.h']]], + ['ucx_5fmap_5fint_5fput',['ucx_map_int_put',['../map_8h.html#aaa30af79b4068c923895619e83f44367',1,'map.h']]], + ['ucx_5fmap_5fint_5fremove',['ucx_map_int_remove',['../map_8h.html#aa767958b5468737755c09f7185b1770c',1,'map.h']]], + ['ucx_5fmap_5fintersection',['ucx_map_intersection',['../map_8h.html#aa594d7a5afebc3bed6bb265348cf6b0d',1,'map.c']]], + ['ucx_5fmap_5fintersection_5fa',['ucx_map_intersection_a',['../map_8h.html#a169e0470a20484dd76425fdf77e3651e',1,'map.c']]], + ['ucx_5fmap_5fiter_5fnext',['ucx_map_iter_next',['../map_8h.html#aceb8675abf44860b4bbc301bbada5b91',1,'map.c']]], + ['ucx_5fmap_5fiterator',['ucx_map_iterator',['../map_8h.html#a9150e9c64fdf4dfcc2cad106b91aa110',1,'map.c']]], + ['ucx_5fmap_5fnew',['ucx_map_new',['../map_8h.html#a79f31de8b93814493759dbc8b940cf0c',1,'map.c']]], + ['ucx_5fmap_5fnew_5fa',['ucx_map_new_a',['../map_8h.html#aed508a94c66cc15372503c64b70eb03e',1,'map.c']]], + ['ucx_5fmap_5fput',['ucx_map_put',['../map_8h.html#ac04a08b604217070254d4c58f0e82498',1,'map.c']]], + ['ucx_5fmap_5frehash',['ucx_map_rehash',['../map_8h.html#a174bce9fad554dd92b8da354e0d32512',1,'map.c']]], + ['ucx_5fmap_5fremove',['ucx_map_remove',['../map_8h.html#a17248a4888eb8f9ae18be522d64632aa',1,'map.c']]], + ['ucx_5fmap_5fsstr_5fget',['ucx_map_sstr_get',['../map_8h.html#a14d385f6b7f371f0507861cabd2eab4e',1,'map.h']]], + ['ucx_5fmap_5fsstr_5fput',['ucx_map_sstr_put',['../map_8h.html#ac26a8615bfc8f47ee9eaceb47645f98e',1,'map.h']]], + ['ucx_5fmap_5fsstr_5fremove',['ucx_map_sstr_remove',['../map_8h.html#a48700ea86fadb9ea54d13010f9124df2',1,'map.h']]], + ['ucx_5fmap_5funion',['ucx_map_union',['../map_8h.html#a3f65978c481af7f637cad021d93522d5',1,'map.c']]], + ['ucx_5fmap_5funion_5fa',['ucx_map_union_a',['../map_8h.html#ab6370c3fa8113fdad593ce4b0460c9c6',1,'map.c']]], + ['ucx_5fmemchunk',['ucx_memchunk',['../structucx__memchunk.html',1,'']]], + ['ucx_5fmemcpy',['ucx_memcpy',['../utils_8h.html#ab2e184e6a744941aab6b8058116baf30',1,'utils.c']]], + ['ucx_5fmempool_5fcalloc',['ucx_mempool_calloc',['../mempool_8h.html#a4b9142011824ae24f00fabe128417d69',1,'mempool.c']]], + ['ucx_5fmempool_5fchcap',['ucx_mempool_chcap',['../mempool_8h.html#aaf75b5016098723a9280531ccc3a6d77',1,'mempool.c']]], + ['ucx_5fmempool_5fdestroy',['ucx_mempool_destroy',['../mempool_8h.html#af096378da7e9bfbed3088497cf4c15bf',1,'mempool.c']]], + ['ucx_5fmempool_5ffree',['ucx_mempool_free',['../mempool_8h.html#aefa26e3015f5aefadbfc74221bd246ac',1,'mempool.c']]], + ['ucx_5fmempool_5fmalloc',['ucx_mempool_malloc',['../mempool_8h.html#a2ae492b8f2878ccc9837ac213dced11e',1,'mempool.c']]], + ['ucx_5fmempool_5fnew',['ucx_mempool_new',['../mempool_8h.html#ad71cb8c3b6fdb30360376a8b372ef22a',1,'mempool.c']]], + ['ucx_5fmempool_5fnew_5fdefault',['ucx_mempool_new_default',['../mempool_8h.html#a49f7bd1da5ac201d0cf54dc0f0d82dd2',1,'mempool.h']]], + ['ucx_5fmempool_5frealloc',['ucx_mempool_realloc',['../mempool_8h.html#a660ef42520ed6737c2e77aae18e3a7a4',1,'mempool.c']]], + ['ucx_5fmempool_5freg_5fdestr',['ucx_mempool_reg_destr',['../mempool_8h.html#af47b6b7c40f8f263dc28cc9a4e77b27c',1,'mempool.c']]], + ['ucx_5fmempool_5fset_5fdestr',['ucx_mempool_set_destr',['../mempool_8h.html#adb788e7ec24cd7dbdea6381539c549f2',1,'mempool.c']]], + ['ucx_5fproperties2map',['ucx_properties2map',['../properties_8h.html#a5c7ff8bc3139960a3f3dc92072b742f3',1,'properties.c']]], + ['ucx_5fproperties_5ffill',['ucx_properties_fill',['../properties_8h.html#aaf8de121764a4d22c763ff2ab41f3a4d',1,'properties.c']]], + ['ucx_5fproperties_5ffree',['ucx_properties_free',['../properties_8h.html#a38a2fe7bb2986bd87c7e69356ab05c05',1,'properties.c']]], + ['ucx_5fproperties_5fload',['ucx_properties_load',['../properties_8h.html#ae1b600f839a6b2278b68fc314981a8a3',1,'properties.c']]], + ['ucx_5fproperties_5fnew',['ucx_properties_new',['../properties_8h.html#a44d9dd12cab3aaa0084f1c8b89405796',1,'properties.c']]], + ['ucx_5fproperties_5fnext',['ucx_properties_next',['../properties_8h.html#a7e03bc573d45d48c538cd721e810d33c',1,'properties.c']]], + ['ucx_5fproperties_5fstore',['ucx_properties_store',['../properties_8h.html#a63c0c1b7648e675b21a1788917ff36fb',1,'properties.c']]], + ['ucx_5fregdestr',['ucx_regdestr',['../structucx__regdestr.html',1,'']]], + ['ucx_5fsc2sc',['ucx_sc2sc',['../string_8h.html#a69d5e3eeec783cc43314df71248768f5',1,'string.c']]], + ['ucx_5fsprintf',['ucx_sprintf',['../utils_8h.html#af9f333b66ecd639c347c7235f4992e2e',1,'utils.h']]], + ['ucx_5fss2c_5fs',['ucx_ss2c_s',['../string_8h.html#aedeb5d7bddda54116101a8d68af8c56d',1,'string.h']]], + ['ucx_5fss2sc',['ucx_ss2sc',['../string_8h.html#a9ce5ad1b2aa2dbeba204d452c2e64359',1,'string.c']]], + ['ucx_5fstack_5favail',['ucx_stack_avail',['../stack_8h.html#a53cd2c7743dc8ad9cbd35ade0b4873e7',1,'stack.c']]], + ['ucx_5fstack_5fcalloc',['ucx_stack_calloc',['../stack_8h.html#afdc467524b5e19a9a777c6bc03e17174',1,'stack.c']]], + ['ucx_5fstack_5fdim',['ucx_stack_dim',['../stack_8h.html#a3b761343c6491222604341ebfa443226',1,'stack.h']]], + ['ucx_5fstack_5fempty',['ucx_stack_empty',['../stack_8h.html#a4f7239dbd6c032c56812e370b71c1985',1,'stack.h']]], + ['ucx_5fstack_5ffree',['ucx_stack_free',['../stack_8h.html#aabd55c14a3866b3782ba324f4d8b4c41',1,'stack.c']]], + ['ucx_5fstack_5finit',['ucx_stack_init',['../stack_8h.html#abaef685df4e7ef95cd7218984a0618fe',1,'stack.c']]], + ['ucx_5fstack_5fmalloc',['ucx_stack_malloc',['../stack_8h.html#af865b416802140f6b6e8ab3626d7d1ac',1,'stack.c']]], + ['ucx_5fstack_5fmetadata',['ucx_stack_metadata',['../structucx__stack__metadata.html',1,'']]], + ['ucx_5fstack_5fpop',['ucx_stack_pop',['../stack_8h.html#a506b82374734ec476d086ddfb561174d',1,'stack.h']]], + ['ucx_5fstack_5fpopn',['ucx_stack_popn',['../stack_8h.html#a07ea48f28eab474dcfefbb86fa66ef81',1,'stack.c']]], + ['ucx_5fstack_5fpush',['ucx_stack_push',['../stack_8h.html#af85e6f77a8341beb6188f9ae1a8e9f92',1,'stack.c']]], + ['ucx_5fstack_5fpusharr',['ucx_stack_pusharr',['../stack_8h.html#a7bb138979191bba138e76ea37488fae2',1,'stack.c']]], + ['ucx_5fstack_5frealloc',['ucx_stack_realloc',['../stack_8h.html#a0c678f96f6fabab49b2b034a1fe91c3a',1,'stack.c']]], + ['ucx_5fstack_5ftopsize',['ucx_stack_topsize',['../stack_8h.html#a030197051a803e87d5eeac5adb80b15a',1,'stack.h']]], + ['ucx_5fstrcpy',['ucx_strcpy',['../utils_8h.html#adeb6e8d0a53a829207cfa0a979d01fff',1,'utils.c']]], + ['ucx_5fstream_5fbcopy',['ucx_stream_bcopy',['../utils_8h.html#a6003a1750a66234169bd1f8cc84b297b',1,'utils.h']]], + ['ucx_5fstream_5fbncopy',['ucx_stream_bncopy',['../utils_8h.html#a114ee7f7da62656ffd35e2dc23394201',1,'utils.c']]], + ['ucx_5fstream_5fcopy',['ucx_stream_copy',['../utils_8h.html#a41ca1344f781c0d3bf7a414a6e811392',1,'utils.h']]], + ['ucx_5fstream_5fcopy_5fbufsize',['UCX_STREAM_COPY_BUFSIZE',['../utils_8h.html#a23efd74fa5f701d4cf26ccbfd138a439',1,'utils.h']]], + ['ucx_5fstream_5fncopy',['ucx_stream_ncopy',['../utils_8h.html#add13f39a8af440b4f7e6f74339eaada2',1,'utils.h']]], + ['ucx_5fszmul',['ucx_szmul',['../ucx_8h.html#a0b5ed6c1a0b15356f4f948acfd32a4cc',1,'ucx.h']]], + ['ucx_5fszmul_5fimpl',['ucx_szmul_impl',['../ucx_8h.html#a6637171cc0ec097b297f731a3036dd3b',1,'ucx.c']]], + ['ucx_5ftest',['UCX_TEST',['../test_8h.html#a66cfb29c329fc9eaef071f2449836659',1,'test.h']]], + ['ucx_5ftest_5fassert',['UCX_TEST_ASSERT',['../test_8h.html#a08f477cd12fc3fe741a92493e5df58a9',1,'test.h']]], + ['ucx_5ftest_5fbegin',['UCX_TEST_BEGIN',['../test_8h.html#a0547b8d4f3bcdb0633fdd8925e8aa5d4',1,'test.h']]], + ['ucx_5ftest_5fcall_5fsubroutine',['UCX_TEST_CALL_SUBROUTINE',['../test_8h.html#a0efbab91c54f5237a2ab207f48cf0e51',1,'test.h']]], + ['ucx_5ftest_5fend',['UCX_TEST_END',['../test_8h.html#a86e64857c04f0447f8b16fb9c2b3b639',1,'test.h']]], + ['ucx_5ftest_5fregister',['ucx_test_register',['../test_8h.html#a8dfabc42f183d3a4d79379a5d17bf67d',1,'test.c']]], + ['ucx_5ftest_5frun',['ucx_test_run',['../test_8h.html#a3721458deeecb43aa322428f007714c3',1,'test.c']]], + ['ucx_5ftest_5fsubroutine',['UCX_TEST_SUBROUTINE',['../test_8h.html#ae073cf5ead22cb27d662da048e16f44a',1,'test.h']]], + ['ucx_5ftest_5fsuite_5ffree',['ucx_test_suite_free',['../test_8h.html#a4a6ac61a6f72722273f8eaa7a343edde',1,'test.c']]], + ['ucx_5ftest_5fsuite_5fnew',['ucx_test_suite_new',['../test_8h.html#a531f0df90363e0befbe900878f65f09e',1,'test.c']]], + ['ucx_5fvasprintf',['ucx_vasprintf',['../utils_8h.html#a3ea1dfb856c741f3e8ec6bfdc9ad427e',1,'utils.c']]], + ['ucx_5fversion',['UCX_VERSION',['../ucx_8h.html#af12001920ca2fc1405615684e4dea284',1,'ucx.h']]], + ['ucx_5fversion_5fmajor',['UCX_VERSION_MAJOR',['../ucx_8h.html#aa57e5dd22d42387d748cc16777df1383',1,'ucx.h']]], + ['ucx_5fversion_5fminor',['UCX_VERSION_MINOR',['../ucx_8h.html#a9ac10d6353e23d4615a87fc737c65eb0',1,'ucx.h']]], + ['ucx_5fvfprintf',['ucx_vfprintf',['../utils_8h.html#a4907967beb92c3ae351dd239abbb6927',1,'utils.c']]], + ['ucxallocator',['UcxAllocator',['../structUcxAllocator.html',1,'']]], + ['ucxarray',['UcxArray',['../structUcxArray.html',1,'']]], + ['ucxavlnode',['UcxAVLNode',['../structUcxAVLNode.html',1,'UcxAVLNode'],['../avl_8h.html#a08ba2496c2316df58548c3cc29712add',1,'UcxAVLNode(): avl.h']]], + ['ucxavltree',['UcxAVLTree',['../structUcxAVLTree.html',1,'']]], + ['ucxbuffer',['UcxBuffer',['../structUcxBuffer.html',1,'']]], + ['ucxkey',['UcxKey',['../structUcxKey.html',1,'UcxKey'],['../map_8h.html#ad63828bb23123fc01a5315a2bac3b142',1,'UcxKey(): map.h']]], + ['ucxlist',['UcxList',['../structUcxList.html',1,'UcxList'],['../list_8h.html#aa6f89f91c1081c9a7c6866c298f497a2',1,'UcxList(): list.h']]], + ['ucxlogger',['UcxLogger',['../structUcxLogger.html',1,'']]], + ['ucxmap',['UcxMap',['../structUcxMap.html',1,'UcxMap'],['../map_8h.html#a18e21948725b2da68c35da587a722033',1,'UcxMap(): map.h']]], + ['ucxmapelement',['UcxMapElement',['../structUcxMapElement.html',1,'UcxMapElement'],['../map_8h.html#ad7d7a910a32113eb93eae11c3dc97b4b',1,'UcxMapElement(): map.h']]], + ['ucxmapiterator',['UcxMapIterator',['../structUcxMapIterator.html',1,'UcxMapIterator'],['../map_8h.html#ae36aff5f645948c54f51578b11fd87fb',1,'UcxMapIterator(): map.h']]], + ['ucxmapkey',['UcxMapKey',['../structUcxMapKey.html',1,'']]], + ['ucxmempool',['UcxMempool',['../structUcxMempool.html',1,'']]], + ['ucxproperties',['UcxProperties',['../structUcxProperties.html',1,'']]], + ['ucxstack',['UcxStack',['../structUcxStack.html',1,'']]], + ['ucxtest',['UcxTest',['../test_8h.html#ae906817354c010b83c2784260cce7a1c',1,'test.h']]], + ['ucxtestlist',['UcxTestList',['../structUcxTestList.html',1,'UcxTestList'],['../test_8h.html#a8048c50ae73ea690b776edfd63bd6a5d',1,'UcxTestList(): test.h']]], + ['ucxtestsuite',['UcxTestSuite',['../structUcxTestSuite.html',1,'UcxTestSuite'],['../test_8h.html#a52115d1d0f1c4a565ed6ef7c1bfd0363',1,'UcxTestSuite(): test.h']]], + ['userdata',['userdata',['../structUcxAVLTree.html#ae92a3bfad3fe33c8dcbdad85112f83fd',1,'UcxAVLTree']]], + ['utils_2eh',['utils.h',['../utils_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_12.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_12.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_12.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_12.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['value',['value',['../structUcxAVLNode.html#a302501b8c04c3fde668fe72249871258',1,'UcxAVLNode']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_13.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_13.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_13.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_13.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['write_5ffunc',['write_func',['../ucx_8h.html#a989b3f0fa4d307d278378fde435641ed',1,'ucx.h']]], + ['writer',['writer',['../structUcxLogger.html#ada13bba090a9dc4f8d6cd9be73c60930',1,'UcxLogger']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_2.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_2.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['buffer',['buffer',['../structUcxProperties.html#a6bb4d29686df41a0f42641ee15232bfd',1,'UcxProperties']]], + ['buffer_2eh',['buffer.h',['../buffer_8h.html',1,'']]], + ['buflen',['buflen',['../structUcxProperties.html#a4e7524434525267e29f493a25dcca6b5',1,'UcxProperties']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_3.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_3.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_3.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_3.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,14 @@ +var searchData= +[ + ['c',['c',['../structucx__memchunk.html#ab86550503e5f019bfa61a1e91f1c40da',1,'ucx_memchunk']]], + ['calloc',['calloc',['../structUcxAllocator.html#ab94ec1cba45cc4e7d81e1588a11cbb62',1,'UcxAllocator']]], + ['capacity',['capacity',['../structUcxArray.html#a7ed074887908e45bde7e1fbc67b31c18',1,'UcxArray::capacity()'],['../structUcxBuffer.html#a385661894f3cee9c549bfe07a8b316bf',1,'UcxBuffer::capacity()']]], + ['cmp_5ffunc',['cmp_func',['../ucx_8h.html#afe5e2d5dbf34778e0e97852051570791',1,'ucx.h']]], + ['cmpfunc',['cmpfunc',['../structUcxAVLTree.html#a87aff25cb726cb9eb88eb815a10d1004',1,'UcxAVLTree']]], + ['comment1',['comment1',['../structUcxProperties.html#afaa2e6a289fa6949b7b01df35fa5def8',1,'UcxProperties']]], + ['comment2',['comment2',['../structUcxProperties.html#a9ea7ecb414ca8bc7bef62cdd19cc6363',1,'UcxProperties']]], + ['comment3',['comment3',['../structUcxProperties.html#a5f3e561e32bac03e36a191a6940cca92',1,'UcxProperties']]], + ['copy_5ffunc',['copy_func',['../ucx_8h.html#aab917a5fe0965673c73e8ebd0a1fc967',1,'ucx.h']]], + ['count',['count',['../structUcxMap.html#a14e9163f71f6c014dfa2103de70ae9cd',1,'UcxMap']]], + ['cur',['cur',['../structUcxMapIterator.html#af1fc40f899f37280adb5b85acf6e742f',1,'UcxMapIterator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_4.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_4.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_4.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_4.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,8 @@ +var searchData= +[ + ['data',['data',['../structUcxArray.html#a04d2b03d0a45af1fab19b4216602075a',1,'UcxArray::data()'],['../structUcxList.html#a4a44905121b6fc2a088084ce578a9ea2',1,'UcxList::data()'],['../structUcxKey.html#a6176109f25b34f3fa92bcfbc8ae7a88c',1,'UcxKey::data()'],['../structUcxMapKey.html#ab71d1841e4f538628c00f782267fb6d5',1,'UcxMapKey::data()'],['../structUcxMapElement.html#abbd7f3bf5beef370f702d2d5bb07733c',1,'UcxMapElement::data()'],['../structUcxMempool.html#ae98c1b0150bb119ee0a8506a6f310d6e',1,'UcxMempool::data()']]], + ['dateformat',['dateformat',['../structUcxLogger.html#a086f75df0f6c81ec491f25c0a4d9262b',1,'UcxLogger']]], + ['delimiter',['delimiter',['../structUcxProperties.html#af6adb3f69616cf9d2bb5ea7b4d837ca5',1,'UcxProperties']]], + ['destructor',['destructor',['../structucx__memchunk.html#ac7b5e3fda47b917d6fb2a1d7ea28447b',1,'ucx_memchunk::destructor()'],['../structucx__regdestr.html#acea2a3bb66909aa800a931ac8b0cce56',1,'ucx_regdestr::destructor()']]], + ['distance_5ffunc',['distance_func',['../ucx_8h.html#a0bc5bf89e556c1d45d10863d52728ac9',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_5.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_5.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_5.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_5.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['elemsize',['elemsize',['../structUcxArray.html#ac4e9ecdf8a8d010644f6e44dfef8190f',1,'UcxArray']]], + ['error',['error',['../structUcxProperties.html#a34f71a6ab6dcb6892e3b4eb802e75bff',1,'UcxProperties']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_6.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_6.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_6.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_6.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['failure',['failure',['../structUcxTestSuite.html#abfd240541d1e956e49cde0ac36286951',1,'UcxTestSuite']]], + ['flags',['flags',['../structUcxBuffer.html#ac642e07b0a03be5aac48eb4aa5bec2f7',1,'UcxBuffer']]], + ['free',['free',['../structUcxAllocator.html#aecce1840378ed53f1002190f4f87026f',1,'UcxAllocator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_7.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_7.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_7.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_7.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['hash',['hash',['../structUcxKey.html#aac9d372ac34a4cbd8459e2b04e505752',1,'UcxKey::hash()'],['../structUcxMapKey.html#a34c1f8fec98174583944fffd30e7c913',1,'UcxMapKey::hash()']]], + ['height',['height',['../structUcxAVLNode.html#af129fd32863a7c35e82c5cd9d11dc95a',1,'UcxAVLNode']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_8.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_8.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_8.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_8.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['index',['index',['../structUcxMapIterator.html#ac2376545c8816dd6895de4995e558c65',1,'UcxMapIterator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_9.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_9.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_9.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_9.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['key',['key',['../structUcxAVLNode.html#ab65a31010d26a3df898e6ba534702af6',1,'UcxAVLNode::key()'],['../structUcxMapElement.html#aa446141b708e106e2c8de1303318187c',1,'UcxMapElement::key()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_a.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_a.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_a.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_a.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,10 @@ +var searchData= +[ + ['left',['left',['../structUcxAVLNode.html#ad3a1c733f2c1cc81ac527f846fc24b9c',1,'UcxAVLNode']]], + ['len',['len',['../structUcxKey.html#abef01de37f355688f2ac797d2c280683',1,'UcxKey::len()'],['../structUcxMapKey.html#a504d46caa45c79cd87ff8cd835654270',1,'UcxMapKey::len()']]], + ['length',['length',['../structsstr__t.html#a5cf571708cdff92e45f08458f2b98229',1,'sstr_t::length()'],['../structscstr__t.html#aaa0229f64f1057b6f65adededaa5a172',1,'scstr_t::length()']]], + ['level',['level',['../structUcxLogger.html#a2e0ee94c25b2307096c7970280d189cd',1,'UcxLogger']]], + ['levels',['levels',['../structUcxLogger.html#a187129f7bc6e5064b3d92a5f1217f396',1,'UcxLogger']]], + ['list_2eh',['list.h',['../list_8h.html',1,'']]], + ['logging_2eh',['logging.h',['../logging_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_b.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_b.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_b.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_b.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,8 @@ +var searchData= +[ + ['malloc',['malloc',['../structUcxAllocator.html#a013376172be39ed54f77c4be6898845a',1,'UcxAllocator']]], + ['map',['map',['../structUcxMap.html#a5792b5037c4f77ea3cb144b66c9b8790',1,'UcxMap::map()'],['../structUcxMapIterator.html#af88d6e22547d09fe1d665dd650dcdb95',1,'UcxMapIterator::map()']]], + ['map_2eh',['map.h',['../map_8h.html',1,'']]], + ['mask',['mask',['../structUcxLogger.html#a1de0db2e02dcf03366268f6943f8b97c',1,'UcxLogger']]], + ['mempool_2eh',['mempool.h',['../mempool_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_c.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_c.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_c.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_c.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['ndata',['ndata',['../structUcxMempool.html#aa3a73ab231e1bc207d526f46f1c1e23a',1,'UcxMempool']]], + ['next',['next',['../structUcxList.html#a82a1818f1abf765b026fa91478569a8f',1,'UcxList::next()'],['../structUcxMapElement.html#a99fe8188b0889201d70ff5f922deef51',1,'UcxMapElement::next()'],['../structUcxTestList.html#aeebb80ff75d9f6f82ab6dc2641a3c74e',1,'UcxTestList::next()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_d.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_d.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_d.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_d.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,10 @@ +var searchData= +[ + ['parent',['parent',['../structUcxAVLNode.html#afc4e3b4f452aa2d91cabb2135b9d42f7',1,'UcxAVLNode']]], + ['pool',['pool',['../structUcxAllocator.html#a1b78012998d1c28be86dc595f8f0aac9',1,'UcxAllocator']]], + ['pos',['pos',['../structUcxBuffer.html#a7a64288f002cf62b492e2ea49c79615c',1,'UcxBuffer::pos()'],['../structUcxProperties.html#addd36ac8e5e42241c0a57453633970db',1,'UcxProperties::pos()']]], + ['prev',['prev',['../structUcxList.html#a0f1fddce9088b9c1414745d0b1b5c08b',1,'UcxList::prev()'],['../structucx__stack__metadata.html#ad46d2e8e5b0acf05f2def41d451c5579',1,'ucx_stack_metadata::prev()']]], + ['prisstr',['PRIsstr',['../string_8h.html#a7d5bc48708405a28b23667e32dfcecae',1,'string.h']]], + ['properties_2eh',['properties.h',['../properties_8h.html',1,'']]], + ['ptr',['ptr',['../structucx__regdestr.html#aac0e9ec8df4aab08728b4f8292b5f5e7',1,'ucx_regdestr::ptr()'],['../structsstr__t.html#af8049914efc1e67f7de3ee55ec0611b0',1,'sstr_t::ptr()'],['../structscstr__t.html#a305fd48934b474a9bf4a40869030e391',1,'scstr_t::ptr()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_e.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_e.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_e.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_e.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,7 @@ +var searchData= +[ + ['read_5ffunc',['read_func',['../ucx_8h.html#a6a67e255e460acb58f802067b3ff5fd5',1,'ucx.h']]], + ['realloc',['realloc',['../structUcxAllocator.html#a3550e3847f31d9e9ce3ffcb0d3440c15',1,'UcxAllocator']]], + ['right',['right',['../structUcxAVLNode.html#a7cbaa31dba8c7a89f4f8f7905f6fd238',1,'UcxAVLNode']]], + ['root',['root',['../structUcxAVLTree.html#a393a8fc99eb2c290d3cb67170081d742',1,'UcxAVLTree']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_f.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_f.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/all_f.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/all_f.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,67 @@ +var searchData= +[ + ['s',['S',['../string_8h.html#a8fa17c8cf4c36df48f4108c36da8573e',1,'string.h']]], + ['sc',['SC',['../string_8h.html#a7d261dd0bc358c957a368bc058c1ce53',1,'string.h']]], + ['scstr',['SCSTR',['../string_8h.html#ad4293350a9b39a23a6546bd0fef2aeed',1,'SCSTR(): string.h'],['../string_8h.html#a2b1d6f1eca1c1549f37107b9c026c5a6',1,'scstr(const char *cstring): string.c']]], + ['scstr_5ft',['scstr_t',['../structscstr__t.html',1,'']]], + ['scstrcasecmp',['scstrcasecmp',['../string_8h.html#aca8142fb823d253054e17c17cfca05e0',1,'string.c']]], + ['scstrcaseprefix',['scstrcaseprefix',['../string_8h.html#a3718ef4aa1e86cdb26bda2f07fb585df',1,'string.c']]], + ['scstrcasesuffix',['scstrcasesuffix',['../string_8h.html#a6edb4b85f2b9efe79db7ffe6eccd7bc3',1,'string.c']]], + ['scstrcat',['scstrcat',['../string_8h.html#a7376842c19e954b49215da81ef76ac0c',1,'string.c']]], + ['scstrcat_5fa',['scstrcat_a',['../string_8h.html#abacce4cbd6f70fcb6453904ef08b02e9',1,'string.c']]], + ['scstrchr',['scstrchr',['../string_8h.html#a5836d6a7a744791c35e5c17bdc394a87',1,'string.c']]], + ['scstrcmp',['scstrcmp',['../string_8h.html#af35272a8e5408c88ed3e25a3a98f0a82',1,'string.c']]], + ['scstrdup',['scstrdup',['../string_8h.html#a97dccce03af419596dbdd592ca46a164',1,'string.c']]], + ['scstrdup_5fa',['scstrdup_a',['../string_8h.html#a8fe58921f51eb1fde038472377e63014',1,'string.c']]], + ['scstrlower',['scstrlower',['../string_8h.html#abccf198bea3186ff2abb080cc88dcae6',1,'string.c']]], + ['scstrlower_5fa',['scstrlower_a',['../string_8h.html#a3cf1e557df7ab58d03c78832c4060276',1,'string.c']]], + ['scstrn',['scstrn',['../string_8h.html#ae594f6e222ea394cef6a26c0dfad000d',1,'string.c']]], + ['scstrnlen',['scstrnlen',['../string_8h.html#ac1b000030d6d197eec48c15a182055d5',1,'string.c']]], + ['scstrprefix',['scstrprefix',['../string_8h.html#a599ddc2f88dd1df68b72eefd91347393',1,'string.c']]], + ['scstrrchr',['scstrrchr',['../string_8h.html#ae389835b97cd9382e7d6a6a075323376',1,'string.c']]], + ['scstrscstr',['scstrscstr',['../string_8h.html#a54f256c3abe811c52d58b4ff1b23f051',1,'string.c']]], + ['scstrsplit',['scstrsplit',['../string_8h.html#ae71cac352b00230848bde358f0fb05ea',1,'string.c']]], + ['scstrsplit_5fa',['scstrsplit_a',['../string_8h.html#a52906455ae530c9cdc6812c8e6d9bdef',1,'string.c']]], + ['scstrsstr',['scstrsstr',['../string_8h.html#aa4362cb36c6629f9d8484739fd827748',1,'string.c']]], + ['scstrsubs',['scstrsubs',['../string_8h.html#a9a6c8d8db0dda0037c3c852cce1a5060',1,'string.c']]], + ['scstrsubsl',['scstrsubsl',['../string_8h.html#ad50f0f67b906fad0744f46bcb51e144b',1,'string.c']]], + ['scstrsuffix',['scstrsuffix',['../string_8h.html#a1f0ae316a2afe85d5b4655e6ece6721a',1,'string.c']]], + ['scstrtrim',['scstrtrim',['../string_8h.html#ad374b16eb1be8b48019debad9b9f268c',1,'string.c']]], + ['scstrupper',['scstrupper',['../string_8h.html#af3dd09ec9d11162fe0075f4e60f41240',1,'string.c']]], + ['scstrupper_5fa',['scstrupper_a',['../string_8h.html#aea94613eb74668cc05d365803d32bfad',1,'string.c']]], + ['sfmt',['SFMT',['../string_8h.html#a23ed51e87385886bb65e8cd19c839362',1,'string.h']]], + ['size',['size',['../structUcxArray.html#a20c11f2c9048cda80062842b7c094e20',1,'UcxArray::size()'],['../structUcxBuffer.html#aec0aea8325394951d5ad4a9fbb8e1ac7',1,'UcxBuffer::size()'],['../structUcxMap.html#afe120846b26d99580a7ff1276464e838',1,'UcxMap::size()'],['../structUcxMempool.html#a304729986f2894971d0469e71e196bf0',1,'UcxMempool::size()'],['../structUcxStack.html#a4df86b1917bfc3bbf760220870638143',1,'UcxStack::size()'],['../structucx__stack__metadata.html#ae2a2848b721cfa44a7e963484c5e4b28',1,'ucx_stack_metadata::size()']]], + ['space',['space',['../structUcxBuffer.html#a1a5076e85acb84b715a53bc0f37fb721',1,'UcxBuffer::space()'],['../structUcxStack.html#af64d528744bf3a47fec87d2e45d2992f',1,'UcxStack::space()']]], + ['sstr',['sstr',['../string_8h.html#a539eb7059251a051ee5d179526a23e9a',1,'string.c']]], + ['sstr_5ft',['sstr_t',['../structsstr__t.html',1,'']]], + ['sstrcasecmp',['sstrcasecmp',['../string_8h.html#a81b0f6df794152c2038703d4e9d0ad59',1,'string.h']]], + ['sstrcaseprefix',['sstrcaseprefix',['../string_8h.html#acd3dc64e90db9b4046e14f115a815ff4',1,'string.h']]], + ['sstrcasesuffix',['sstrcasesuffix',['../string_8h.html#a57eabd4862d531dd685bbf2feb8468bf',1,'string.h']]], + ['sstrcat',['sstrcat',['../string_8h.html#a6af8a4c347c7fdb5980d4c4803be2759',1,'string.h']]], + ['sstrcat_5fa',['sstrcat_a',['../string_8h.html#a6068d460f9bc05962666a917d26568b3',1,'string.h']]], + ['sstrchr',['sstrchr',['../string_8h.html#af80898a0b75955eb2579298c3ae2c481',1,'string.c']]], + ['sstrcmp',['sstrcmp',['../string_8h.html#a7ae7156c8de57454ca38d306100b8160',1,'string.h']]], + ['sstrdup',['sstrdup',['../string_8h.html#accbfd2b459a028d7af9fb7df6f977d80',1,'string.h']]], + ['sstrdup_5fa',['sstrdup_a',['../string_8h.html#a8d098baada4ea9ad5d8b6343b5aec007',1,'string.h']]], + ['sstrlower',['sstrlower',['../string_8h.html#a89343ea3e719f00ee802b557db57b769',1,'string.h']]], + ['sstrlower_5fa',['sstrlower_a',['../string_8h.html#a4bb4742fe71115f493991d307cb22b23',1,'string.h']]], + ['sstrn',['sstrn',['../string_8h.html#a2744c38ac44abf3e01fa059056dcf36c',1,'string.c']]], + ['sstrnlen',['sstrnlen',['../string_8h.html#a33fa945acc5ac2ce962e5ef13cf1638c',1,'string.h']]], + ['sstrprefix',['sstrprefix',['../string_8h.html#a7d73b66256384b26927e787318fdefa2',1,'string.h']]], + ['sstrrchr',['sstrrchr',['../string_8h.html#adae3f59957ca328e1da5285cb8b02a72',1,'string.c']]], + ['sstrscstr',['sstrscstr',['../string_8h.html#aa696932213265e10f864678686f4ccde',1,'string.h']]], + ['sstrsplit',['sstrsplit',['../string_8h.html#aa929984004c3576bfafb95031aca8eb7',1,'string.h']]], + ['sstrsplit_5fa',['sstrsplit_a',['../string_8h.html#ac9f69fa3a17e26a3a5f9d985b5844601',1,'string.h']]], + ['sstrstr',['sstrstr',['../string_8h.html#a9d03be026afa9447c52bb34b9e3b895a',1,'string.h']]], + ['sstrsubs',['sstrsubs',['../string_8h.html#a5eb9e0e1f26cf7fbecc038cd90e8b258',1,'string.c']]], + ['sstrsubsl',['sstrsubsl',['../string_8h.html#a78925c91af54f23cebd20ff99ef4331a',1,'string.c']]], + ['sstrsuffix',['sstrsuffix',['../string_8h.html#ac6a5246f26be2e8a5f34d8995b7ec14e',1,'string.h']]], + ['sstrtrim',['sstrtrim',['../string_8h.html#ae2d6da564d3fce51f2e0cac580fdbc56',1,'string.c']]], + ['sstrupper',['sstrupper',['../string_8h.html#a084fe5a3a90d6fb6b15ecda03bb30824',1,'string.h']]], + ['sstrupper_5fa',['sstrupper_a',['../string_8h.html#a5f0dd83c0176b812fb428004b2877a34',1,'string.h']]], + ['st',['ST',['../string_8h.html#a9037956cca97a4e84b642f17f3d10378',1,'string.h']]], + ['stack_2eh',['stack.h',['../stack_8h.html',1,'']]], + ['stream',['stream',['../structUcxLogger.html#a33fddf4791e8d49e479ecc78bf5d1b9e',1,'UcxLogger']]], + ['string_2eh',['string.h',['../string_8h.html',1,'']]], + ['success',['success',['../structUcxTestSuite.html#a6cefa870a3c2e38d6ee682e38643dbbb',1,'UcxTestSuite']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/classes_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/classes_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/classes_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/classes_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['scstr_5ft',['scstr_t',['../structscstr__t.html',1,'']]], + ['sstr_5ft',['sstr_t',['../structsstr__t.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/classes_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/classes_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/classes_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/classes_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,23 @@ +var searchData= +[ + ['ucx_5fmemchunk',['ucx_memchunk',['../structucx__memchunk.html',1,'']]], + ['ucx_5fregdestr',['ucx_regdestr',['../structucx__regdestr.html',1,'']]], + ['ucx_5fstack_5fmetadata',['ucx_stack_metadata',['../structucx__stack__metadata.html',1,'']]], + ['ucxallocator',['UcxAllocator',['../structUcxAllocator.html',1,'']]], + ['ucxarray',['UcxArray',['../structUcxArray.html',1,'']]], + ['ucxavlnode',['UcxAVLNode',['../structUcxAVLNode.html',1,'']]], + ['ucxavltree',['UcxAVLTree',['../structUcxAVLTree.html',1,'']]], + ['ucxbuffer',['UcxBuffer',['../structUcxBuffer.html',1,'']]], + ['ucxkey',['UcxKey',['../structUcxKey.html',1,'']]], + ['ucxlist',['UcxList',['../structUcxList.html',1,'']]], + ['ucxlogger',['UcxLogger',['../structUcxLogger.html',1,'']]], + ['ucxmap',['UcxMap',['../structUcxMap.html',1,'']]], + ['ucxmapelement',['UcxMapElement',['../structUcxMapElement.html',1,'']]], + ['ucxmapiterator',['UcxMapIterator',['../structUcxMapIterator.html',1,'']]], + ['ucxmapkey',['UcxMapKey',['../structUcxMapKey.html',1,'']]], + ['ucxmempool',['UcxMempool',['../structUcxMempool.html',1,'']]], + ['ucxproperties',['UcxProperties',['../structUcxProperties.html',1,'']]], + ['ucxstack',['UcxStack',['../structUcxStack.html',1,'']]], + ['ucxtestlist',['UcxTestList',['../structUcxTestList.html',1,'']]], + ['ucxtestsuite',['UcxTestSuite',['../structUcxTestSuite.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/close.png Binary file docs/api-2.1/search/close.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['_5f_5ffunction_5f_5f',['__FUNCTION__',['../test_8h.html#a828bb1dfda1afd67ca795075903d227d',1,'test.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,7 @@ +var searchData= +[ + ['alcalloc',['alcalloc',['../allocator_8h.html#a8d71470816f88f78cb9a9686c57e1b10',1,'allocator.h']]], + ['alfree',['alfree',['../allocator_8h.html#acd775785b54e97dc2b33a432c12c8fb2',1,'allocator.h']]], + ['almalloc',['almalloc',['../allocator_8h.html#ae1bc218fea8a35f4a3706f0beefcfb19',1,'allocator.h']]], + ['alrealloc',['alrealloc',['../allocator_8h.html#a029ee5c9bcbb3f873571553f788c5820',1,'allocator.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_2.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_2.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['prisstr',['PRIsstr',['../string_8h.html#a7d5bc48708405a28b23667e32dfcecae',1,'string.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_3.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_3.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_3.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_3.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,27 @@ +var searchData= +[ + ['s',['S',['../string_8h.html#a8fa17c8cf4c36df48f4108c36da8573e',1,'string.h']]], + ['sc',['SC',['../string_8h.html#a7d261dd0bc358c957a368bc058c1ce53',1,'string.h']]], + ['scstr',['SCSTR',['../string_8h.html#ad4293350a9b39a23a6546bd0fef2aeed',1,'string.h']]], + ['sfmt',['SFMT',['../string_8h.html#a23ed51e87385886bb65e8cd19c839362',1,'string.h']]], + ['sstrcasecmp',['sstrcasecmp',['../string_8h.html#a81b0f6df794152c2038703d4e9d0ad59',1,'string.h']]], + ['sstrcaseprefix',['sstrcaseprefix',['../string_8h.html#acd3dc64e90db9b4046e14f115a815ff4',1,'string.h']]], + ['sstrcasesuffix',['sstrcasesuffix',['../string_8h.html#a57eabd4862d531dd685bbf2feb8468bf',1,'string.h']]], + ['sstrcat',['sstrcat',['../string_8h.html#a6af8a4c347c7fdb5980d4c4803be2759',1,'string.h']]], + ['sstrcat_5fa',['sstrcat_a',['../string_8h.html#a6068d460f9bc05962666a917d26568b3',1,'string.h']]], + ['sstrcmp',['sstrcmp',['../string_8h.html#a7ae7156c8de57454ca38d306100b8160',1,'string.h']]], + ['sstrdup',['sstrdup',['../string_8h.html#accbfd2b459a028d7af9fb7df6f977d80',1,'string.h']]], + ['sstrdup_5fa',['sstrdup_a',['../string_8h.html#a8d098baada4ea9ad5d8b6343b5aec007',1,'string.h']]], + ['sstrlower',['sstrlower',['../string_8h.html#a89343ea3e719f00ee802b557db57b769',1,'string.h']]], + ['sstrlower_5fa',['sstrlower_a',['../string_8h.html#a4bb4742fe71115f493991d307cb22b23',1,'string.h']]], + ['sstrnlen',['sstrnlen',['../string_8h.html#a33fa945acc5ac2ce962e5ef13cf1638c',1,'string.h']]], + ['sstrprefix',['sstrprefix',['../string_8h.html#a7d73b66256384b26927e787318fdefa2',1,'string.h']]], + ['sstrscstr',['sstrscstr',['../string_8h.html#aa696932213265e10f864678686f4ccde',1,'string.h']]], + ['sstrsplit',['sstrsplit',['../string_8h.html#aa929984004c3576bfafb95031aca8eb7',1,'string.h']]], + ['sstrsplit_5fa',['sstrsplit_a',['../string_8h.html#ac9f69fa3a17e26a3a5f9d985b5844601',1,'string.h']]], + ['sstrstr',['sstrstr',['../string_8h.html#a9d03be026afa9447c52bb34b9e3b895a',1,'string.h']]], + ['sstrsuffix',['sstrsuffix',['../string_8h.html#ac6a5246f26be2e8a5f34d8995b7ec14e',1,'string.h']]], + ['sstrupper',['sstrupper',['../string_8h.html#a084fe5a3a90d6fb6b15ecda03bb30824',1,'string.h']]], + ['sstrupper_5fa',['sstrupper_a',['../string_8h.html#a5f0dd83c0176b812fb428004b2877a34',1,'string.h']]], + ['st',['ST',['../string_8h.html#a9037956cca97a4e84b642f17f3d10378',1,'string.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_4.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_4.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/defines_4.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/defines_4.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,59 @@ +var searchData= +[ + ['ucx_5fallocator_5fdefault',['UCX_ALLOCATOR_DEFAULT',['../allocator_8h.html#a1283a8f875f90a7af3aba5e031fc2e3f',1,'allocator.h']]], + ['ucx_5farray_5futil_5fset',['ucx_array_util_set',['../array_8h.html#a1d959c29af3125bdd37cde3a554e729c',1,'array.h']]], + ['ucx_5farray_5futil_5fsetptr',['ucx_array_util_setptr',['../array_8h.html#a59a5b342965e790945f9c7a3f86b99f9',1,'array.h']]], + ['ucx_5favl_5fdefault_5fnew',['ucx_avl_default_new',['../avl_8h.html#ac2886d4b79b48c9fabf6408873f84cd2',1,'avl.h']]], + ['ucx_5favl_5ffind_5fclosest',['UCX_AVL_FIND_CLOSEST',['../avl_8h.html#af16f24d74fd6af0154de041566c6603b',1,'avl.h']]], + ['ucx_5favl_5ffind_5fexact',['UCX_AVL_FIND_EXACT',['../avl_8h.html#aaaf4a6f6f661cda7791db239212285d9',1,'avl.h']]], + ['ucx_5favl_5ffind_5flower_5fbounded',['UCX_AVL_FIND_LOWER_BOUNDED',['../avl_8h.html#abd2446d544d5412b6997ee8a17bd368c',1,'avl.h']]], + ['ucx_5favl_5ffind_5fupper_5fbounded',['UCX_AVL_FIND_UPPER_BOUNDED',['../avl_8h.html#ac74ee7649c1e206b08b31f37dd68ca5e',1,'avl.h']]], + ['ucx_5fbprintf',['ucx_bprintf',['../utils_8h.html#a9d7d65a420f026fcb6982803d5120519',1,'utils.h']]], + ['ucx_5fbuffer_5fautoextend',['UCX_BUFFER_AUTOEXTEND',['../buffer_8h.html#a05f9565f2d04399168c3b1c152a632be',1,'buffer.h']]], + ['ucx_5fbuffer_5fautofree',['UCX_BUFFER_AUTOFREE',['../buffer_8h.html#a8bab11ad8a76719228b9ee91e2e45535',1,'buffer.h']]], + ['ucx_5fbuffer_5fclear',['ucx_buffer_clear',['../buffer_8h.html#a374abd5aabfcc3ee0777a79d5fe651ab',1,'buffer.h']]], + ['ucx_5fbuffer_5fclone',['ucx_buffer_clone',['../buffer_8h.html#a828353846428c2c2f695f9938f059e52',1,'buffer.h']]], + ['ucx_5fbuffer_5fdefault',['UCX_BUFFER_DEFAULT',['../buffer_8h.html#acc77c8ed7b26854f555d4a5d11e49ea2',1,'buffer.h']]], + ['ucx_5fbuffer_5fto_5fsstr',['ucx_buffer_to_sstr',['../buffer_8h.html#a0f4b64f1b3a74c4f6c5d9409d6b6086a',1,'buffer.h']]], + ['ucx_5fforeach',['UCX_FOREACH',['../list_8h.html#a4b143b6526a410aa4d22cb3bb9365d70',1,'list.h']]], + ['ucx_5flogger_5fdebug',['ucx_logger_debug',['../logging_8h.html#a2936402799892db5138e5f1f8c25db0c',1,'ucx_logger_debug(): logging.h'],['../logging_8h.html#acff01d1ef919ea997cfce755fc1b83d8',1,'UCX_LOGGER_DEBUG(): logging.h']]], + ['ucx_5flogger_5ferror',['ucx_logger_error',['../logging_8h.html#a6a9e472e14d6768e59d96d245e065397',1,'ucx_logger_error(): logging.h'],['../logging_8h.html#aa254c07fe3a907613e2256a318d5c9a8',1,'UCX_LOGGER_ERROR(): logging.h']]], + ['ucx_5flogger_5finfo',['UCX_LOGGER_INFO',['../logging_8h.html#a4b0178bf60a6129373ffc59114ca4c9b',1,'UCX_LOGGER_INFO(): logging.h'],['../logging_8h.html#a98464d8d51376ce2716dcc4eca00d5da',1,'ucx_logger_info(): logging.h']]], + ['ucx_5flogger_5flevel',['UCX_LOGGER_LEVEL',['../logging_8h.html#aee18bc20e58ffb69910121512c350839',1,'logging.h']]], + ['ucx_5flogger_5flog',['ucx_logger_log',['../logging_8h.html#aa0245325031d95799b28def177fd14ec',1,'logging.h']]], + ['ucx_5flogger_5fregister_5flevel',['ucx_logger_register_level',['../logging_8h.html#a5cffc19502c4c90bfb3bd3bbcd18170a',1,'logging.h']]], + ['ucx_5flogger_5fsource',['UCX_LOGGER_SOURCE',['../logging_8h.html#a0e0d72b12616c1e49ff8834eaf4cb8a2',1,'logging.h']]], + ['ucx_5flogger_5ftimestamp',['UCX_LOGGER_TIMESTAMP',['../logging_8h.html#a38607008268b4f776ee500fb95d2e823',1,'logging.h']]], + ['ucx_5flogger_5ftrace',['UCX_LOGGER_TRACE',['../logging_8h.html#a55b88d1fec7036d841b3ddd6195c5586',1,'UCX_LOGGER_TRACE(): logging.h'],['../logging_8h.html#a3031b7ff13f4cfae9c2916543be2877c',1,'ucx_logger_trace(): logging.h']]], + ['ucx_5flogger_5fwarn',['UCX_LOGGER_WARN',['../logging_8h.html#abd01ca11486226ba34e8f7028d9fffba',1,'UCX_LOGGER_WARN(): logging.h'],['../logging_8h.html#aca7bd861b646892813fd7310c0aa69af',1,'ucx_logger_warn(): logging.h']]], + ['ucx_5fmap_5fcstr_5fget',['ucx_map_cstr_get',['../map_8h.html#a64e1fb55498fa502dd2ed8ed69062cdd',1,'map.h']]], + ['ucx_5fmap_5fcstr_5fput',['ucx_map_cstr_put',['../map_8h.html#ad9356b01425b934ab237b52339ac0cc3',1,'map.h']]], + ['ucx_5fmap_5fcstr_5fremove',['ucx_map_cstr_remove',['../map_8h.html#a9c4405a5a75ecf64e2ef3d0c6501a9fe',1,'map.h']]], + ['ucx_5fmap_5fforeach',['UCX_MAP_FOREACH',['../map_8h.html#a940896c4aa1b13e54c55c04c3efc186b',1,'map.h']]], + ['ucx_5fmap_5fint_5fget',['ucx_map_int_get',['../map_8h.html#aa1681bd2178553cd092fd24c4d681d3c',1,'map.h']]], + ['ucx_5fmap_5fint_5fput',['ucx_map_int_put',['../map_8h.html#aaa30af79b4068c923895619e83f44367',1,'map.h']]], + ['ucx_5fmap_5fint_5fremove',['ucx_map_int_remove',['../map_8h.html#aa767958b5468737755c09f7185b1770c',1,'map.h']]], + ['ucx_5fmap_5fsstr_5fget',['ucx_map_sstr_get',['../map_8h.html#a14d385f6b7f371f0507861cabd2eab4e',1,'map.h']]], + ['ucx_5fmap_5fsstr_5fput',['ucx_map_sstr_put',['../map_8h.html#ac26a8615bfc8f47ee9eaceb47645f98e',1,'map.h']]], + ['ucx_5fmap_5fsstr_5fremove',['ucx_map_sstr_remove',['../map_8h.html#a48700ea86fadb9ea54d13010f9124df2',1,'map.h']]], + ['ucx_5fmempool_5fnew_5fdefault',['ucx_mempool_new_default',['../mempool_8h.html#a49f7bd1da5ac201d0cf54dc0f0d82dd2',1,'mempool.h']]], + ['ucx_5fsprintf',['ucx_sprintf',['../utils_8h.html#af9f333b66ecd639c347c7235f4992e2e',1,'utils.h']]], + ['ucx_5fstack_5fdim',['ucx_stack_dim',['../stack_8h.html#a3b761343c6491222604341ebfa443226',1,'stack.h']]], + ['ucx_5fstack_5fempty',['ucx_stack_empty',['../stack_8h.html#a4f7239dbd6c032c56812e370b71c1985',1,'stack.h']]], + ['ucx_5fstack_5fpop',['ucx_stack_pop',['../stack_8h.html#a506b82374734ec476d086ddfb561174d',1,'stack.h']]], + ['ucx_5fstack_5ftopsize',['ucx_stack_topsize',['../stack_8h.html#a030197051a803e87d5eeac5adb80b15a',1,'stack.h']]], + ['ucx_5fstream_5fbcopy',['ucx_stream_bcopy',['../utils_8h.html#a6003a1750a66234169bd1f8cc84b297b',1,'utils.h']]], + ['ucx_5fstream_5fcopy',['ucx_stream_copy',['../utils_8h.html#a41ca1344f781c0d3bf7a414a6e811392',1,'utils.h']]], + ['ucx_5fstream_5fcopy_5fbufsize',['UCX_STREAM_COPY_BUFSIZE',['../utils_8h.html#a23efd74fa5f701d4cf26ccbfd138a439',1,'utils.h']]], + ['ucx_5fstream_5fncopy',['ucx_stream_ncopy',['../utils_8h.html#add13f39a8af440b4f7e6f74339eaada2',1,'utils.h']]], + ['ucx_5fszmul',['ucx_szmul',['../ucx_8h.html#a0b5ed6c1a0b15356f4f948acfd32a4cc',1,'ucx.h']]], + ['ucx_5ftest',['UCX_TEST',['../test_8h.html#a66cfb29c329fc9eaef071f2449836659',1,'test.h']]], + ['ucx_5ftest_5fassert',['UCX_TEST_ASSERT',['../test_8h.html#a08f477cd12fc3fe741a92493e5df58a9',1,'test.h']]], + ['ucx_5ftest_5fbegin',['UCX_TEST_BEGIN',['../test_8h.html#a0547b8d4f3bcdb0633fdd8925e8aa5d4',1,'test.h']]], + ['ucx_5ftest_5fcall_5fsubroutine',['UCX_TEST_CALL_SUBROUTINE',['../test_8h.html#a0efbab91c54f5237a2ab207f48cf0e51',1,'test.h']]], + ['ucx_5ftest_5fend',['UCX_TEST_END',['../test_8h.html#a86e64857c04f0447f8b16fb9c2b3b639',1,'test.h']]], + ['ucx_5ftest_5fsubroutine',['UCX_TEST_SUBROUTINE',['../test_8h.html#ae073cf5ead22cb27d662da048e16f44a',1,'test.h']]], + ['ucx_5fversion',['UCX_VERSION',['../ucx_8h.html#af12001920ca2fc1405615684e4dea284',1,'ucx.h']]], + ['ucx_5fversion_5fmajor',['UCX_VERSION_MAJOR',['../ucx_8h.html#aa57e5dd22d42387d748cc16777df1383',1,'ucx.h']]], + ['ucx_5fversion_5fminor',['UCX_VERSION_MINOR',['../ucx_8h.html#a9ac10d6353e23d4615a87fc737c65eb0',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['allocator_2eh',['allocator.h',['../allocator_8h.html',1,'']]], + ['array_2eh',['array.h',['../array_8h.html',1,'']]], + ['avl_2eh',['avl.h',['../avl_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['buffer_2eh',['buffer.h',['../buffer_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_2.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_2.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['list_2eh',['list.h',['../list_8h.html',1,'']]], + ['logging_2eh',['logging.h',['../logging_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_3.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_3.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_3.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_3.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['map_2eh',['map.h',['../map_8h.html',1,'']]], + ['mempool_2eh',['mempool.h',['../mempool_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_4.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_4.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_4.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_4.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['properties_2eh',['properties.h',['../properties_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_5.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_5.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_5.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_5.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['stack_2eh',['stack.h',['../stack_8h.html',1,'']]], + ['string_2eh',['string.h',['../string_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_6.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_6.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_6.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_6.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['test_2eh',['test.h',['../test_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_7.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_7.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/files_7.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/files_7.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['ucx_2eh',['ucx.h',['../ucx_8h.html',1,'']]], + ['utils_2eh',['utils.h',['../utils_8h.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/functions_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/functions_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/functions_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/functions_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,36 @@ +var searchData= +[ + ['scstr',['scstr',['../string_8h.html#a2b1d6f1eca1c1549f37107b9c026c5a6',1,'string.c']]], + ['scstrcasecmp',['scstrcasecmp',['../string_8h.html#aca8142fb823d253054e17c17cfca05e0',1,'string.c']]], + ['scstrcaseprefix',['scstrcaseprefix',['../string_8h.html#a3718ef4aa1e86cdb26bda2f07fb585df',1,'string.c']]], + ['scstrcasesuffix',['scstrcasesuffix',['../string_8h.html#a6edb4b85f2b9efe79db7ffe6eccd7bc3',1,'string.c']]], + ['scstrcat',['scstrcat',['../string_8h.html#a7376842c19e954b49215da81ef76ac0c',1,'string.c']]], + ['scstrcat_5fa',['scstrcat_a',['../string_8h.html#abacce4cbd6f70fcb6453904ef08b02e9',1,'string.c']]], + ['scstrchr',['scstrchr',['../string_8h.html#a5836d6a7a744791c35e5c17bdc394a87',1,'string.c']]], + ['scstrcmp',['scstrcmp',['../string_8h.html#af35272a8e5408c88ed3e25a3a98f0a82',1,'string.c']]], + ['scstrdup',['scstrdup',['../string_8h.html#a97dccce03af419596dbdd592ca46a164',1,'string.c']]], + ['scstrdup_5fa',['scstrdup_a',['../string_8h.html#a8fe58921f51eb1fde038472377e63014',1,'string.c']]], + ['scstrlower',['scstrlower',['../string_8h.html#abccf198bea3186ff2abb080cc88dcae6',1,'string.c']]], + ['scstrlower_5fa',['scstrlower_a',['../string_8h.html#a3cf1e557df7ab58d03c78832c4060276',1,'string.c']]], + ['scstrn',['scstrn',['../string_8h.html#ae594f6e222ea394cef6a26c0dfad000d',1,'string.c']]], + ['scstrnlen',['scstrnlen',['../string_8h.html#ac1b000030d6d197eec48c15a182055d5',1,'string.c']]], + ['scstrprefix',['scstrprefix',['../string_8h.html#a599ddc2f88dd1df68b72eefd91347393',1,'string.c']]], + ['scstrrchr',['scstrrchr',['../string_8h.html#ae389835b97cd9382e7d6a6a075323376',1,'string.c']]], + ['scstrscstr',['scstrscstr',['../string_8h.html#a54f256c3abe811c52d58b4ff1b23f051',1,'string.c']]], + ['scstrsplit',['scstrsplit',['../string_8h.html#ae71cac352b00230848bde358f0fb05ea',1,'string.c']]], + ['scstrsplit_5fa',['scstrsplit_a',['../string_8h.html#a52906455ae530c9cdc6812c8e6d9bdef',1,'string.c']]], + ['scstrsstr',['scstrsstr',['../string_8h.html#aa4362cb36c6629f9d8484739fd827748',1,'string.c']]], + ['scstrsubs',['scstrsubs',['../string_8h.html#a9a6c8d8db0dda0037c3c852cce1a5060',1,'string.c']]], + ['scstrsubsl',['scstrsubsl',['../string_8h.html#ad50f0f67b906fad0744f46bcb51e144b',1,'string.c']]], + ['scstrsuffix',['scstrsuffix',['../string_8h.html#a1f0ae316a2afe85d5b4655e6ece6721a',1,'string.c']]], + ['scstrtrim',['scstrtrim',['../string_8h.html#ad374b16eb1be8b48019debad9b9f268c',1,'string.c']]], + ['scstrupper',['scstrupper',['../string_8h.html#af3dd09ec9d11162fe0075f4e60f41240',1,'string.c']]], + ['scstrupper_5fa',['scstrupper_a',['../string_8h.html#aea94613eb74668cc05d365803d32bfad',1,'string.c']]], + ['sstr',['sstr',['../string_8h.html#a539eb7059251a051ee5d179526a23e9a',1,'string.c']]], + ['sstrchr',['sstrchr',['../string_8h.html#af80898a0b75955eb2579298c3ae2c481',1,'string.c']]], + ['sstrn',['sstrn',['../string_8h.html#a2744c38ac44abf3e01fa059056dcf36c',1,'string.c']]], + ['sstrrchr',['sstrrchr',['../string_8h.html#adae3f59957ca328e1da5285cb8b02a72',1,'string.c']]], + ['sstrsubs',['sstrsubs',['../string_8h.html#a5eb9e0e1f26cf7fbecc038cd90e8b258',1,'string.c']]], + ['sstrsubsl',['sstrsubsl',['../string_8h.html#a78925c91af54f23cebd20ff99ef4331a',1,'string.c']]], + ['sstrtrim',['sstrtrim',['../string_8h.html#ae2d6da564d3fce51f2e0cac580fdbc56',1,'string.c']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/functions_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/functions_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/functions_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/functions_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,185 @@ +var searchData= +[ + ['ucx_5farray_5fappend_5ffrom',['ucx_array_append_from',['../array_8h.html#aea01731ad94ea73c0c8fb1d1b7a35fcf',1,'array.c']]], + ['ucx_5farray_5fat',['ucx_array_at',['../array_8h.html#aa698085fd1a8b70d6b709999c51b49e8',1,'array.c']]], + ['ucx_5farray_5fclone',['ucx_array_clone',['../array_8h.html#a4a8c273370e4a3a3e2624e364f5ab410',1,'array.c']]], + ['ucx_5farray_5fconcat',['ucx_array_concat',['../array_8h.html#aa5a0bf3d3f0df6406beb0e569021cc28',1,'array.c']]], + ['ucx_5farray_5fcontains',['ucx_array_contains',['../array_8h.html#a5241058cd2329147bc5b1593ae7e51dc',1,'array.c']]], + ['ucx_5farray_5fdestroy',['ucx_array_destroy',['../array_8h.html#a8e83681d8d5d8cddbf10f63ce5be4c10',1,'array.c']]], + ['ucx_5farray_5fequals',['ucx_array_equals',['../array_8h.html#a43292b448adb1741677aa8c578bcc201',1,'array.c']]], + ['ucx_5farray_5ffind',['ucx_array_find',['../array_8h.html#ae7bdbed94afee9b20b38b95e3ab470f0',1,'array.c']]], + ['ucx_5farray_5ffree',['ucx_array_free',['../array_8h.html#ac01ee914468a16f470bf3071fffbe438',1,'array.c']]], + ['ucx_5farray_5fgrow',['ucx_array_grow',['../array_8h.html#ab0cbf243824aaebee48277315e03afce',1,'array.c']]], + ['ucx_5farray_5finit',['ucx_array_init',['../array_8h.html#ad921e85c28ffae32230777a53c5037e5',1,'array.c']]], + ['ucx_5farray_5finit_5fa',['ucx_array_init_a',['../array_8h.html#a2451e61ebb15a7ba1c1319267ba75b8c',1,'array.c']]], + ['ucx_5farray_5fnew',['ucx_array_new',['../array_8h.html#a994a2fbf1c33a3833e2a70cd9a4352b7',1,'array.c']]], + ['ucx_5farray_5fnew_5fa',['ucx_array_new_a',['../array_8h.html#a177170258c215eb2e4f5a32e59f0cb1b',1,'array.c']]], + ['ucx_5farray_5fprepend_5ffrom',['ucx_array_prepend_from',['../array_8h.html#a95b52acc2193b5c33cf0eaa4f2082477',1,'array.c']]], + ['ucx_5farray_5fremove',['ucx_array_remove',['../array_8h.html#aa45eac6b697f83adac81c0860cf306b8',1,'array.c']]], + ['ucx_5farray_5fremove_5ffast',['ucx_array_remove_fast',['../array_8h.html#a548d81b07612bae3ba8c4c4b49104b8e',1,'array.c']]], + ['ucx_5farray_5freserve',['ucx_array_reserve',['../array_8h.html#a1c3bf8433c1de3c933f3854ab297fe1d',1,'array.c']]], + ['ucx_5farray_5fresize',['ucx_array_resize',['../array_8h.html#a27762e7c06a6c781015e3c8ceeee0ce3',1,'array.c']]], + ['ucx_5farray_5fset_5ffrom',['ucx_array_set_from',['../array_8h.html#a1bb545d065358d265d80d815ba382a28',1,'array.c']]], + ['ucx_5farray_5fshrink',['ucx_array_shrink',['../array_8h.html#a2daf50e80aee9bccebee876a7efd2dfc',1,'array.c']]], + ['ucx_5farray_5fsort',['ucx_array_sort',['../array_8h.html#add773514569b872a6624381b4b6af52c',1,'array.c']]], + ['ucx_5farray_5futil_5fset_5fa',['ucx_array_util_set_a',['../array_8h.html#ad0a8d76980cf1c1910e64a245803fb9a',1,'array.c']]], + ['ucx_5farray_5futil_5fsetptr_5fa',['ucx_array_util_setptr_a',['../array_8h.html#ad708b333c0c1b02c998309a58ea65e31',1,'array.c']]], + ['ucx_5fasprintf',['ucx_asprintf',['../utils_8h.html#a9f9cf0e89ffdc256ecb35429907f51f5',1,'utils.c']]], + ['ucx_5favl_5fcount',['ucx_avl_count',['../avl_8h.html#a92c1d41c2b22fe4a029a486ab2153e35',1,'avl.c']]], + ['ucx_5favl_5ffind',['ucx_avl_find',['../avl_8h.html#a51770e1614b28d7d22dea096c3704f83',1,'avl.c']]], + ['ucx_5favl_5ffind_5fnode',['ucx_avl_find_node',['../avl_8h.html#a664986f64d6865605199fbff06e19cd5',1,'avl.c']]], + ['ucx_5favl_5ffree',['ucx_avl_free',['../avl_8h.html#a2f92db538f25fce908d2cb3e5590944c',1,'avl.c']]], + ['ucx_5favl_5ffree_5fcontent',['ucx_avl_free_content',['../avl_8h.html#a31ad7fb196ca211f1fc39f4e15f72279',1,'avl.c']]], + ['ucx_5favl_5fget',['ucx_avl_get',['../avl_8h.html#adbcf7ceb3f014a30c7214f7304519efe',1,'avl.c']]], + ['ucx_5favl_5fget_5fnode',['ucx_avl_get_node',['../avl_8h.html#acf42da9a4168e47dc10b4ba0d27ceb4e',1,'avl.c']]], + ['ucx_5favl_5fnew',['ucx_avl_new',['../avl_8h.html#a11b043d65a11b7092d5d98b298e5ede3',1,'avl.c']]], + ['ucx_5favl_5fnew_5fa',['ucx_avl_new_a',['../avl_8h.html#af0f868d67e9dc08b4867c02a06c23ee2',1,'avl.c']]], + ['ucx_5favl_5fpred',['ucx_avl_pred',['../avl_8h.html#a0e739aeb66dda6a6a3f6eb51b50cf346',1,'avl.c']]], + ['ucx_5favl_5fput',['ucx_avl_put',['../avl_8h.html#aec401fab4a24a7edffa734f9baf88577',1,'avl.c']]], + ['ucx_5favl_5fput_5fs',['ucx_avl_put_s',['../avl_8h.html#a32cf8955cc0226a82bacfc7b76d6474c',1,'avl.c']]], + ['ucx_5favl_5fremove',['ucx_avl_remove',['../avl_8h.html#a1d821119c805d7fbb7e424bc3effeba9',1,'avl.c']]], + ['ucx_5favl_5fremove_5fnode',['ucx_avl_remove_node',['../avl_8h.html#a9a792b7d9e58073deef74a341f8bc720',1,'avl.c']]], + ['ucx_5favl_5fremove_5fs',['ucx_avl_remove_s',['../avl_8h.html#a01aeeecd6415f0cc2b623486eb28f254',1,'avl.c']]], + ['ucx_5favl_5fsucc',['ucx_avl_succ',['../avl_8h.html#aab1ad9b027ff5e50671aa0ee84e2d541',1,'avl.c']]], + ['ucx_5fbuffer_5feof',['ucx_buffer_eof',['../buffer_8h.html#abad7fd9ad5061224c780b8d1d4c55f09',1,'buffer.c']]], + ['ucx_5fbuffer_5fextend',['ucx_buffer_extend',['../buffer_8h.html#afaf97d2cd7e9faad79a9d35fe33e30c6',1,'buffer.c']]], + ['ucx_5fbuffer_5fextract',['ucx_buffer_extract',['../buffer_8h.html#a33fa7bb35fe08bbb3542f227514332ef',1,'buffer.c']]], + ['ucx_5fbuffer_5ffree',['ucx_buffer_free',['../buffer_8h.html#a2af8646d8905c22c7322e7540b0440af',1,'buffer.c']]], + ['ucx_5fbuffer_5fgetc',['ucx_buffer_getc',['../buffer_8h.html#a396339022159ce4ca6d069de9f9209b0',1,'buffer.c']]], + ['ucx_5fbuffer_5fnew',['ucx_buffer_new',['../buffer_8h.html#aacea876d692193ec6f859ce98da7351c',1,'buffer.c']]], + ['ucx_5fbuffer_5fputc',['ucx_buffer_putc',['../buffer_8h.html#a7d6f01b9d631b0123475dfb98fb849ac',1,'buffer.c']]], + ['ucx_5fbuffer_5fputs',['ucx_buffer_puts',['../buffer_8h.html#af1d4b478e04b3ae0bf30e7c2ea964ea2',1,'buffer.c']]], + ['ucx_5fbuffer_5fread',['ucx_buffer_read',['../buffer_8h.html#ae5c3430759f0059547b35d5a254d4da5',1,'buffer.c']]], + ['ucx_5fbuffer_5fseek',['ucx_buffer_seek',['../buffer_8h.html#a47d98482662073c74f35deb0957d15d1',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift',['ucx_buffer_shift',['../buffer_8h.html#a12a0c6a2379ef080043e6286bb8bad69',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift_5fleft',['ucx_buffer_shift_left',['../buffer_8h.html#a20431dd0ed6a6fe9f15333bd72afe4db',1,'buffer.c']]], + ['ucx_5fbuffer_5fshift_5fright',['ucx_buffer_shift_right',['../buffer_8h.html#a4fa10b6471495547eb981248fd4f1bc2',1,'buffer.c']]], + ['ucx_5fbuffer_5fwrite',['ucx_buffer_write',['../buffer_8h.html#af8aacc7401814392b58c1b7b81bffc05',1,'buffer.c']]], + ['ucx_5fcmp_5fdouble',['ucx_cmp_double',['../utils_8h.html#ab804b7c27d0bfcd7bf3a3583140825b6',1,'utils.c']]], + ['ucx_5fcmp_5ffloat',['ucx_cmp_float',['../utils_8h.html#ad1196b561bcdad76c393885819769a97',1,'utils.c']]], + ['ucx_5fcmp_5fint',['ucx_cmp_int',['../utils_8h.html#a8ce7e11e6b3deafe89a32a091fde7f16',1,'utils.c']]], + ['ucx_5fcmp_5fint16',['ucx_cmp_int16',['../utils_8h.html#aa29e6e559946375e34113e34e0b0bd0d',1,'utils.c']]], + ['ucx_5fcmp_5fint32',['ucx_cmp_int32',['../utils_8h.html#a858b2ac443fb202643b71f6a7e9218dd',1,'utils.c']]], + ['ucx_5fcmp_5fint64',['ucx_cmp_int64',['../utils_8h.html#a54701aea6a89fed1402dfb0bf56bc7f6',1,'utils.c']]], + ['ucx_5fcmp_5flongint',['ucx_cmp_longint',['../utils_8h.html#aeb57a2b9a6aaa0460c7a6bec29accf2c',1,'utils.c']]], + ['ucx_5fcmp_5flonglong',['ucx_cmp_longlong',['../utils_8h.html#a366b57def20f86a41eaedf575eea5375',1,'utils.c']]], + ['ucx_5fcmp_5fmem',['ucx_cmp_mem',['../utils_8h.html#aff7d2bcded71196831a8c0664333f8e7',1,'utils.c']]], + ['ucx_5fcmp_5fptr',['ucx_cmp_ptr',['../utils_8h.html#aa174d539de3ea59be4f9640f17ce53d8',1,'utils.c']]], + ['ucx_5fcmp_5fsstr',['ucx_cmp_sstr',['../utils_8h.html#adee0739589166d272f8cb7c23aabf8ba',1,'utils.c']]], + ['ucx_5fcmp_5fstr',['ucx_cmp_str',['../utils_8h.html#aa6a37b9d172b6a5b2803d152f9e1b258',1,'utils.c']]], + ['ucx_5fcmp_5fstrn',['ucx_cmp_strn',['../utils_8h.html#ac6b354a878f551a3a5b20a167db3f308',1,'utils.c']]], + ['ucx_5fcmp_5fuint',['ucx_cmp_uint',['../utils_8h.html#abd83a5da91c3dd026a6931bd80c12f1e',1,'utils.c']]], + ['ucx_5fcmp_5fuint16',['ucx_cmp_uint16',['../utils_8h.html#acde5366437e886a459b7468f7a9e11f0',1,'utils.c']]], + ['ucx_5fcmp_5fuint32',['ucx_cmp_uint32',['../utils_8h.html#a5879d1722330355914d8c9146fa549d3',1,'utils.c']]], + ['ucx_5fcmp_5fuint64',['ucx_cmp_uint64',['../utils_8h.html#a1572a78b5b42f7151a5b2a5a7283d62d',1,'utils.c']]], + ['ucx_5fcmp_5fulongint',['ucx_cmp_ulongint',['../utils_8h.html#a3f3cbae2594d6f722bae29acb0408a24',1,'utils.c']]], + ['ucx_5fcmp_5fulonglong',['ucx_cmp_ulonglong',['../utils_8h.html#a6acfc359421f21f9a042a654ff7faac5',1,'utils.c']]], + ['ucx_5fdefault_5fallocator',['ucx_default_allocator',['../allocator_8h.html#a98d2f1b341118b7a0e341fda5d8b2ebf',1,'allocator.c']]], + ['ucx_5fdefault_5fcalloc',['ucx_default_calloc',['../allocator_8h.html#a3a0bfdd13d887012309c459b339f338f',1,'allocator.c']]], + ['ucx_5fdefault_5ffree',['ucx_default_free',['../allocator_8h.html#a646d83aaaadfe33ae414c0fad8bfc52a',1,'allocator.c']]], + ['ucx_5fdefault_5fmalloc',['ucx_default_malloc',['../allocator_8h.html#a96403ebf3d2312d95f2fe7627a1cdbc0',1,'allocator.c']]], + ['ucx_5fdefault_5frealloc',['ucx_default_realloc',['../allocator_8h.html#a47cfc8af626a86fcb93a2b14b90498ed',1,'allocator.c']]], + ['ucx_5fdist_5fint',['ucx_dist_int',['../utils_8h.html#a4ab6753739d56c09cdf6079fdcabf7c6',1,'utils.c']]], + ['ucx_5fdist_5fint16',['ucx_dist_int16',['../utils_8h.html#a81fb8434b70ca11bf2c14abfa21d16a9',1,'utils.c']]], + ['ucx_5fdist_5fint32',['ucx_dist_int32',['../utils_8h.html#ab4a659cc46096f0490c1dafa57726476',1,'utils.c']]], + ['ucx_5fdist_5fint64',['ucx_dist_int64',['../utils_8h.html#a54e7d06585bad3a899befc4e9c13853f',1,'utils.c']]], + ['ucx_5fdist_5flongint',['ucx_dist_longint',['../utils_8h.html#a43e73d288b1553a0078bf4c98dd341f5',1,'utils.c']]], + ['ucx_5fdist_5flonglong',['ucx_dist_longlong',['../utils_8h.html#a306778414a2427951ea263be92368627',1,'utils.c']]], + ['ucx_5fdist_5fuint',['ucx_dist_uint',['../utils_8h.html#a37b7d471ca1679992afc11a0deda45f4',1,'utils.c']]], + ['ucx_5fdist_5fuint16',['ucx_dist_uint16',['../utils_8h.html#a66e00a0703cbcde050ec922578e2f080',1,'utils.c']]], + ['ucx_5fdist_5fuint32',['ucx_dist_uint32',['../utils_8h.html#add2b5c5507caba59d894b84e056b079b',1,'utils.c']]], + ['ucx_5fdist_5fuint64',['ucx_dist_uint64',['../utils_8h.html#a3ba75e2e0b2479eef2b22fb219b42da7',1,'utils.c']]], + ['ucx_5fdist_5fulongint',['ucx_dist_ulongint',['../utils_8h.html#abb13476228d0c16bfaba08469adbae2d',1,'utils.c']]], + ['ucx_5fdist_5fulonglong',['ucx_dist_ulonglong',['../utils_8h.html#a59a5859272cb4b43cbdd58208c41e32b',1,'utils.c']]], + ['ucx_5ffprintf',['ucx_fprintf',['../utils_8h.html#aa0bec80e1c67f769ff5e112a7d4ce72a',1,'utils.c']]], + ['ucx_5fhash',['ucx_hash',['../map_8h.html#aea3be97254c05595d986ef6a9faae87b',1,'map.c']]], + ['ucx_5fkey',['ucx_key',['../map_8h.html#a3e540bb46b8ee19789aed63fd8919200',1,'map.c']]], + ['ucx_5flist_5fappend',['ucx_list_append',['../list_8h.html#a00c122c8a26d35b60676939df4161621',1,'list.c']]], + ['ucx_5flist_5fappend_5fa',['ucx_list_append_a',['../list_8h.html#adf3b3e2e0ff977d8928671d6bd82fc60',1,'list.c']]], + ['ucx_5flist_5fclone',['ucx_list_clone',['../list_8h.html#ae7054a41c289b24e6caf5cb07ac850ed',1,'list.c']]], + ['ucx_5flist_5fclone_5fa',['ucx_list_clone_a',['../list_8h.html#a08ca1ba0d2e82258b0408714c1f4c425',1,'list.c']]], + ['ucx_5flist_5fconcat',['ucx_list_concat',['../list_8h.html#a77163a0cc82fae52bec26c8c0c3674d9',1,'list.c']]], + ['ucx_5flist_5fcontains',['ucx_list_contains',['../list_8h.html#a8b0fa051fcfe12e1a82cca1087973852',1,'list.c']]], + ['ucx_5flist_5fdifference',['ucx_list_difference',['../list_8h.html#a6c5db5d1d11ad28b6fe1a80ee1c1e449',1,'list.c']]], + ['ucx_5flist_5fdifference_5fa',['ucx_list_difference_a',['../list_8h.html#a4a2a2fc5cc41073c516db6235bbc51d5',1,'list.c']]], + ['ucx_5flist_5fequals',['ucx_list_equals',['../list_8h.html#adc435447cecf885bc63d232191085bbe',1,'list.c']]], + ['ucx_5flist_5ffind',['ucx_list_find',['../list_8h.html#a9b3b6842d3be572e06a7f519e198cb83',1,'list.c']]], + ['ucx_5flist_5ffirst',['ucx_list_first',['../list_8h.html#a6aa0e34ebc5f0dca6f52d0f7626b4bd5',1,'list.c']]], + ['ucx_5flist_5ffree',['ucx_list_free',['../list_8h.html#a1a0fa2c5b1e478a96da19b0c3f013668',1,'list.c']]], + ['ucx_5flist_5ffree_5fa',['ucx_list_free_a',['../list_8h.html#a944e11f76c38767cd1100d72a4e3b25b',1,'list.c']]], + ['ucx_5flist_5ffree_5fcontent',['ucx_list_free_content',['../list_8h.html#a4ba6c96642f72ea046cc22627c72979c',1,'list.c']]], + ['ucx_5flist_5fget',['ucx_list_get',['../list_8h.html#a2509ffe19bce6a8708c77f89480c75fb',1,'list.c']]], + ['ucx_5flist_5findexof',['ucx_list_indexof',['../list_8h.html#ae2ff2974812ca185870f80bc4ed9337e',1,'list.c']]], + ['ucx_5flist_5fintersection',['ucx_list_intersection',['../list_8h.html#a259f9b754978aeca23dfabba16e20f39',1,'list.c']]], + ['ucx_5flist_5fintersection_5fa',['ucx_list_intersection_a',['../list_8h.html#a1d0b00514dbb81ba6270b58da0c5b9a8',1,'list.c']]], + ['ucx_5flist_5flast',['ucx_list_last',['../list_8h.html#add5ec40c5006e29c629d23c2eb5a6553',1,'list.c']]], + ['ucx_5flist_5fprepend',['ucx_list_prepend',['../list_8h.html#a8fcb68e4556395b15180eec2d0b77aa4',1,'list.c']]], + ['ucx_5flist_5fprepend_5fa',['ucx_list_prepend_a',['../list_8h.html#a54654e6dc60e1c3de9e886c150e404ec',1,'list.c']]], + ['ucx_5flist_5fremove',['ucx_list_remove',['../list_8h.html#a410cb3e8260037ba56c72d14b899b468',1,'list.c']]], + ['ucx_5flist_5fremove_5fa',['ucx_list_remove_a',['../list_8h.html#aca687b7c4e7170175f447e549125aa52',1,'list.c']]], + ['ucx_5flist_5fsize',['ucx_list_size',['../list_8h.html#ae88001cc8ae40b946560f31434abed8f',1,'list.c']]], + ['ucx_5flist_5fsort',['ucx_list_sort',['../list_8h.html#ac74962d9bd7cfc9d3e2e09651469377b',1,'list.c']]], + ['ucx_5flist_5funion',['ucx_list_union',['../list_8h.html#a94ecdb0cea1633ad7074f027fa8485fa',1,'list.c']]], + ['ucx_5flist_5funion_5fa',['ucx_list_union_a',['../list_8h.html#a65b4355536f4ebc4130211b46469f4c1',1,'list.c']]], + ['ucx_5flogger_5ffree',['ucx_logger_free',['../logging_8h.html#ac4697b784e01ec990d2acea192e21658',1,'logging.c']]], + ['ucx_5flogger_5flogf',['ucx_logger_logf',['../logging_8h.html#ac337e5d02ebea565012d4c11bd643801',1,'logging.c']]], + ['ucx_5flogger_5fnew',['ucx_logger_new',['../logging_8h.html#ac560f8517d2172794c9d2691735ec48c',1,'logging.c']]], + ['ucx_5fmap_5fclear',['ucx_map_clear',['../map_8h.html#a285e90e40681c6d9631c935dda0967f2',1,'map.c']]], + ['ucx_5fmap_5fclone',['ucx_map_clone',['../map_8h.html#a62c6c30cbb0d824ba710f5030ff9a4e4',1,'map.c']]], + ['ucx_5fmap_5fclone_5fa',['ucx_map_clone_a',['../map_8h.html#a9aea9103703d5c168420bb6bf85549ea',1,'map.c']]], + ['ucx_5fmap_5fcopy',['ucx_map_copy',['../map_8h.html#adfeb2d61003fd2896bcfdc9a57f36425',1,'map.c']]], + ['ucx_5fmap_5fdifference',['ucx_map_difference',['../map_8h.html#a774fcff87d1e58b6c5af77dd19a8c3dc',1,'map.c']]], + ['ucx_5fmap_5fdifference_5fa',['ucx_map_difference_a',['../map_8h.html#ad0ba103494247d798ac3037c50fc8831',1,'map.c']]], + ['ucx_5fmap_5ffree',['ucx_map_free',['../map_8h.html#abe3d9688e4224bf7bb962abf25ff8c2e',1,'map.c']]], + ['ucx_5fmap_5ffree_5fcontent',['ucx_map_free_content',['../map_8h.html#a750f3d9d83e2f3788a14c17a9d160618',1,'map.c']]], + ['ucx_5fmap_5fget',['ucx_map_get',['../map_8h.html#ab61192c5af2e06ecb9ad73880d1c95a6',1,'map.c']]], + ['ucx_5fmap_5fintersection',['ucx_map_intersection',['../map_8h.html#aa594d7a5afebc3bed6bb265348cf6b0d',1,'map.c']]], + ['ucx_5fmap_5fintersection_5fa',['ucx_map_intersection_a',['../map_8h.html#a169e0470a20484dd76425fdf77e3651e',1,'map.c']]], + ['ucx_5fmap_5fiter_5fnext',['ucx_map_iter_next',['../map_8h.html#aceb8675abf44860b4bbc301bbada5b91',1,'map.c']]], + ['ucx_5fmap_5fiterator',['ucx_map_iterator',['../map_8h.html#a9150e9c64fdf4dfcc2cad106b91aa110',1,'map.c']]], + ['ucx_5fmap_5fnew',['ucx_map_new',['../map_8h.html#a79f31de8b93814493759dbc8b940cf0c',1,'map.c']]], + ['ucx_5fmap_5fnew_5fa',['ucx_map_new_a',['../map_8h.html#aed508a94c66cc15372503c64b70eb03e',1,'map.c']]], + ['ucx_5fmap_5fput',['ucx_map_put',['../map_8h.html#ac04a08b604217070254d4c58f0e82498',1,'map.c']]], + ['ucx_5fmap_5frehash',['ucx_map_rehash',['../map_8h.html#a174bce9fad554dd92b8da354e0d32512',1,'map.c']]], + ['ucx_5fmap_5fremove',['ucx_map_remove',['../map_8h.html#a17248a4888eb8f9ae18be522d64632aa',1,'map.c']]], + ['ucx_5fmap_5funion',['ucx_map_union',['../map_8h.html#a3f65978c481af7f637cad021d93522d5',1,'map.c']]], + ['ucx_5fmap_5funion_5fa',['ucx_map_union_a',['../map_8h.html#ab6370c3fa8113fdad593ce4b0460c9c6',1,'map.c']]], + ['ucx_5fmemcpy',['ucx_memcpy',['../utils_8h.html#ab2e184e6a744941aab6b8058116baf30',1,'utils.c']]], + ['ucx_5fmempool_5fcalloc',['ucx_mempool_calloc',['../mempool_8h.html#a4b9142011824ae24f00fabe128417d69',1,'mempool.c']]], + ['ucx_5fmempool_5fchcap',['ucx_mempool_chcap',['../mempool_8h.html#aaf75b5016098723a9280531ccc3a6d77',1,'mempool.c']]], + ['ucx_5fmempool_5fdestroy',['ucx_mempool_destroy',['../mempool_8h.html#af096378da7e9bfbed3088497cf4c15bf',1,'mempool.c']]], + ['ucx_5fmempool_5ffree',['ucx_mempool_free',['../mempool_8h.html#aefa26e3015f5aefadbfc74221bd246ac',1,'mempool.c']]], + ['ucx_5fmempool_5fmalloc',['ucx_mempool_malloc',['../mempool_8h.html#a2ae492b8f2878ccc9837ac213dced11e',1,'mempool.c']]], + ['ucx_5fmempool_5fnew',['ucx_mempool_new',['../mempool_8h.html#ad71cb8c3b6fdb30360376a8b372ef22a',1,'mempool.c']]], + ['ucx_5fmempool_5frealloc',['ucx_mempool_realloc',['../mempool_8h.html#a660ef42520ed6737c2e77aae18e3a7a4',1,'mempool.c']]], + ['ucx_5fmempool_5freg_5fdestr',['ucx_mempool_reg_destr',['../mempool_8h.html#af47b6b7c40f8f263dc28cc9a4e77b27c',1,'mempool.c']]], + ['ucx_5fmempool_5fset_5fdestr',['ucx_mempool_set_destr',['../mempool_8h.html#adb788e7ec24cd7dbdea6381539c549f2',1,'mempool.c']]], + ['ucx_5fproperties2map',['ucx_properties2map',['../properties_8h.html#a5c7ff8bc3139960a3f3dc92072b742f3',1,'properties.c']]], + ['ucx_5fproperties_5ffill',['ucx_properties_fill',['../properties_8h.html#aaf8de121764a4d22c763ff2ab41f3a4d',1,'properties.c']]], + ['ucx_5fproperties_5ffree',['ucx_properties_free',['../properties_8h.html#a38a2fe7bb2986bd87c7e69356ab05c05',1,'properties.c']]], + ['ucx_5fproperties_5fload',['ucx_properties_load',['../properties_8h.html#ae1b600f839a6b2278b68fc314981a8a3',1,'properties.c']]], + ['ucx_5fproperties_5fnew',['ucx_properties_new',['../properties_8h.html#a44d9dd12cab3aaa0084f1c8b89405796',1,'properties.c']]], + ['ucx_5fproperties_5fnext',['ucx_properties_next',['../properties_8h.html#a7e03bc573d45d48c538cd721e810d33c',1,'properties.c']]], + ['ucx_5fproperties_5fstore',['ucx_properties_store',['../properties_8h.html#a63c0c1b7648e675b21a1788917ff36fb',1,'properties.c']]], + ['ucx_5fsc2sc',['ucx_sc2sc',['../string_8h.html#a69d5e3eeec783cc43314df71248768f5',1,'string.c']]], + ['ucx_5fss2c_5fs',['ucx_ss2c_s',['../string_8h.html#aedeb5d7bddda54116101a8d68af8c56d',1,'string.h']]], + ['ucx_5fss2sc',['ucx_ss2sc',['../string_8h.html#a9ce5ad1b2aa2dbeba204d452c2e64359',1,'string.c']]], + ['ucx_5fstack_5favail',['ucx_stack_avail',['../stack_8h.html#a53cd2c7743dc8ad9cbd35ade0b4873e7',1,'stack.c']]], + ['ucx_5fstack_5fcalloc',['ucx_stack_calloc',['../stack_8h.html#afdc467524b5e19a9a777c6bc03e17174',1,'stack.c']]], + ['ucx_5fstack_5ffree',['ucx_stack_free',['../stack_8h.html#aabd55c14a3866b3782ba324f4d8b4c41',1,'stack.c']]], + ['ucx_5fstack_5finit',['ucx_stack_init',['../stack_8h.html#abaef685df4e7ef95cd7218984a0618fe',1,'stack.c']]], + ['ucx_5fstack_5fmalloc',['ucx_stack_malloc',['../stack_8h.html#af865b416802140f6b6e8ab3626d7d1ac',1,'stack.c']]], + ['ucx_5fstack_5fpopn',['ucx_stack_popn',['../stack_8h.html#a07ea48f28eab474dcfefbb86fa66ef81',1,'stack.c']]], + ['ucx_5fstack_5fpush',['ucx_stack_push',['../stack_8h.html#af85e6f77a8341beb6188f9ae1a8e9f92',1,'stack.c']]], + ['ucx_5fstack_5fpusharr',['ucx_stack_pusharr',['../stack_8h.html#a7bb138979191bba138e76ea37488fae2',1,'stack.c']]], + ['ucx_5fstack_5frealloc',['ucx_stack_realloc',['../stack_8h.html#a0c678f96f6fabab49b2b034a1fe91c3a',1,'stack.c']]], + ['ucx_5fstrcpy',['ucx_strcpy',['../utils_8h.html#adeb6e8d0a53a829207cfa0a979d01fff',1,'utils.c']]], + ['ucx_5fstream_5fbncopy',['ucx_stream_bncopy',['../utils_8h.html#a114ee7f7da62656ffd35e2dc23394201',1,'utils.c']]], + ['ucx_5fszmul_5fimpl',['ucx_szmul_impl',['../ucx_8h.html#a6637171cc0ec097b297f731a3036dd3b',1,'ucx.c']]], + ['ucx_5ftest_5fregister',['ucx_test_register',['../test_8h.html#a8dfabc42f183d3a4d79379a5d17bf67d',1,'test.c']]], + ['ucx_5ftest_5frun',['ucx_test_run',['../test_8h.html#a3721458deeecb43aa322428f007714c3',1,'test.c']]], + ['ucx_5ftest_5fsuite_5ffree',['ucx_test_suite_free',['../test_8h.html#a4a6ac61a6f72722273f8eaa7a343edde',1,'test.c']]], + ['ucx_5ftest_5fsuite_5fnew',['ucx_test_suite_new',['../test_8h.html#a531f0df90363e0befbe900878f65f09e',1,'test.c']]], + ['ucx_5fvasprintf',['ucx_vasprintf',['../utils_8h.html#a3ea1dfb856c741f3e8ec6bfdc9ad427e',1,'utils.c']]], + ['ucx_5fvfprintf',['ucx_vfprintf',['../utils_8h.html#a4907967beb92c3ae351dd239abbb6927',1,'utils.c']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/mag_sel.png Binary file docs/api-2.1/search/mag_sel.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/nomatches.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/nomatches.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,12 @@ + + + + + + + +
    +
    No Matches
    +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/pages_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/pages_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/pages_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/pages_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['uap_20common_20extensions',['UAP Common Extensions',['../index.html',1,'']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/search.css --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/search.css Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,271 @@ +/*---------------- Search Box */ + +#FSearchBox { + float: left; +} + +#MSearchBox { + white-space : nowrap; + float: none; + margin-top: 8px; + right: 0px; + width: 170px; + height: 24px; + z-index: 102; +} + +#MSearchBox .left +{ + display:block; + position:absolute; + left:10px; + width:20px; + height:19px; + background:url('search_l.png') no-repeat; + background-position:right; +} + +#MSearchSelect { + display:block; + position:absolute; + width:20px; + height:19px; +} + +.left #MSearchSelect { + left:4px; +} + +.right #MSearchSelect { + right:5px; +} + +#MSearchField { + display:block; + position:absolute; + height:19px; + background:url('search_m.png') repeat-x; + border:none; + width:115px; + margin-left:20px; + padding-left:4px; + color: #909090; + outline: none; + font: 9pt Arial, Verdana, sans-serif; + -webkit-border-radius: 0px; +} + +#FSearchBox #MSearchField { + margin-left:15px; +} + +#MSearchBox .right { + display:block; + position:absolute; + right:10px; + top:8px; + width:20px; + height:19px; + background:url('search_r.png') no-repeat; + background-position:left; +} + +#MSearchClose { + display: none; + position: absolute; + top: 4px; + background : none; + border: none; + margin: 0px 4px 0px 0px; + padding: 0px 0px; + outline: none; +} + +.left #MSearchClose { + left: 6px; +} + +.right #MSearchClose { + right: 2px; +} + +.MSearchBoxActive #MSearchField { + color: #000000; +} + +/*---------------- Search filter selection */ + +#MSearchSelectWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid #90A5CE; + background-color: #F9FAFC; + z-index: 10001; + padding-top: 4px; + padding-bottom: 4px; + -moz-border-radius: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +.SelectItem { + font: 8pt Arial, Verdana, sans-serif; + padding-left: 2px; + padding-right: 12px; + border: 0px; +} + +span.SelectionMark { + margin-right: 4px; + font-family: monospace; + outline-style: none; + text-decoration: none; +} + +a.SelectItem { + display: block; + outline-style: none; + color: #000000; + text-decoration: none; + padding-left: 6px; + padding-right: 12px; +} + +a.SelectItem:focus, +a.SelectItem:active { + color: #000000; + outline-style: none; + text-decoration: none; +} + +a.SelectItem:hover { + color: #FFFFFF; + background-color: #3D578C; + outline-style: none; + text-decoration: none; + cursor: pointer; + display: block; +} + +/*---------------- Search results window */ + +iframe#MSearchResults { + width: 60ex; + height: 15em; +} + +#MSearchResultsWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid #000; + background-color: #EEF1F7; + z-index:10000; +} + +/* ----------------------------------- */ + + +#SRIndex { + clear:both; + padding-bottom: 15px; +} + +.SREntry { + font-size: 10pt; + padding-left: 1ex; +} + +.SRPage .SREntry { + font-size: 8pt; + padding: 1px 5px; +} + +body.SRPage { + margin: 5px 2px; +} + +.SRChildren { + padding-left: 3ex; padding-bottom: .5em +} + +.SRPage .SRChildren { + display: none; +} + +.SRSymbol { + font-weight: bold; + color: #425E97; + font-family: Arial, Verdana, sans-serif; + text-decoration: none; + outline: none; +} + +a.SRScope { + display: block; + color: #425E97; + font-family: Arial, Verdana, sans-serif; + text-decoration: none; + outline: none; +} + +a.SRSymbol:focus, a.SRSymbol:active, +a.SRScope:focus, a.SRScope:active { + text-decoration: underline; +} + +span.SRScope { + padding-left: 4px; +} + +.SRPage .SRStatus { + padding: 2px 5px; + font-size: 8pt; + font-style: italic; +} + +.SRResult { + display: none; +} + +DIV.searchresults { + margin-left: 10px; + margin-right: 10px; +} + +/*---------------- External search page results */ + +.searchresult { + background-color: #F0F3F8; +} + +.pages b { + color: white; + padding: 5px 5px 3px 5px; + background-image: url("../tab_a.png"); + background-repeat: repeat-x; + text-shadow: 0 1px 1px #000000; +} + +.pages { + line-height: 17px; + margin-left: 4px; + text-decoration: none; +} + +.hl { + font-weight: bold; +} + +#searchresults { + margin-bottom: 20px; +} + +.searchpages { + margin-top: 10px; +} + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/search.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/search.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,791 @@ +function convertToId(search) +{ + var result = ''; + for (i=0;i do a search + { + this.Search(); + } + } + + this.OnSearchSelectKey = function(evt) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==40 && this.searchIndex0) // Up + { + this.searchIndex--; + this.OnSelectItem(this.searchIndex); + } + else if (e.keyCode==13 || e.keyCode==27) + { + this.OnSelectItem(this.searchIndex); + this.CloseSelectionWindow(); + this.DOMSearchField().focus(); + } + return false; + } + + // --------- Actions + + // Closes the results window. + this.CloseResultsWindow = function() + { + this.DOMPopupSearchResultsWindow().style.display = 'none'; + this.DOMSearchClose().style.display = 'none'; + this.Activate(false); + } + + this.CloseSelectionWindow = function() + { + this.DOMSearchSelectWindow().style.display = 'none'; + } + + // Performs a search. + this.Search = function() + { + this.keyTimeout = 0; + + // strip leading whitespace + var searchValue = this.DOMSearchField().value.replace(/^ +/, ""); + + var code = searchValue.toLowerCase().charCodeAt(0); + var idxChar = searchValue.substr(0, 1).toLowerCase(); + if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair + { + idxChar = searchValue.substr(0, 2); + } + + var resultsPage; + var resultsPageWithSearch; + var hasResultsPage; + + var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar); + if (idx!=-1) + { + var hexCode=idx.toString(16); + resultsPage = this.resultsPath + '/' + indexSectionNames[this.searchIndex] + '_' + hexCode + '.html'; + resultsPageWithSearch = resultsPage+'?'+escape(searchValue); + hasResultsPage = true; + } + else // nothing available for this search term + { + resultsPage = this.resultsPath + '/nomatches.html'; + resultsPageWithSearch = resultsPage; + hasResultsPage = false; + } + + window.frames.MSearchResults.location = resultsPageWithSearch; + var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow(); + + if (domPopupSearchResultsWindow.style.display!='block') + { + var domSearchBox = this.DOMSearchBox(); + this.DOMSearchClose().style.display = 'inline'; + if (this.insideFrame) + { + var domPopupSearchResults = this.DOMPopupSearchResults(); + domPopupSearchResultsWindow.style.position = 'relative'; + domPopupSearchResultsWindow.style.display = 'block'; + var width = document.body.clientWidth - 8; // the -8 is for IE :-( + domPopupSearchResultsWindow.style.width = width + 'px'; + domPopupSearchResults.style.width = width + 'px'; + } + else + { + var domPopupSearchResults = this.DOMPopupSearchResults(); + var left = getXPos(domSearchBox) + 150; // domSearchBox.offsetWidth; + var top = getYPos(domSearchBox) + 20; // domSearchBox.offsetHeight + 1; + domPopupSearchResultsWindow.style.display = 'block'; + left -= domPopupSearchResults.offsetWidth; + domPopupSearchResultsWindow.style.top = top + 'px'; + domPopupSearchResultsWindow.style.left = left + 'px'; + } + } + + this.lastSearchValue = searchValue; + this.lastResultsPage = resultsPage; + } + + // -------- Activation Functions + + // Activates or deactivates the search panel, resetting things to + // their default values if necessary. + this.Activate = function(isActive) + { + if (isActive || // open it + this.DOMPopupSearchResultsWindow().style.display == 'block' + ) + { + this.DOMSearchBox().className = 'MSearchBoxActive'; + + var searchField = this.DOMSearchField(); + + if (searchField.value == this.searchLabel) // clear "Search" term upon entry + { + searchField.value = ''; + this.searchActive = true; + } + } + else if (!isActive) // directly remove the panel + { + this.DOMSearchBox().className = 'MSearchBoxInactive'; + this.DOMSearchField().value = this.searchLabel; + this.searchActive = false; + this.lastSearchValue = '' + this.lastResultsPage = ''; + } + } +} + +// ----------------------------------------------------------------------- + +// The class that handles everything on the search results page. +function SearchResults(name) +{ + // The number of matches from the last run of . + this.lastMatchCount = 0; + this.lastKey = 0; + this.repeatOn = false; + + // Toggles the visibility of the passed element ID. + this.FindChildElement = function(id) + { + var parentElement = document.getElementById(id); + var element = parentElement.firstChild; + + while (element && element!=parentElement) + { + if (element.nodeName == 'DIV' && element.className == 'SRChildren') + { + return element; + } + + if (element.nodeName == 'DIV' && element.hasChildNodes()) + { + element = element.firstChild; + } + else if (element.nextSibling) + { + element = element.nextSibling; + } + else + { + do + { + element = element.parentNode; + } + while (element && element!=parentElement && !element.nextSibling); + + if (element && element!=parentElement) + { + element = element.nextSibling; + } + } + } + } + + this.Toggle = function(id) + { + var element = this.FindChildElement(id); + if (element) + { + if (element.style.display == 'block') + { + element.style.display = 'none'; + } + else + { + element.style.display = 'block'; + } + } + } + + // Searches for the passed string. If there is no parameter, + // it takes it from the URL query. + // + // Always returns true, since other documents may try to call it + // and that may or may not be possible. + this.Search = function(search) + { + if (!search) // get search word from URL + { + search = window.location.search; + search = search.substring(1); // Remove the leading '?' + search = unescape(search); + } + + search = search.replace(/^ +/, ""); // strip leading spaces + search = search.replace(/ +$/, ""); // strip trailing spaces + search = search.toLowerCase(); + search = convertToId(search); + + var resultRows = document.getElementsByTagName("div"); + var matches = 0; + + var i = 0; + while (i < resultRows.length) + { + var row = resultRows.item(i); + if (row.className == "SRResult") + { + var rowMatchName = row.id.toLowerCase(); + rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_' + + if (search.length<=rowMatchName.length && + rowMatchName.substr(0, search.length)==search) + { + row.style.display = 'block'; + matches++; + } + else + { + row.style.display = 'none'; + } + } + i++; + } + document.getElementById("Searching").style.display='none'; + if (matches == 0) // no results + { + document.getElementById("NoMatches").style.display='block'; + } + else // at least one result + { + document.getElementById("NoMatches").style.display='none'; + } + this.lastMatchCount = matches; + return true; + } + + // return the first item with index index or higher that is visible + this.NavNext = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index++; + } + return focusItem; + } + + this.NavPrev = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index--; + } + return focusItem; + } + + this.ProcessKeys = function(e) + { + if (e.type == "keydown") + { + this.repeatOn = false; + this.lastKey = e.keyCode; + } + else if (e.type == "keypress") + { + if (!this.repeatOn) + { + if (this.lastKey) this.repeatOn = true; + return false; // ignore first keypress after keydown + } + } + else if (e.type == "keyup") + { + this.lastKey = 0; + this.repeatOn = false; + } + return this.lastKey!=0; + } + + this.Nav = function(evt,itemIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + var newIndex = itemIndex-1; + var focusItem = this.NavPrev(newIndex); + if (focusItem) + { + var child = this.FindChildElement(focusItem.parentNode.parentNode.id); + if (child && child.style.display == 'block') // children visible + { + var n=0; + var tmpElem; + while (1) // search for last child + { + tmpElem = document.getElementById('Item'+newIndex+'_c'+n); + if (tmpElem) + { + focusItem = tmpElem; + } + else // found it! + { + break; + } + n++; + } + } + } + if (focusItem) + { + focusItem.focus(); + } + else // return focus to search field + { + parent.document.getElementById("MSearchField").focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = itemIndex+1; + var focusItem; + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem && elem.style.display == 'block') // children visible + { + focusItem = document.getElementById('Item'+itemIndex+'_c0'); + } + if (!focusItem) focusItem = this.NavNext(newIndex); + if (focusItem) focusItem.focus(); + } + else if (this.lastKey==39) // Right + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'block'; + } + else if (this.lastKey==37) // Left + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'none'; + } + else if (this.lastKey==27) // Escape + { + parent.searchBox.CloseResultsWindow(); + parent.document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } + + this.NavChild = function(evt,itemIndex,childIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + if (childIndex>0) + { + var newIndex = childIndex-1; + document.getElementById('Item'+itemIndex+'_c'+newIndex).focus(); + } + else // already at first child, jump to parent + { + document.getElementById('Item'+itemIndex).focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = childIndex+1; + var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex); + if (!elem) // last child, jump to parent next parent + { + elem = this.NavNext(itemIndex+1); + } + if (elem) + { + elem.focus(); + } + } + else if (this.lastKey==27) // Escape + { + parent.searchBox.CloseResultsWindow(); + parent.document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } +} + +function setKeyActions(elem,action) +{ + elem.setAttribute('onkeydown',action); + elem.setAttribute('onkeypress',action); + elem.setAttribute('onkeyup',action); +} + +function setClassAttr(elem,attr) +{ + elem.setAttribute('class',attr); + elem.setAttribute('className',attr); +} + +function createResults() +{ + var results = document.getElementById("SRResults"); + for (var e=0; e + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['cmp_5ffunc',['cmp_func',['../ucx_8h.html#afe5e2d5dbf34778e0e97852051570791',1,'ucx.h']]], + ['copy_5ffunc',['copy_func',['../ucx_8h.html#aab917a5fe0965673c73e8ebd0a1fc967',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['distance_5ffunc',['distance_func',['../ucx_8h.html#a0bc5bf89e556c1d45d10863d52728ac9',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_2.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_2.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['read_5ffunc',['read_func',['../ucx_8h.html#a6a67e255e460acb58f802067b3ff5fd5',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_3.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_3.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_3.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_3.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,17 @@ +var searchData= +[ + ['ucx_5fallocator_5fcalloc',['ucx_allocator_calloc',['../allocator_8h.html#a2c0aba4221c1ac6801f03ed799f15b12',1,'allocator.h']]], + ['ucx_5fallocator_5ffree',['ucx_allocator_free',['../allocator_8h.html#aaf2387ddaddd8ab4b267e6b00e5d6f7e',1,'allocator.h']]], + ['ucx_5fallocator_5fmalloc',['ucx_allocator_malloc',['../allocator_8h.html#a29f0f6a23a70db3b60635cd6dc384473',1,'allocator.h']]], + ['ucx_5fallocator_5frealloc',['ucx_allocator_realloc',['../allocator_8h.html#a6d7cf038a806e327c5da37321d04e426',1,'allocator.h']]], + ['ucx_5fdestructor',['ucx_destructor',['../ucx_8h.html#ad2b370c2809914c8b7fedab163c266b3',1,'ucx.h']]], + ['ucxavlnode',['UcxAVLNode',['../avl_8h.html#a08ba2496c2316df58548c3cc29712add',1,'avl.h']]], + ['ucxkey',['UcxKey',['../map_8h.html#ad63828bb23123fc01a5315a2bac3b142',1,'map.h']]], + ['ucxlist',['UcxList',['../list_8h.html#aa6f89f91c1081c9a7c6866c298f497a2',1,'list.h']]], + ['ucxmap',['UcxMap',['../map_8h.html#a18e21948725b2da68c35da587a722033',1,'map.h']]], + ['ucxmapelement',['UcxMapElement',['../map_8h.html#ad7d7a910a32113eb93eae11c3dc97b4b',1,'map.h']]], + ['ucxmapiterator',['UcxMapIterator',['../map_8h.html#ae36aff5f645948c54f51578b11fd87fb',1,'map.h']]], + ['ucxtest',['UcxTest',['../test_8h.html#ae906817354c010b83c2784260cce7a1c',1,'test.h']]], + ['ucxtestlist',['UcxTestList',['../test_8h.html#a8048c50ae73ea690b776edfd63bd6a5d',1,'test.h']]], + ['ucxtestsuite',['UcxTestSuite',['../test_8h.html#a52115d1d0f1c4a565ed6ef7c1bfd0363',1,'test.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_4.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_4.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/typedefs_4.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/typedefs_4.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['write_5ffunc',['write_func',['../ucx_8h.html#a989b3f0fa4d307d278378fde435641ed',1,'ucx.h']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_0.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_0.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_0.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_0.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['allocator',['allocator',['../structUcxArray.html#a2ef31303b7548b9aa8e2b9187e295212',1,'UcxArray::allocator()'],['../structUcxAVLTree.html#a30652776b540156ad54c7d52833e4e28',1,'UcxAVLTree::allocator()'],['../structUcxMap.html#a531f3e481c1c331cf037b916192e974d',1,'UcxMap::allocator()'],['../structUcxMempool.html#ac45fd1e9269399e4c434d6bdaa770d92',1,'UcxMempool::allocator()'],['../structUcxStack.html#a33cda4f6890ac56ab31701598bc1ae10',1,'UcxStack::allocator()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_1.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_1.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_1.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_1.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['buffer',['buffer',['../structUcxProperties.html#a6bb4d29686df41a0f42641ee15232bfd',1,'UcxProperties']]], + ['buflen',['buflen',['../structUcxProperties.html#a4e7524434525267e29f493a25dcca6b5',1,'UcxProperties']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_10.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_10.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_10.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_10.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['userdata',['userdata',['../structUcxAVLTree.html#ae92a3bfad3fe33c8dcbdad85112f83fd',1,'UcxAVLTree']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_11.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_11.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_11.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_11.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['value',['value',['../structUcxAVLNode.html#a302501b8c04c3fde668fe72249871258',1,'UcxAVLNode']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_12.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_12.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_12.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_12.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['writer',['writer',['../structUcxLogger.html#ada13bba090a9dc4f8d6cd9be73c60930',1,'UcxLogger']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_2.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_2.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,12 @@ +var searchData= +[ + ['c',['c',['../structucx__memchunk.html#ab86550503e5f019bfa61a1e91f1c40da',1,'ucx_memchunk']]], + ['calloc',['calloc',['../structUcxAllocator.html#ab94ec1cba45cc4e7d81e1588a11cbb62',1,'UcxAllocator']]], + ['capacity',['capacity',['../structUcxArray.html#a7ed074887908e45bde7e1fbc67b31c18',1,'UcxArray::capacity()'],['../structUcxBuffer.html#a385661894f3cee9c549bfe07a8b316bf',1,'UcxBuffer::capacity()']]], + ['cmpfunc',['cmpfunc',['../structUcxAVLTree.html#a87aff25cb726cb9eb88eb815a10d1004',1,'UcxAVLTree']]], + ['comment1',['comment1',['../structUcxProperties.html#afaa2e6a289fa6949b7b01df35fa5def8',1,'UcxProperties']]], + ['comment2',['comment2',['../structUcxProperties.html#a9ea7ecb414ca8bc7bef62cdd19cc6363',1,'UcxProperties']]], + ['comment3',['comment3',['../structUcxProperties.html#a5f3e561e32bac03e36a191a6940cca92',1,'UcxProperties']]], + ['count',['count',['../structUcxMap.html#a14e9163f71f6c014dfa2103de70ae9cd',1,'UcxMap']]], + ['cur',['cur',['../structUcxMapIterator.html#af1fc40f899f37280adb5b85acf6e742f',1,'UcxMapIterator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_3.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_3.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_3.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_3.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,7 @@ +var searchData= +[ + ['data',['data',['../structUcxArray.html#a04d2b03d0a45af1fab19b4216602075a',1,'UcxArray::data()'],['../structUcxList.html#a4a44905121b6fc2a088084ce578a9ea2',1,'UcxList::data()'],['../structUcxKey.html#a6176109f25b34f3fa92bcfbc8ae7a88c',1,'UcxKey::data()'],['../structUcxMapKey.html#ab71d1841e4f538628c00f782267fb6d5',1,'UcxMapKey::data()'],['../structUcxMapElement.html#abbd7f3bf5beef370f702d2d5bb07733c',1,'UcxMapElement::data()'],['../structUcxMempool.html#ae98c1b0150bb119ee0a8506a6f310d6e',1,'UcxMempool::data()']]], + ['dateformat',['dateformat',['../structUcxLogger.html#a086f75df0f6c81ec491f25c0a4d9262b',1,'UcxLogger']]], + ['delimiter',['delimiter',['../structUcxProperties.html#af6adb3f69616cf9d2bb5ea7b4d837ca5',1,'UcxProperties']]], + ['destructor',['destructor',['../structucx__memchunk.html#ac7b5e3fda47b917d6fb2a1d7ea28447b',1,'ucx_memchunk::destructor()'],['../structucx__regdestr.html#acea2a3bb66909aa800a931ac8b0cce56',1,'ucx_regdestr::destructor()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_4.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_4.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_4.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_4.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['elemsize',['elemsize',['../structUcxArray.html#ac4e9ecdf8a8d010644f6e44dfef8190f',1,'UcxArray']]], + ['error',['error',['../structUcxProperties.html#a34f71a6ab6dcb6892e3b4eb802e75bff',1,'UcxProperties']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_5.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_5.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_5.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_5.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['failure',['failure',['../structUcxTestSuite.html#abfd240541d1e956e49cde0ac36286951',1,'UcxTestSuite']]], + ['flags',['flags',['../structUcxBuffer.html#ac642e07b0a03be5aac48eb4aa5bec2f7',1,'UcxBuffer']]], + ['free',['free',['../structUcxAllocator.html#aecce1840378ed53f1002190f4f87026f',1,'UcxAllocator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_6.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_6.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_6.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_6.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['hash',['hash',['../structUcxKey.html#aac9d372ac34a4cbd8459e2b04e505752',1,'UcxKey::hash()'],['../structUcxMapKey.html#a34c1f8fec98174583944fffd30e7c913',1,'UcxMapKey::hash()']]], + ['height',['height',['../structUcxAVLNode.html#af129fd32863a7c35e82c5cd9d11dc95a',1,'UcxAVLNode']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_7.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_7.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_7.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_7.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['index',['index',['../structUcxMapIterator.html#ac2376545c8816dd6895de4995e558c65',1,'UcxMapIterator']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_8.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_8.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_8.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_8.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,4 @@ +var searchData= +[ + ['key',['key',['../structUcxAVLNode.html#ab65a31010d26a3df898e6ba534702af6',1,'UcxAVLNode::key()'],['../structUcxMapElement.html#aa446141b708e106e2c8de1303318187c',1,'UcxMapElement::key()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_9.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_9.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_9.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_9.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,8 @@ +var searchData= +[ + ['left',['left',['../structUcxAVLNode.html#ad3a1c733f2c1cc81ac527f846fc24b9c',1,'UcxAVLNode']]], + ['len',['len',['../structUcxKey.html#abef01de37f355688f2ac797d2c280683',1,'UcxKey::len()'],['../structUcxMapKey.html#a504d46caa45c79cd87ff8cd835654270',1,'UcxMapKey::len()']]], + ['length',['length',['../structsstr__t.html#a5cf571708cdff92e45f08458f2b98229',1,'sstr_t::length()'],['../structscstr__t.html#aaa0229f64f1057b6f65adededaa5a172',1,'scstr_t::length()']]], + ['level',['level',['../structUcxLogger.html#a2e0ee94c25b2307096c7970280d189cd',1,'UcxLogger']]], + ['levels',['levels',['../structUcxLogger.html#a187129f7bc6e5064b3d92a5f1217f396',1,'UcxLogger']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_a.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_a.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_a.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_a.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['malloc',['malloc',['../structUcxAllocator.html#a013376172be39ed54f77c4be6898845a',1,'UcxAllocator']]], + ['map',['map',['../structUcxMap.html#a5792b5037c4f77ea3cb144b66c9b8790',1,'UcxMap::map()'],['../structUcxMapIterator.html#af88d6e22547d09fe1d665dd650dcdb95',1,'UcxMapIterator::map()']]], + ['mask',['mask',['../structUcxLogger.html#a1de0db2e02dcf03366268f6943f8b97c',1,'UcxLogger']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_b.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_b.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_b.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_b.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,5 @@ +var searchData= +[ + ['ndata',['ndata',['../structUcxMempool.html#aa3a73ab231e1bc207d526f46f1c1e23a',1,'UcxMempool']]], + ['next',['next',['../structUcxList.html#a82a1818f1abf765b026fa91478569a8f',1,'UcxList::next()'],['../structUcxMapElement.html#a99fe8188b0889201d70ff5f922deef51',1,'UcxMapElement::next()'],['../structUcxTestList.html#aeebb80ff75d9f6f82ab6dc2641a3c74e',1,'UcxTestList::next()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_c.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_c.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_c.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_c.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,8 @@ +var searchData= +[ + ['parent',['parent',['../structUcxAVLNode.html#afc4e3b4f452aa2d91cabb2135b9d42f7',1,'UcxAVLNode']]], + ['pool',['pool',['../structUcxAllocator.html#a1b78012998d1c28be86dc595f8f0aac9',1,'UcxAllocator']]], + ['pos',['pos',['../structUcxBuffer.html#a7a64288f002cf62b492e2ea49c79615c',1,'UcxBuffer::pos()'],['../structUcxProperties.html#addd36ac8e5e42241c0a57453633970db',1,'UcxProperties::pos()']]], + ['prev',['prev',['../structUcxList.html#a0f1fddce9088b9c1414745d0b1b5c08b',1,'UcxList::prev()'],['../structucx__stack__metadata.html#ad46d2e8e5b0acf05f2def41d451c5579',1,'ucx_stack_metadata::prev()']]], + ['ptr',['ptr',['../structucx__regdestr.html#aac0e9ec8df4aab08728b4f8292b5f5e7',1,'ucx_regdestr::ptr()'],['../structsstr__t.html#af8049914efc1e67f7de3ee55ec0611b0',1,'sstr_t::ptr()'],['../structscstr__t.html#a305fd48934b474a9bf4a40869030e391',1,'scstr_t::ptr()']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_d.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_d.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_d.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_d.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,6 @@ +var searchData= +[ + ['realloc',['realloc',['../structUcxAllocator.html#a3550e3847f31d9e9ce3ffcb0d3440c15',1,'UcxAllocator']]], + ['right',['right',['../structUcxAVLNode.html#a7cbaa31dba8c7a89f4f8f7905f6fd238',1,'UcxAVLNode']]], + ['root',['root',['../structUcxAVLTree.html#a393a8fc99eb2c290d3cb67170081d742',1,'UcxAVLTree']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_e.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_e.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_e.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_e.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,7 @@ +var searchData= +[ + ['size',['size',['../structUcxArray.html#a20c11f2c9048cda80062842b7c094e20',1,'UcxArray::size()'],['../structUcxBuffer.html#aec0aea8325394951d5ad4a9fbb8e1ac7',1,'UcxBuffer::size()'],['../structUcxMap.html#afe120846b26d99580a7ff1276464e838',1,'UcxMap::size()'],['../structUcxMempool.html#a304729986f2894971d0469e71e196bf0',1,'UcxMempool::size()'],['../structUcxStack.html#a4df86b1917bfc3bbf760220870638143',1,'UcxStack::size()'],['../structucx__stack__metadata.html#ae2a2848b721cfa44a7e963484c5e4b28',1,'ucx_stack_metadata::size()']]], + ['space',['space',['../structUcxBuffer.html#a1a5076e85acb84b715a53bc0f37fb721',1,'UcxBuffer::space()'],['../structUcxStack.html#af64d528744bf3a47fec87d2e45d2992f',1,'UcxStack::space()']]], + ['stream',['stream',['../structUcxLogger.html#a33fddf4791e8d49e479ecc78bf5d1b9e',1,'UcxLogger']]], + ['success',['success',['../structUcxTestSuite.html#a6cefa870a3c2e38d6ee682e38643dbbb',1,'UcxTestSuite']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_f.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_f.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/search/variables_f.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/search/variables_f.js Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,9 @@ +var searchData= +[ + ['test',['test',['../structUcxTestList.html#a6022faa52e772b073141ca0a2f5a56c9',1,'UcxTestList']]], + ['tests',['tests',['../structUcxTestSuite.html#a630677a70ebc2c3296704cda3196492b',1,'UcxTestSuite']]], + ['tmp',['tmp',['../structUcxProperties.html#a68556d4260153f58dde44e4c365edce6',1,'UcxProperties']]], + ['tmpcap',['tmpcap',['../structUcxProperties.html#a5af10131ea9f679b4ee174499f92e210',1,'UcxProperties']]], + ['tmplen',['tmplen',['../structUcxProperties.html#a8a81853d5903bee2f4e1fa53fdffae6e',1,'UcxProperties']]], + ['top',['top',['../structUcxStack.html#af0ff6f58edce469f17683013b86ade27',1,'UcxStack']]] +]; diff -r 92e482410453 -r d345541018fa docs/api-2.1/splitbar.png Binary file docs/api-2.1/splitbar.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/stack_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/stack_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,677 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/stack.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Data Structures | +Macros | +Functions
    +
    +
    stack.h File Reference
    +
    +
    + +

    Default stack memory allocation implementation. +More...

    +
    #include "ucx.h"
    +#include "allocator.h"
    +
    +

    Go to the source code of this file.

    + + + + + + + + +

    +Data Structures

    struct  UcxStack
     UCX stack structure. More...
     
    struct  ucx_stack_metadata
     Metadata for each UCX stack element. More...
     
    + + + + + + + + + + + + + +

    +Macros

    #define ucx_stack_topsize(stack)
     Returns the size of the top most element. More...
     
    #define ucx_stack_pop(stack, dest)   ucx_stack_popn(stack, dest, (size_t)-1)
     Removes the top most element from the stack and copies the content to dest, if specified. More...
     
    #define ucx_stack_empty(stack)   (!(stack)->top)
     Checks, if the stack is empty. More...
     
    #define ucx_stack_dim(size, elems)
     Computes a recommended size for the stack memory area. More...
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    void ucx_stack_init (UcxStack *stack, char *space, size_t size)
     Initializes UcxStack structure with memory. More...
     
    void * ucx_stack_malloc (UcxStack *stack, size_t n)
     Allocates stack memory. More...
     
    void * ucx_stack_push (UcxStack *stack, size_t n, const void *data)
     Allocates memory with ucx_stack_malloc() and copies the specified data if the allocation was successful. More...
     
    void * ucx_stack_calloc (UcxStack *stack, size_t nelem, size_t elsize)
     Allocates an array of stack memory. More...
     
    void * ucx_stack_pusharr (UcxStack *stack, size_t nelem, size_t elsize, const void *data)
     Allocates memory with ucx_stack_calloc() and copies the specified data if the allocation was successful. More...
     
    void * ucx_stack_realloc (UcxStack *stack, void *ptr, size_t n)
     Reallocates memory on the stack. More...
     
    void ucx_stack_free (UcxStack *stack, void *ptr)
     Frees memory on the stack. More...
     
    void ucx_stack_popn (UcxStack *stack, void *dest, size_t n)
     Removes the top most element from the stack and copies the content to dest. More...
     
    size_t ucx_stack_avail (UcxStack *stack)
     Returns the remaining available memory on the specified stack. More...
     
    +

    Detailed Description

    +

    Default stack memory allocation implementation.

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Macro Definition Documentation

    + +

    ◆ ucx_stack_dim

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define ucx_stack_dim( size,
     elems 
    )
    +
    +Value:
    (size+sizeof(struct ucx_stack_metadata) * \
    (elems + 1))
    ucx_stack_metadata
    Metadata for each UCX stack element.
    Definition: stack.h:69
    +
    +

    Computes a recommended size for the stack memory area.

    +

    Note, that reallocations have not been taken into account, so you might need to reserve twice as much memory to allow many reallocations.

    +
    Parameters
    + + + +
    sizethe approximate payload
    elemsthe approximate count of element allocations
    +
    +
    +
    Returns
    a recommended size for the stack space based on the information provided
    + +
    +
    + +

    ◆ ucx_stack_empty

    + +
    +
    + + + + + + + + +
    #define ucx_stack_empty( stack)   (!(stack)->top)
    +
    + +

    Checks, if the stack is empty.

    +
    Parameters
    + + +
    stacka pointer to the stack
    +
    +
    +
    Returns
    nonzero, if the stack is empty, zero otherwise
    + +
    +
    + +

    ◆ ucx_stack_pop

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define ucx_stack_pop( stack,
     dest 
    )   ucx_stack_popn(stack, dest, (size_t)-1)
    +
    + +

    Removes the top most element from the stack and copies the content to dest, if specified.

    +

    Use ucx_stack_topsize()# to get the amount of memory that must be available at the location of dest.

    +
    Parameters
    + + + +
    stacka pointer to the stack
    destthe location where the contents shall be written to, or NULL, if the element shall only be removed.
    +
    +
    +
    See also
    ucx_stack_free
    +
    +ucx_stack_popn
    + +
    +
    + +

    ◆ ucx_stack_topsize

    + +
    +
    + + + + + + + + +
    #define ucx_stack_topsize( stack)
    +
    +Value:
    ((stack)->top ? ((struct ucx_stack_metadata*)\
    (stack)->top - 1)->size : 0)
    ucx_stack_metadata
    Metadata for each UCX stack element.
    Definition: stack.h:69
    +
    +

    Returns the size of the top most element.

    +
    Parameters
    + + +
    stacka pointer to the stack
    +
    +
    +
    Returns
    the size of the top most element
    + +
    +
    +

    Function Documentation

    + +

    ◆ ucx_stack_avail()

    + +
    +
    + + + + + + + + +
    size_t ucx_stack_avail (UcxStack * stack)
    +
    + +

    Returns the remaining available memory on the specified stack.

    +
    Parameters
    + + +
    stacka pointer to the stack
    +
    +
    +
    Returns
    the remaining available memory
    + +
    +
    + +

    ◆ ucx_stack_calloc()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void* ucx_stack_calloc (UcxStack * stack,
    size_t nelem,
    size_t elsize 
    )
    +
    + +

    Allocates an array of stack memory.

    +

    The content of the allocated memory is set to zero.

    +
    Parameters
    + + + + +
    stacka pointer to the stack
    nelemamount of elements to allocate
    elsizeamount of memory per element
    +
    +
    +
    Returns
    a pointer to the allocated memory
    +
    See also
    ucx_allocator_calloc()
    + +
    +
    + +

    ◆ ucx_stack_free()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void ucx_stack_free (UcxStack * stack,
    void * ptr 
    )
    +
    + +

    Frees memory on the stack.

    +

    Freeing stack memory behaves in a special way.

    +

    If the element, that should be freed, is the top most element of the stack, it is removed from the stack. Otherwise it is marked as freed. Marked elements are removed, when they become the top most elements of the stack.

    +
    Parameters
    + + + +
    stacka pointer to the stack
    ptra pointer to the memory that shall be freed
    +
    +
    + +
    +
    + +

    ◆ ucx_stack_init()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void ucx_stack_init (UcxStack * stack,
    char * space,
    size_t size 
    )
    +
    + +

    Initializes UcxStack structure with memory.

    +
    Parameters
    + + + + +
    stacka pointer to an uninitialized stack structure
    spacethe memory area that shall be managed
    sizesize of the memory area
    +
    +
    +
    Returns
    a new UcxStack structure
    + +
    +
    + +

    ◆ ucx_stack_malloc()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void* ucx_stack_malloc (UcxStack * stack,
    size_t n 
    )
    +
    + +

    Allocates stack memory.

    +
    Parameters
    + + + +
    stacka pointer to the stack
    namount of memory to allocate
    +
    +
    +
    Returns
    a pointer to the allocated memory or NULL on stack overflow
    +
    See also
    ucx_allocator_malloc()
    + +
    +
    + +

    ◆ ucx_stack_popn()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void ucx_stack_popn (UcxStack * stack,
    void * dest,
    size_t n 
    )
    +
    + +

    Removes the top most element from the stack and copies the content to dest.

    +

    This function copies at most n bytes to the destination, but the element is always freed as a whole. If the element was larger than n, the remaining data is lost.

    +
    Parameters
    + + + + +
    stacka pointer to the stack
    destthe location where the contents shall be written to
    ncopies at most n bytes to dest
    +
    +
    +
    See also
    ucx_stack_pop
    + +
    +
    + +

    ◆ ucx_stack_push()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void* ucx_stack_push (UcxStack * stack,
    size_t n,
    const void * data 
    )
    +
    + +

    Allocates memory with ucx_stack_malloc() and copies the specified data if the allocation was successful.

    +
    Parameters
    + + + + +
    stacka pointer to the stack
    namount of memory to allocate
    dataa pointer to the data to copy
    +
    +
    +
    Returns
    a pointer to the allocated memory
    +
    See also
    ucx_stack_malloc
    + +
    +
    + +

    ◆ ucx_stack_pusharr()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    void* ucx_stack_pusharr (UcxStack * stack,
    size_t nelem,
    size_t elsize,
    const void * data 
    )
    +
    + +

    Allocates memory with ucx_stack_calloc() and copies the specified data if the allocation was successful.

    +
    Parameters
    + + + + + +
    stacka pointer to the stack
    nelemamount of elements to allocate
    elsizeamount of memory per element
    dataa pointer to the data
    +
    +
    +
    Returns
    a pointer to the allocated memory
    +
    See also
    ucx_stack_calloc
    + +
    +
    + +

    ◆ ucx_stack_realloc()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void* ucx_stack_realloc (UcxStack * stack,
    void * ptr,
    size_t n 
    )
    +
    + +

    Reallocates memory on the stack.

    +

    Shrinking memory is always safe. Extending memory can be very expensive.

    +
    Parameters
    + + + + +
    stackthe stack
    ptra pointer to the memory that shall be reallocated
    nthe new size of the memory
    +
    +
    +
    Returns
    a pointer to the new location of the memory
    +
    See also
    ucx_allocator_realloc()
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/stack_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/stack_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,99 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/stack.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    stack.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    38 #ifndef UCX_STACK_H
    39 #define UCX_STACK_H
    40 
    41 #include "ucx.h"
    42 #include "allocator.h"
    43 
    44 #ifdef __cplusplus
    45 extern "C" {
    46 #endif
    47 
    48 
    52 typedef struct {
    54  UcxAllocator allocator;
    55 
    57  size_t size;
    58 
    60  char *space;
    61 
    63  char *top;
    64 } UcxStack;
    65 
    69 struct ucx_stack_metadata {
    73  char *prev;
    74 
    76  size_t size;
    77 };
    78 
    87 void ucx_stack_init(UcxStack *stack, char* space, size_t size);
    88 
    98 void *ucx_stack_malloc(UcxStack *stack, size_t n);
    99 
    110 void *ucx_stack_push(UcxStack *stack, size_t n, const void *data);
    111 
    123 void *ucx_stack_calloc(UcxStack *stack, size_t nelem, size_t elsize);
    124 
    136 void *ucx_stack_pusharr(UcxStack *stack,
    137  size_t nelem, size_t elsize, const void *data);
    138 
    150 void *ucx_stack_realloc(UcxStack *stack, void *ptr, size_t n);
    151 
    164 void ucx_stack_free(UcxStack *stack, void *ptr);
    165 
    166 
    172 #define ucx_stack_topsize(stack) ((stack)->top ? ((struct ucx_stack_metadata*)\
    173  (stack)->top - 1)->size : 0)
    174 
    188 #define ucx_stack_pop(stack, dest) ucx_stack_popn(stack, dest, (size_t)-1)
    189 
    203 void ucx_stack_popn(UcxStack *stack, void *dest, size_t n);
    204 
    211 size_t ucx_stack_avail(UcxStack *stack);
    212 
    219 #define ucx_stack_empty(stack) (!(stack)->top)
    220 
    231 #define ucx_stack_dim(size, elems) (size+sizeof(struct ucx_stack_metadata) * \
    232  (elems + 1))
    233 
    234 
    235 #ifdef __cplusplus
    236 }
    237 #endif
    238 
    239 #endif /* UCX_STACK_H */
    240 
    UcxStack::size
    size_t size
    Stack size.
    Definition: stack.h:57
    +
    UcxStack
    UCX stack structure.
    Definition: stack.h:52
    +
    ucx_stack_free
    void ucx_stack_free(UcxStack *stack, void *ptr)
    Frees memory on the stack.
    Definition: stack.c:106
    +
    ucx.h
    Main UCX Header providing most common definitions.
    +
    ucx_stack_malloc
    void * ucx_stack_malloc(UcxStack *stack, size_t n)
    Allocates stack memory.
    Definition: stack.c:53
    +
    ucx_stack_push
    void * ucx_stack_push(UcxStack *stack, size_t n, const void *data)
    Allocates memory with ucx_stack_malloc() and copies the specified data if the allocation was successf...
    Definition: stack.c:148
    +
    ucx_stack_metadata
    Metadata for each UCX stack element.
    Definition: stack.h:69
    +
    ucx_stack_realloc
    void * ucx_stack_realloc(UcxStack *stack, void *ptr, size_t n)
    Reallocates memory on the stack.
    Definition: stack.c:79
    +
    ucx_stack_metadata::prev
    char * prev
    Location of the previous element (NULL if this is the first)
    Definition: stack.h:73
    +
    ucx_stack_avail
    size_t ucx_stack_avail(UcxStack *stack)
    Returns the remaining available memory on the specified stack.
    Definition: stack.c:135
    +
    UcxAllocator
    UCX allocator data structure containing memory management functions.
    Definition: allocator.h:88
    +
    UcxStack::space
    char * space
    Pointer to the bottom of the stack.
    Definition: stack.h:60
    +
    ucx_stack_popn
    void ucx_stack_popn(UcxStack *stack, void *dest, size_t n)
    Removes the top most element from the stack and copies the content to dest.
    Definition: stack.c:118
    +
    allocator.h
    Allocator for custom memory management.
    +
    ucx_stack_init
    void ucx_stack_init(UcxStack *stack, char *space, size_t size)
    Initializes UcxStack structure with memory.
    Definition: stack.c:41
    +
    ucx_stack_metadata::size
    size_t size
    Size of this element.
    Definition: stack.h:76
    +
    ucx_stack_pusharr
    void * ucx_stack_pusharr(UcxStack *stack, size_t nelem, size_t elsize, const void *data)
    Allocates memory with ucx_stack_calloc() and copies the specified data if the allocation was successf...
    Definition: stack.c:156
    +
    ucx_stack_calloc
    void * ucx_stack_calloc(UcxStack *stack, size_t nelem, size_t elsize)
    Allocates an array of stack memory.
    Definition: stack.c:73
    +
    UcxStack::top
    char * top
    Pointer to the top of the stack.
    Definition: stack.h:63
    +
    UcxStack::allocator
    UcxAllocator allocator
    UcxAllocator based on this stack.
    Definition: stack.h:54
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/string_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/string_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,2598 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/string.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Data Structures | +Macros | +Functions
    +
    +
    string.h File Reference
    +
    +
    + +

    Bounded string implementation. +More...

    +
    #include "ucx.h"
    +#include "allocator.h"
    +#include <stddef.h>
    +
    +

    Go to the source code of this file.

    + + + + + + + + +

    +Data Structures

    struct  sstr_t
     The UCX string structure. More...
     
    struct  scstr_t
     The UCX string structure for immutable (constant) strings. More...
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Macros

    +#define ST(s)   { s, sizeof(s)-1 }
     Shortcut for a sstr_t struct or scstr_t struct literal.
     
    #define S(s)   sstrn(s, sizeof(s)-1)
     Shortcut for the conversion of a C string to a sstr_t. More...
     
    #define SC(s)   scstrn(s, sizeof(s)-1)
     Shortcut for the conversion of a C string to a scstr_t. More...
     
    #define SFMT(s)   (int) (s).length, (s).ptr
     Expands a sstr_t or scstr_t to printf arguments. More...
     
    #define PRIsstr   ".*s"
     Format specifier for a sstr_t or scstr_t. More...
     
    #define SCSTR(str)   ucx_ss2c_s(str)
     Converts a UCX string to an immutable UCX string (scstr_t). More...
     
    #define sstrnlen(count, ...)   scstrnlen(count, __VA_ARGS__)
     Returns the accumulated length of all specified strings. More...
     
    #define sstrcat(count, s1, ...)   scstrcat(count, SCSTR(s1), __VA_ARGS__)
     Concatenates two or more strings. More...
     
    #define sstrcat_a(alloc, count, s1, ...)   scstrcat_a(alloc, count, SCSTR(s1), __VA_ARGS__)
     Concatenates two or more strings using a UcxAllocator. More...
     
    #define sstrstr(string, match)   scstrsstr(string, SCSTR(match))
     Returns a substring starting at the location of the first occurrence of the specified string. More...
     
    #define sstrscstr(string, match)   scstrscstr(string, SCSTR(match))
     Returns an immutable substring starting at the location of the first occurrence of the specified immutable string. More...
     
    #define sstrsplit(string, delim, count)   scstrsplit(SCSTR(string), SCSTR(delim), count)
     Splits a string into parts by using a delimiter string. More...
     
    #define sstrsplit_a(allocator, string, delim, count)   scstrsplit_a(allocator, SCSTR(string), SCSTR(delim), count)
     Performing sstrsplit() using a UcxAllocator. More...
     
    #define sstrcmp(s1, s2)   scstrcmp(SCSTR(s1), SCSTR(s2))
     Compares two UCX strings with standard memcmp(). More...
     
    #define sstrcasecmp(s1, s2)   scstrcasecmp(SCSTR(s1), SCSTR(s2))
     Compares two UCX strings ignoring the case. More...
     
    #define sstrdup(string)   scstrdup(SCSTR(string))
     Creates a duplicate of the specified string. More...
     
    #define sstrdup_a(allocator, string)   scstrdup_a(allocator, SCSTR(string))
     Creates a duplicate of the specified string using a UcxAllocator. More...
     
    #define sstrprefix(string, prefix)   scstrprefix(SCSTR(string), SCSTR(prefix))
     Checks, if a string has a specific prefix. More...
     
    #define sstrsuffix(string, suffix)   scstrsuffix(SCSTR(string), SCSTR(suffix))
     Checks, if a string has a specific suffix. More...
     
    #define sstrcaseprefix(string, prefix)   scstrcaseprefix(SCSTR(string), SCSTR(prefix))
     Checks, if a string has a specific prefix, ignoring the case. More...
     
    #define sstrcasesuffix(string, suffix)   scstrcasesuffix(SCSTR(string), SCSTR(suffix))
     Checks, if a string has a specific suffix, ignoring the case. More...
     
    #define sstrlower(string)   scstrlower(SCSTR(string))
     Returns a lower case version of a string. More...
     
    #define sstrlower_a(allocator, string)   scstrlower_a(allocator, SCSTR(string))
     Returns a lower case version of a string. More...
     
    #define sstrupper(string)   scstrupper(SCSTR(string))
     Returns a upper case version of a string. More...
     
    #define sstrupper_a(allocator, string)   scstrupper_a(allocator, string)
     Returns a upper case version of a string. More...
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    scstr_t ucx_sc2sc (scstr_t str)
     One of two type adjustment functions that return an scstr_t. More...
     
    scstr_t ucx_ss2sc (sstr_t str)
     One of two type adjustment functions that return an scstr_t. More...
     
    scstr_t ucx_ss2c_s ()
     Converts a UCX string to an immutable UCX string (scstr_t). More...
     
    sstr_t sstr (char *cstring)
     Creates a new sstr_t based on a C string. More...
     
    sstr_t sstrn (char *cstring, size_t length)
     Creates a new sstr_t of the specified length based on a C string. More...
     
    scstr_t scstr (const char *cstring)
     Creates a new scstr_t based on a constant C string. More...
     
    scstr_t scstrn (const char *cstring, size_t length)
     Creates a new scstr_t of the specified length based on a constant C string. More...
     
    size_t scstrnlen (size_t count,...)
     Returns the accumulated length of all specified strings. More...
     
    sstr_t scstrcat (size_t count, scstr_t s1,...)
     Concatenates two or more strings. More...
     
    sstr_t scstrcat_a (UcxAllocator *alloc, size_t count, scstr_t s1,...)
     Concatenates two or more strings using a UcxAllocator. More...
     
    sstr_t sstrsubs (sstr_t string, size_t start)
     Returns a substring starting at the specified location. More...
     
    sstr_t sstrsubsl (sstr_t string, size_t start, size_t length)
     Returns a substring with the given length starting at the specified location. More...
     
    scstr_t scstrsubs (scstr_t string, size_t start)
     Returns a substring of an immutable string starting at the specified location. More...
     
    scstr_t scstrsubsl (scstr_t string, size_t start, size_t length)
     Returns a substring of an immutable string with a maximum length starting at the specified location. More...
     
    sstr_t sstrchr (sstr_t string, int chr)
     Returns a substring starting at the location of the first occurrence of the specified character. More...
     
    sstr_t sstrrchr (sstr_t string, int chr)
     Returns a substring starting at the location of the last occurrence of the specified character. More...
     
    scstr_t scstrchr (scstr_t string, int chr)
     Returns an immutable substring starting at the location of the first occurrence of the specified character. More...
     
    scstr_t scstrrchr (scstr_t string, int chr)
     Returns an immutable substring starting at the location of the last occurrence of the specified character. More...
     
    sstr_t scstrsstr (sstr_t string, scstr_t match)
     Returns a substring starting at the location of the first occurrence of the specified string. More...
     
    scstr_t scstrscstr (scstr_t string, scstr_t match)
     Returns an immutable substring starting at the location of the first occurrence of the specified immutable string. More...
     
    sstr_t * scstrsplit (scstr_t string, scstr_t delim, ssize_t *count)
     Splits a string into parts by using a delimiter string. More...
     
    sstr_t * scstrsplit_a (UcxAllocator *allocator, scstr_t string, scstr_t delim, ssize_t *count)
     Performing scstrsplit() using a UcxAllocator. More...
     
    int scstrcmp (scstr_t s1, scstr_t s2)
     Compares two UCX strings with standard memcmp(). More...
     
    int scstrcasecmp (scstr_t s1, scstr_t s2)
     Compares two UCX strings ignoring the case. More...
     
    sstr_t scstrdup (scstr_t string)
     Creates a duplicate of the specified string. More...
     
    sstr_t scstrdup_a (UcxAllocator *allocator, scstr_t string)
     Creates a duplicate of the specified string using a UcxAllocator. More...
     
    sstr_t sstrtrim (sstr_t string)
     Omits leading and trailing spaces. More...
     
    scstr_t scstrtrim (scstr_t string)
     Omits leading and trailing spaces. More...
     
    int scstrprefix (scstr_t string, scstr_t prefix)
     Checks, if a string has a specific prefix. More...
     
    int scstrsuffix (scstr_t string, scstr_t suffix)
     Checks, if a string has a specific suffix. More...
     
    int scstrcaseprefix (scstr_t string, scstr_t prefix)
     Checks, if a string has a specific prefix, ignoring the case. More...
     
    int scstrcasesuffix (scstr_t string, scstr_t suffix)
     Checks, if a string has a specific suffix, ignoring the case. More...
     
    sstr_t scstrlower (scstr_t string)
     Returns a lower case version of a string. More...
     
    sstr_t scstrlower_a (UcxAllocator *allocator, scstr_t string)
     Returns a lower case version of a string. More...
     
    sstr_t scstrupper (scstr_t string)
     Returns a upper case version of a string. More...
     
    sstr_t scstrupper_a (UcxAllocator *allocator, scstr_t string)
     Returns a upper case version of a string. More...
     
    +

    Detailed Description

    +

    Bounded string implementation.

    +

    The UCX strings (sstr_t) provide an alternative to C strings. The main difference to C strings is, that sstr_t does not need to be NULL-terminated. Instead the length is stored within the structure.

    +

    When using sstr_t, developers must be full aware of what type of string (NULL-terminated) or not) they are using, when accessing the char* ptr directly.

    +

    The UCX string module provides some common string functions, known from standard libc, working with sstr_t.

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Macro Definition Documentation

    + +

    ◆ PRIsstr

    + +
    +
    + + + + +
    #define PRIsstr   ".*s"
    +
    + +

    Format specifier for a sstr_t or scstr_t.

    + +
    +
    + +

    ◆ S

    + +
    +
    + + + + + + + + +
    #define S( s)   sstrn(s, sizeof(s)-1)
    +
    + +

    Shortcut for the conversion of a C string to a sstr_t.

    + +
    +
    + +

    ◆ SC

    + +
    +
    + + + + + + + + +
    #define SC( s)   scstrn(s, sizeof(s)-1)
    +
    + +

    Shortcut for the conversion of a C string to a scstr_t.

    + +
    +
    + +

    ◆ SCSTR

    + +
    +
    + + + + + + + + +
    #define SCSTR( str)   ucx_ss2c_s(str)
    +
    + +

    Converts a UCX string to an immutable UCX string (scstr_t).

    +
    Parameters
    + + +
    strsome UCX string
    +
    +
    +
    Returns
    the an immutable version of the provided string
    + +
    +
    + +

    ◆ SFMT

    + +
    +
    + + + + + + + + +
    #define SFMT( s)   (int) (s).length, (s).ptr
    +
    + +

    Expands a sstr_t or scstr_t to printf arguments.

    + +
    +
    + +

    ◆ sstrcasecmp

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrcasecmp( s1,
     s2 
    )   scstrcasecmp(SCSTR(s1), SCSTR(s2))
    +
    + +

    Compares two UCX strings ignoring the case.

    +

    At first it compares the sstr_t.length attribute of the two strings. If and only if the lengths match, both strings are compared char by char ignoring the case.

    +
    Parameters
    + + + +
    s1the first string
    s2the second string
    +
    +
    +
    Returns
    -1, if the length of s1 is less than the length of s2 or 1, if the length of s1 is greater than the length of s2 or the result of the platform specific string comparison function ignoring the case.
    + +
    +
    + +

    ◆ sstrcaseprefix

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrcaseprefix( string,
     prefix 
    )   scstrcaseprefix(SCSTR(string), SCSTR(prefix))
    +
    + +

    Checks, if a string has a specific prefix, ignoring the case.

    +
    Parameters
    + + + +
    stringthe string to check
    prefixthe prefix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified prefix, 0 otherwise
    + +
    +
    + +

    ◆ sstrcasesuffix

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrcasesuffix( string,
     suffix 
    )   scstrcasesuffix(SCSTR(string), SCSTR(suffix))
    +
    + +

    Checks, if a string has a specific suffix, ignoring the case.

    +
    Parameters
    + + + +
    stringthe string to check
    suffixthe suffix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified suffix, 0 otherwise
    + +
    +
    + +

    ◆ sstrcat

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    #define sstrcat( count,
     s1,
     ... 
    )   scstrcat(count, SCSTR(s1), __VA_ARGS__)
    +
    + +

    Concatenates two or more strings.

    +

    The resulting string will be allocated by standard malloc(). So developers MUST pass the sstr_t.ptr to free().

    +

    The sstr_t.ptr of the return value will always be NULL- terminated.

    +
    Parameters
    + + + + +
    countthe total number of strings to concatenate
    s1first string
    ...all remaining strings
    +
    +
    +
    Returns
    the concatenated string
    + +
    +
    + +

    ◆ sstrcat_a

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    #define sstrcat_a( alloc,
     count,
     s1,
     ... 
    )   scstrcat_a(alloc, count, SCSTR(s1), __VA_ARGS__)
    +
    + +

    Concatenates two or more strings using a UcxAllocator.

    +

    The resulting string must be freed by the allocators free() implementation.

    +

    The sstr_t.ptr of the return value will always be NULL- terminated.

    +
    Parameters
    + + + + + +
    allocthe allocator to use
    countthe total number of strings to concatenate
    s1first string
    ...all remaining strings
    +
    +
    +
    Returns
    the concatenated string
    +
    See also
    sstrcat()
    + +
    +
    + +

    ◆ sstrcmp

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrcmp( s1,
     s2 
    )   scstrcmp(SCSTR(s1), SCSTR(s2))
    +
    + +

    Compares two UCX strings with standard memcmp().

    +

    At first it compares the sstr_t.length attribute of the two strings. The memcmp() function is called, if and only if the lengths match.

    +
    Parameters
    + + + +
    s1the first string
    s2the second string
    +
    +
    +
    Returns
    -1, if the length of s1 is less than the length of s2 or 1, if the length of s1 is greater than the length of s2 or the result of memcmp() otherwise (i.e. 0 if the strings match)
    + +
    +
    + +

    ◆ sstrdup

    + +
    +
    + + + + + + + + +
    #define sstrdup( string)   scstrdup(SCSTR(string))
    +
    + +

    Creates a duplicate of the specified string.

    +

    The new sstr_t will contain a copy allocated by standard malloc(). So developers MUST pass the sstr_t.ptr to free().

    +

    The sstr_t.ptr of the return value will always be NULL- terminated, regardless of the argument.

    +
    Parameters
    + + +
    stringthe string to duplicate
    +
    +
    +
    Returns
    a duplicate of the string
    +
    See also
    sstrdup_a()
    + +
    +
    + +

    ◆ sstrdup_a

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrdup_a( allocator,
     string 
    )   scstrdup_a(allocator, SCSTR(string))
    +
    + +

    Creates a duplicate of the specified string using a UcxAllocator.

    +

    The new sstr_t will contain a copy allocated by the allocators UcxAllocator.malloc() function. So it is implementation depended, whether the returned sstr_t.ptr pointer must be passed to the allocators UcxAllocator.free() function manually.

    +

    The sstr_t.ptr of the return value will always be NULL- terminated, regardless of the argument.

    +
    Parameters
    + + + +
    allocatora valid instance of a UcxAllocator
    stringthe string to duplicate
    +
    +
    +
    Returns
    a duplicate of the string
    +
    See also
    scstrdup()
    + +
    +
    + +

    ◆ sstrlower

    + +
    +
    + + + + + + + + +
    #define sstrlower( string)   scstrlower(SCSTR(string))
    +
    + +

    Returns a lower case version of a string.

    +

    This function creates a duplicate of the input string, first (see sstrdup()).

    +
    Parameters
    + + +
    stringthe input string
    +
    +
    +
    Returns
    the resulting lower case string
    + +
    +
    + +

    ◆ sstrlower_a

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrlower_a( allocator,
     string 
    )   scstrlower_a(allocator, SCSTR(string))
    +
    + +

    Returns a lower case version of a string.

    +

    This function creates a duplicate of the input string, first (see sstrdup_a()).

    +
    Parameters
    + + + +
    allocatorthe allocator used for duplicating the string
    stringthe input string
    +
    +
    +
    Returns
    the resulting lower case string
    + +
    +
    + +

    ◆ sstrnlen

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrnlen( count,
     ... 
    )   scstrnlen(count, __VA_ARGS__)
    +
    + +

    Returns the accumulated length of all specified strings.

    +

    Attention: if the count argument is larger than the count of the specified strings, the behavior is undefined.

    +
    Parameters
    + + + +
    countthe total number of specified strings
    ...all strings
    +
    +
    +
    Returns
    the cumulated length of all strings
    + +
    +
    + +

    ◆ sstrprefix

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrprefix( string,
     prefix 
    )   scstrprefix(SCSTR(string), SCSTR(prefix))
    +
    + +

    Checks, if a string has a specific prefix.

    +
    Parameters
    + + + +
    stringthe string to check
    prefixthe prefix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified prefix, 0 otherwise
    + +
    +
    + +

    ◆ sstrscstr

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrscstr( string,
     match 
    )   scstrscstr(string, SCSTR(match))
    +
    + +

    Returns an immutable substring starting at the location of the first occurrence of the specified immutable string.

    +

    If the string does not contain the other string, an empty string is returned.

    +

    If match is an empty string, the complete string is returned.

    +
    Parameters
    + + + +
    stringthe string to be scanned
    matchstring containing the sequence of characters to match
    +
    +
    +
    Returns
    a substring starting at the first occurrence of match, or an empty string, if the sequence is not present in string
    + +
    +
    + +

    ◆ sstrsplit

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    #define sstrsplit( string,
     delim,
     count 
    )   scstrsplit(SCSTR(string), SCSTR(delim), count)
    +
    + +

    Splits a string into parts by using a delimiter string.

    +

    This function will return NULL, if one of the following happens:

      +
    • +the string length is zero
      • +
    • +the delimeter length is zero
      • +
    • +the string equals the delimeter
      • +
    • +memory allocation fails
      • +
    +

    The integer referenced by count is used as input and determines the maximum size of the resulting array, i.e. the maximum count of splits to perform + 1.

    +

    The integer referenced by count is also used as output and is set to

      +
    • +-2, on memory allocation errors
      • +
    • +-1, if either the string or the delimiter is an empty string
      • +
    • +0, if the string equals the delimiter
      • +
    • +1, if the string does not contain the delimiter
      • +
    • +the count of array items, otherwise
      • +
    +

    If the string starts with the delimiter, the first item of the resulting array will be an empty string.

    +

    If the string ends with the delimiter and the maximum list size is not exceeded, the last array item will be an empty string. In case the list size would be exceeded, the last array item will be the remaining string after the last split, including the terminating delimiter.

    +

    Attention: The array pointer AND all sstr_t.ptr of the array items must be manually passed to free(). Use sstrsplit_a() with an allocator to managed memory, to avoid this.

    +
    Parameters
    + + + + +
    stringthe string to split
    delimthe delimiter string
    countIN: the maximum size of the resulting array (0 = no limit), OUT: the actual size of the array
    +
    +
    +
    Returns
    a sstr_t array containing the split strings or NULL on error
    +
    See also
    sstrsplit_a()
    + +
    +
    + +

    ◆ sstrsplit_a

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    #define sstrsplit_a( allocator,
     string,
     delim,
     count 
    )   scstrsplit_a(allocator, SCSTR(string), SCSTR(delim), count)
    +
    + +

    Performing sstrsplit() using a UcxAllocator.

    +

    Read the description of sstrsplit() for details.

    +

    The memory for the sstr_t.ptr pointers of the array items and the memory for the sstr_t array itself are allocated by using the UcxAllocator.malloc() function.

    +
    Parameters
    + + + + + +
    allocatorthe UcxAllocator used for allocating memory
    stringthe string to split
    delimthe delimiter string
    countIN: the maximum size of the resulting array (0 = no limit), OUT: the actual size of the array
    +
    +
    +
    Returns
    a sstr_t array containing the split strings or NULL on error
    +
    See also
    sstrsplit()
    + +
    +
    + +

    ◆ sstrstr

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrstr( string,
     match 
    )   scstrsstr(string, SCSTR(match))
    +
    + +

    Returns a substring starting at the location of the first occurrence of the specified string.

    +

    If the string does not contain the other string, an empty string is returned.

    +

    If match is an empty string, the complete string is returned.

    +
    Parameters
    + + + +
    stringthe string to be scanned
    matchstring containing the sequence of characters to match
    +
    +
    +
    Returns
    a substring starting at the first occurrence of match, or an empty string, if the sequence is not present in string
    + +
    +
    + +

    ◆ sstrsuffix

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrsuffix( string,
     suffix 
    )   scstrsuffix(SCSTR(string), SCSTR(suffix))
    +
    + +

    Checks, if a string has a specific suffix.

    +
    Parameters
    + + + +
    stringthe string to check
    suffixthe suffix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified suffix, 0 otherwise
    + +
    +
    + +

    ◆ sstrupper

    + +
    +
    + + + + + + + + +
    #define sstrupper( string)   scstrupper(SCSTR(string))
    +
    + +

    Returns a upper case version of a string.

    +

    This function creates a duplicate of the input string, first (see sstrdup()).

    +
    Parameters
    + + +
    stringthe input string
    +
    +
    +
    Returns
    the resulting upper case string
    + +
    +
    + +

    ◆ sstrupper_a

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define sstrupper_a( allocator,
     string 
    )   scstrupper_a(allocator, string)
    +
    + +

    Returns a upper case version of a string.

    +

    This function creates a duplicate of the input string, first (see sstrdup_a()).

    +
    Parameters
    + + + +
    allocatorthe allocator used for duplicating the string
    stringthe input string
    +
    +
    +
    Returns
    the resulting upper case string
    + +
    +
    +

    Function Documentation

    + +

    ◆ scstr()

    + +
    +
    + + + + + + + + +
    scstr_t scstr (const char * cstring)
    +
    + +

    Creates a new scstr_t based on a constant C string.

    +

    The length is implicitly inferred by using a call to strlen().

    +

    Note: the scstr_t will share the specified pointer to the C string. If you do want a copy, use scstrdup() on the return value of this function.

    +
    Parameters
    + + +
    cstringthe C string to wrap
    +
    +
    +
    Returns
    a new scstr_t containing the C string
    +
    See also
    scstrn()
    + +
    +
    + +

    ◆ scstrcasecmp()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrcasecmp (scstr_t s1,
    scstr_t s2 
    )
    +
    + +

    Compares two UCX strings ignoring the case.

    +

    At first it compares the scstr_t.length attribute of the two strings. If and only if the lengths match, both strings are compared char by char ignoring the case.

    +
    Parameters
    + + + +
    s1the first string
    s2the second string
    +
    +
    +
    Returns
    -1, if the length of s1 is less than the length of s2 or 1, if the length of s1 is greater than the length of s2 or the result of the platform specific string comparison function ignoring the case.
    + +
    +
    + +

    ◆ scstrcaseprefix()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrcaseprefix (scstr_t string,
    scstr_t prefix 
    )
    +
    + +

    Checks, if a string has a specific prefix, ignoring the case.

    +
    Parameters
    + + + +
    stringthe string to check
    prefixthe prefix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified prefix, 0 otherwise
    + +
    +
    + +

    ◆ scstrcasesuffix()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrcasesuffix (scstr_t string,
    scstr_t suffix 
    )
    +
    + +

    Checks, if a string has a specific suffix, ignoring the case.

    +
    Parameters
    + + + +
    stringthe string to check
    suffixthe suffix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified suffix, 0 otherwise
    + +
    +
    + +

    ◆ scstrcat()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t scstrcat (size_t count,
    scstr_t s1,
     ... 
    )
    +
    + +

    Concatenates two or more strings.

    +

    The resulting string will be allocated by standard malloc(). So developers MUST pass the sstr_t.ptr to free().

    +

    The sstr_t.ptr of the return value will always be NULL- terminated.

    +
    Parameters
    + + + + +
    countthe total number of strings to concatenate
    s1first string
    ...all remaining strings
    +
    +
    +
    Returns
    the concatenated string
    + +
    +
    + +

    ◆ scstrcat_a()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t scstrcat_a (UcxAllocator * alloc,
    size_t count,
    scstr_t s1,
     ... 
    )
    +
    + +

    Concatenates two or more strings using a UcxAllocator.

    +

    The resulting string must be freed by the allocators free() implementation.

    +

    The sstr_t.ptr of the return value will always be NULL- terminated.

    +
    Parameters
    + + + + + +
    allocthe allocator to use
    countthe total number of strings to concatenate
    s1first string
    ...all remaining strings
    +
    +
    +
    Returns
    the concatenated string
    +
    See also
    scstrcat()
    + +
    +
    + +

    ◆ scstrchr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    scstr_t scstrchr (scstr_t string,
    int chr 
    )
    +
    + +

    Returns an immutable substring starting at the location of the first occurrence of the specified character.

    +

    If the string does not contain the character, an empty string is returned.

    +
    Parameters
    + + + +
    stringthe string where to locate the character
    chrthe character to locate
    +
    +
    +
    Returns
    a substring starting at the first location of chr
    +
    See also
    scstrsubs()
    + +
    +
    + +

    ◆ scstrcmp()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrcmp (scstr_t s1,
    scstr_t s2 
    )
    +
    + +

    Compares two UCX strings with standard memcmp().

    +

    At first it compares the scstr_t.length attribute of the two strings. The memcmp() function is called, if and only if the lengths match.

    +
    Parameters
    + + + +
    s1the first string
    s2the second string
    +
    +
    +
    Returns
    -1, if the length of s1 is less than the length of s2 or 1, if the length of s1 is greater than the length of s2 or the result of memcmp() otherwise (i.e. 0 if the strings match)
    + +
    +
    + +

    ◆ scstrdup()

    + +
    +
    + + + + + + + + +
    sstr_t scstrdup (scstr_t string)
    +
    + +

    Creates a duplicate of the specified string.

    +

    The new sstr_t will contain a copy allocated by standard malloc(). So developers MUST pass the sstr_t.ptr to free().

    +

    The sstr_t.ptr of the return value will always be NULL- terminated and mutable, regardless of the argument.

    +
    Parameters
    + + +
    stringthe string to duplicate
    +
    +
    +
    Returns
    a duplicate of the string
    +
    See also
    scstrdup_a()
    + +
    +
    + +

    ◆ scstrdup_a()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t scstrdup_a (UcxAllocator * allocator,
    scstr_t string 
    )
    +
    + +

    Creates a duplicate of the specified string using a UcxAllocator.

    +

    The new sstr_t will contain a copy allocated by the allocators UcxAllocator.malloc() function. So it is implementation depended, whether the returned sstr_t.ptr pointer must be passed to the allocators UcxAllocator.free() function manually.

    +

    The sstr_t.ptr of the return value will always be NULL- terminated and mutable, regardless of the argument.

    +
    Parameters
    + + + +
    allocatora valid instance of a UcxAllocator
    stringthe string to duplicate
    +
    +
    +
    Returns
    a duplicate of the string
    +
    See also
    scstrdup()
    + +
    +
    + +

    ◆ scstrlower()

    + +
    +
    + + + + + + + + +
    sstr_t scstrlower (scstr_t string)
    +
    + +

    Returns a lower case version of a string.

    +

    This function creates a duplicate of the input string, first (see scstrdup()).

    +
    Parameters
    + + +
    stringthe input string
    +
    +
    +
    Returns
    the resulting lower case string
    +
    See also
    scstrdup()
    + +
    +
    + +

    ◆ scstrlower_a()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t scstrlower_a (UcxAllocator * allocator,
    scstr_t string 
    )
    +
    + +

    Returns a lower case version of a string.

    +

    This function creates a duplicate of the input string, first (see scstrdup_a()).

    +
    Parameters
    + + + +
    allocatorthe allocator used for duplicating the string
    stringthe input string
    +
    +
    +
    Returns
    the resulting lower case string
    +
    See also
    scstrdup_a()
    + +
    +
    + +

    ◆ scstrn()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    scstr_t scstrn (const char * cstring,
    size_t length 
    )
    +
    + +

    Creates a new scstr_t of the specified length based on a constant C string.

    +

    Note: the scstr_t will share the specified pointer to the C string. If you do want a copy, use scstrdup() on the return value of this function. *

    +
    Parameters
    + + + +
    cstringthe C string to wrap
    lengththe length of the string
    +
    +
    +
    Returns
    a new scstr_t containing the C string
    +
    See also
    scstr()
    + +
    +
    + +

    ◆ scstrnlen()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    size_t scstrnlen (size_t count,
     ... 
    )
    +
    + +

    Returns the accumulated length of all specified strings.

    +

    Attention: if the count argument is larger than the count of the specified strings, the behavior is undefined.

    +
    Parameters
    + + + +
    countthe total number of specified strings
    ...all strings
    +
    +
    +
    Returns
    the accumulated length of all strings
    + +
    +
    + +

    ◆ scstrprefix()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrprefix (scstr_t string,
    scstr_t prefix 
    )
    +
    + +

    Checks, if a string has a specific prefix.

    +
    Parameters
    + + + +
    stringthe string to check
    prefixthe prefix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified prefix, 0 otherwise
    + +
    +
    + +

    ◆ scstrrchr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    scstr_t scstrrchr (scstr_t string,
    int chr 
    )
    +
    + +

    Returns an immutable substring starting at the location of the last occurrence of the specified character.

    +

    If the string does not contain the character, an empty string is returned.

    +
    Parameters
    + + + +
    stringthe string where to locate the character
    chrthe character to locate
    +
    +
    +
    Returns
    a substring starting at the last location of chr
    +
    See also
    scstrsubs()
    + +
    +
    + +

    ◆ scstrscstr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    scstr_t scstrscstr (scstr_t string,
    scstr_t match 
    )
    +
    + +

    Returns an immutable substring starting at the location of the first occurrence of the specified immutable string.

    +

    If the string does not contain the other string, an empty string is returned.

    +

    If match is an empty string, the complete string is returned.

    +
    Parameters
    + + + +
    stringthe string to be scanned
    matchstring containing the sequence of characters to match
    +
    +
    +
    Returns
    a substring starting at the first occurrence of match, or an empty string, if the sequence is not present in string
    + +
    +
    + +

    ◆ scstrsplit()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t* scstrsplit (scstr_t string,
    scstr_t delim,
    ssize_t * count 
    )
    +
    + +

    Splits a string into parts by using a delimiter string.

    +

    This function will return NULL, if one of the following happens:

      +
    • +the string length is zero
      • +
    • +the delimeter length is zero
      • +
    • +the string equals the delimeter
      • +
    • +memory allocation fails
      • +
    +

    The integer referenced by count is used as input and determines the maximum size of the resulting array, i.e. the maximum count of splits to perform + 1.

    +

    The integer referenced by count is also used as output and is set to

      +
    • +-2, on memory allocation errors
      • +
    • +-1, if either the string or the delimiter is an empty string
      • +
    • +0, if the string equals the delimiter
      • +
    • +1, if the string does not contain the delimiter
      • +
    • +the count of array items, otherwise
      • +
    +

    If the string starts with the delimiter, the first item of the resulting array will be an empty string.

    +

    If the string ends with the delimiter and the maximum list size is not exceeded, the last array item will be an empty string. In case the list size would be exceeded, the last array item will be the remaining string after the last split, including the terminating delimiter.

    +

    Attention: The array pointer AND all sstr_t.ptr of the array items must be manually passed to free(). Use scstrsplit_a() with an allocator to managed memory, to avoid this.

    +
    Parameters
    + + + + +
    stringthe string to split
    delimthe delimiter string
    countIN: the maximum size of the resulting array (0 = no limit), OUT: the actual size of the array
    +
    +
    +
    Returns
    a sstr_t array containing the split strings or NULL on error
    +
    See also
    scstrsplit_a()
    + +
    +
    + +

    ◆ scstrsplit_a()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t* scstrsplit_a (UcxAllocator * allocator,
    scstr_t string,
    scstr_t delim,
    ssize_t * count 
    )
    +
    + +

    Performing scstrsplit() using a UcxAllocator.

    +

    Read the description of scstrsplit() for details.

    +

    The memory for the sstr_t.ptr pointers of the array items and the memory for the sstr_t array itself are allocated by using the UcxAllocator.malloc() function.

    +
    Parameters
    + + + + + +
    allocatorthe UcxAllocator used for allocating memory
    stringthe string to split
    delimthe delimiter string
    countIN: the maximum size of the resulting array (0 = no limit), OUT: the actual size of the array
    +
    +
    +
    Returns
    a sstr_t array containing the split strings or NULL on error
    +
    See also
    scstrsplit()
    + +
    +
    + +

    ◆ scstrsstr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t scstrsstr (sstr_t string,
    scstr_t match 
    )
    +
    + +

    Returns a substring starting at the location of the first occurrence of the specified string.

    +

    If the string does not contain the other string, an empty string is returned.

    +

    If match is an empty string, the complete string is returned.

    +
    Parameters
    + + + +
    stringthe string to be scanned
    matchstring containing the sequence of characters to match
    +
    +
    +
    Returns
    a substring starting at the first occurrence of match, or an empty string, if the sequence is not present in string
    + +
    +
    + +

    ◆ scstrsubs()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    scstr_t scstrsubs (scstr_t string,
    size_t start 
    )
    +
    + +

    Returns a substring of an immutable string starting at the specified location.

    +

    Attention: the new string references the same memory area as the input string and is NOT required to be NULL-terminated. Use scstrdup() to get a copy.

    +
    Parameters
    + + + +
    stringinput string
    startstart location of the substring
    +
    +
    +
    Returns
    a substring of string starting at start
    +
    See also
    scstrsubsl()
    +
    +scstrchr()
    + +
    +
    + +

    ◆ scstrsubsl()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    scstr_t scstrsubsl (scstr_t string,
    size_t start,
    size_t length 
    )
    +
    + +

    Returns a substring of an immutable string with a maximum length starting at the specified location.

    +

    Attention: the new string references the same memory area as the input string and is NOT required to be NULL-terminated. Use scstrdup() to get a copy.

    +
    Parameters
    + + + + +
    stringinput string
    startstart location of the substring
    lengththe maximum length of the substring
    +
    +
    +
    Returns
    a substring of string starting at start with a maximum length of length
    +
    See also
    scstrsubs()
    +
    +scstrchr()
    + +
    +
    + +

    ◆ scstrsuffix()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int scstrsuffix (scstr_t string,
    scstr_t suffix 
    )
    +
    + +

    Checks, if a string has a specific suffix.

    +
    Parameters
    + + + +
    stringthe string to check
    suffixthe suffix the string should have
    +
    +
    +
    Returns
    1, if and only if the string has the specified suffix, 0 otherwise
    + +
    +
    + +

    ◆ scstrtrim()

    + +
    +
    + + + + + + + + +
    scstr_t scstrtrim (scstr_t string)
    +
    + +

    Omits leading and trailing spaces.

    +

    This function returns a new scstr_t containing a trimmed version of the specified string.

    +

    Note: the new scstr_t references the same memory, thus you MUST NOT pass the scstr_t.ptr of the return value to free(). It is also highly recommended to avoid assignments like mystr = scstrtrim(mystr); as you lose the reference to the source string. Assignments of this type are only permitted, if the scstr_t.ptr of the source string does not need to be freed or if another reference to the source string exists.

    +
    Parameters
    + + +
    stringthe string that shall be trimmed
    +
    +
    +
    Returns
    a new scstr_t containing the trimmed string
    + +
    +
    + +

    ◆ scstrupper()

    + +
    +
    + + + + + + + + +
    sstr_t scstrupper (scstr_t string)
    +
    + +

    Returns a upper case version of a string.

    +

    This function creates a duplicate of the input string, first (see scstrdup()).

    +
    Parameters
    + + +
    stringthe input string
    +
    +
    +
    Returns
    the resulting upper case string
    +
    See also
    scstrdup()
    + +
    +
    + +

    ◆ scstrupper_a()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t scstrupper_a (UcxAllocator * allocator,
    scstr_t string 
    )
    +
    + +

    Returns a upper case version of a string.

    +

    This function creates a duplicate of the input string, first (see scstrdup_a()).

    +
    Parameters
    + + + +
    allocatorthe allocator used for duplicating the string
    stringthe input string
    +
    +
    +
    Returns
    the resulting upper case string
    +
    See also
    scstrdup_a()
    + +
    +
    + +

    ◆ sstr()

    + +
    +
    + + + + + + + + +
    sstr_t sstr (char * cstring)
    +
    + +

    Creates a new sstr_t based on a C string.

    +

    The length is implicitly inferred by using a call to strlen().

    +

    Note: the sstr_t will share the specified pointer to the C string. If you do want a copy, use sstrdup() on the return value of this function.

    +

    If you need to wrap a constant string, use scstr().

    +
    Parameters
    + + +
    cstringthe C string to wrap
    +
    +
    +
    Returns
    a new sstr_t containing the C string
    +
    See also
    sstrn()
    + +
    +
    + +

    ◆ sstrchr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t sstrchr (sstr_t string,
    int chr 
    )
    +
    + +

    Returns a substring starting at the location of the first occurrence of the specified character.

    +

    If the string does not contain the character, an empty string is returned.

    +
    Parameters
    + + + +
    stringthe string where to locate the character
    chrthe character to locate
    +
    +
    +
    Returns
    a substring starting at the first location of chr
    +
    See also
    sstrsubs()
    + +
    +
    + +

    ◆ sstrn()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t sstrn (char * cstring,
    size_t length 
    )
    +
    + +

    Creates a new sstr_t of the specified length based on a C string.

    +

    Note: the sstr_t will share the specified pointer to the C string. If you do want a copy, use sstrdup() on the return value of this function.

    +

    If you need to wrap a constant string, use scstrn().

    +
    Parameters
    + + + +
    cstringthe C string to wrap
    lengththe length of the string
    +
    +
    +
    Returns
    a new sstr_t containing the C string
    +
    See also
    sstr()
    +
    +S()
    + +
    +
    + +

    ◆ sstrrchr()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t sstrrchr (sstr_t string,
    int chr 
    )
    +
    + +

    Returns a substring starting at the location of the last occurrence of the specified character.

    +

    If the string does not contain the character, an empty string is returned.

    +
    Parameters
    + + + +
    stringthe string where to locate the character
    chrthe character to locate
    +
    +
    +
    Returns
    a substring starting at the last location of chr
    +
    See also
    sstrsubs()
    + +
    +
    + +

    ◆ sstrsubs()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    sstr_t sstrsubs (sstr_t string,
    size_t start 
    )
    +
    + +

    Returns a substring starting at the specified location.

    +

    Attention: the new string references the same memory area as the input string and is NOT required to be NULL-terminated. Use sstrdup() to get a copy.

    +
    Parameters
    + + + +
    stringinput string
    startstart location of the substring
    +
    +
    +
    Returns
    a substring of string starting at start
    +
    See also
    sstrsubsl()
    +
    +sstrchr()
    + +
    +
    + +

    ◆ sstrsubsl()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t sstrsubsl (sstr_t string,
    size_t start,
    size_t length 
    )
    +
    + +

    Returns a substring with the given length starting at the specified location.

    +

    Attention: the new string references the same memory area as the input string and is NOT required to be NULL-terminated. Use sstrdup() to get a copy.

    +
    Parameters
    + + + + +
    stringinput string
    startstart location of the substring
    lengththe maximum length of the substring
    +
    +
    +
    Returns
    a substring of string starting at start with a maximum length of length
    +
    See also
    sstrsubs()
    +
    +sstrchr()
    + +
    +
    + +

    ◆ sstrtrim()

    + +
    +
    + + + + + + + + +
    sstr_t sstrtrim (sstr_t string)
    +
    + +

    Omits leading and trailing spaces.

    +

    This function returns a new sstr_t containing a trimmed version of the specified string.

    +

    Note: the new sstr_t references the same memory, thus you MUST NOT pass the sstr_t.ptr of the return value to free(). It is also highly recommended to avoid assignments like mystr = sstrtrim(mystr); as you lose the reference to the source string. Assignments of this type are only permitted, if the sstr_t.ptr of the source string does not need to be freed or if another reference to the source string exists.

    +
    Parameters
    + + +
    stringthe string that shall be trimmed
    +
    +
    +
    Returns
    a new sstr_t containing the trimmed string
    + +
    +
    + +

    ◆ ucx_sc2sc()

    + +
    +
    + + + + + + + + +
    scstr_t ucx_sc2sc (scstr_t str)
    +
    + +

    One of two type adjustment functions that return an scstr_t.

    +

    Used internally to convert a UCX string to an immutable UCX string. This variant is used, when the string is already immutable and no operation needs to be performed.

    +

    Do not use this function manually.

    +
    Parameters
    + + +
    strsome scstr_t
    +
    +
    +
    Returns
    the argument itself
    + +
    +
    + +

    ◆ ucx_ss2c_s()

    + +
    +
    + + + + + + + +
    scstr_t ucx_ss2c_s ()
    +
    + +

    Converts a UCX string to an immutable UCX string (scstr_t).

    +

    This internal function (ab)uses the C standard an expects one single argument which is then implicitly converted to scstr_t without a warning.

    +

    Do not use this function manually.

    +
    Returns
    the an immutable version of the provided string
    + +
    +
    + +

    ◆ ucx_ss2sc()

    + +
    +
    + + + + + + + + +
    scstr_t ucx_ss2sc (sstr_t str)
    +
    + +

    One of two type adjustment functions that return an scstr_t.

    +

    Used internally to convert a UCX string to an immutable UCX string.

    +

    Do not use this function manually.

    +
    Parameters
    + + +
    strsome sstr_t
    +
    +
    +
    Returns
    an immutable (scstr_t) version of the provided string.
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/string_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/string_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,124 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/string.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    string.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    48 #ifndef UCX_STRING_H
    49 #define UCX_STRING_H
    50 
    51 #include "ucx.h"
    52 #include "allocator.h"
    53 #include <stddef.h>
    54 
    55 /*
    56  * Use this macro to disable the shortcuts if you experience macro collision.
    57  */
    58 #ifndef UCX_NO_SSTR_SHORTCUTS
    59 
    63 #define ST(s) { s, sizeof(s)-1 }
    64 
    66 #define S(s) sstrn(s, sizeof(s)-1)
    67 
    69 #define SC(s) scstrn(s, sizeof(s)-1)
    70 #endif /* UCX_NO_SSTR_SHORTCUTS */
    71 
    72 /*
    73  * Use this macro to disable the format macros.
    74  */
    75 #ifndef UCX_NO_SSTR_FORMAT_MACROS
    76 
    77 #define SFMT(s) (int) (s).length, (s).ptr
    78 
    80 #define PRIsstr ".*s"
    81 #endif /* UCX_NO_SSTR_FORMAT_MACROS */
    82 
    83 #ifdef __cplusplus
    84 extern "C" {
    85 #endif
    86 
    90 typedef struct {
    93  char *ptr;
    95  size_t length;
    96 } sstr_t;
    97 
    101 typedef struct {
    104  const char *ptr;
    106  size_t length;
    107 } scstr_t;
    108 
    109 #ifdef __cplusplus
    110 }
    111 #endif
    112 
    113 
    114 #ifdef __cplusplus
    115 
    125 inline scstr_t s2scstr(sstr_t s) {
    126  scstr_t c;
    127  c.ptr = s.ptr;
    128  c.length = s.length;
    129  return c;
    130 }
    131 
    144 inline scstr_t s2scstr(scstr_t str) {
    145  return str;
    146 }
    147 
    153 #define SCSTR(s) s2scstr(s)
    154 #else
    155 
    168 scstr_t ucx_sc2sc(scstr_t str);
    169 
    180 scstr_t ucx_ss2sc(sstr_t str);
    181 
    182 #if __STDC_VERSION__ >= 201112L
    183 
    188 #define SCSTR(str) _Generic(str, sstr_t: ucx_ss2sc, scstr_t: ucx_sc2sc)(str)
    189 
    190 #elif defined(__GNUC__) || defined(__clang__)
    191 
    197 #define SCSTR(str) __builtin_choose_expr( \
    198  __builtin_types_compatible_p(typeof(str), sstr_t), \
    199  ucx_ss2sc, \
    200  ucx_sc2sc)(str)
    201 
    202 #elif defined(__sun)
    203 
    209 #define SCSTR(str) ({typeof(str) ucx_tmp_var_str = str; \
    210  scstr_t ucx_tmp_var_c; \
    211  ucx_tmp_var_c.ptr = ucx_tmp_var_str.ptr;\
    212  ucx_tmp_var_c.length = ucx_tmp_var_str.length;\
    213  ucx_tmp_var_c; })
    214 #else /* no generics and no builtins */
    215 
    226 scstr_t ucx_ss2c_s();
    227 
    233 #define SCSTR(str) ucx_ss2c_s(str)
    234 #endif /* C11 feature test */
    235 
    236 #endif /* C++ */
    237 
    238 #ifdef __cplusplus
    239 extern "C" {
    240 #endif
    241 
    242 
    258 sstr_t sstr(char *cstring);
    259 
    275 sstr_t sstrn(char *cstring, size_t length);
    276 
    290 scstr_t scstr(const char *cstring);
    291 
    292 
    305 scstr_t scstrn(const char *cstring, size_t length);
    306 
    317 size_t scstrnlen(size_t count, ...);
    318 
    329 #define sstrnlen(count, ...) scstrnlen(count, __VA_ARGS__)
    330 
    345 sstr_t scstrcat(size_t count, scstr_t s1, ...);
    346 
    361 #define sstrcat(count, s1, ...) scstrcat(count, SCSTR(s1), __VA_ARGS__)
    362 
    380 sstr_t scstrcat_a(UcxAllocator *alloc, size_t count, scstr_t s1, ...);
    381 
    399 #define sstrcat_a(alloc, count, s1, ...) \
    400  scstrcat_a(alloc, count, SCSTR(s1), __VA_ARGS__)
    401 
    416 sstr_t sstrsubs(sstr_t string, size_t start);
    417 
    434 sstr_t sstrsubsl(sstr_t string, size_t start, size_t length);
    435 
    451 scstr_t scstrsubs(scstr_t string, size_t start);
    452 
    470 scstr_t scstrsubsl(scstr_t string, size_t start, size_t length);
    471 
    484 sstr_t sstrchr(sstr_t string, int chr);
    485 
    498 sstr_t sstrrchr(sstr_t string, int chr);
    499 
    512 scstr_t scstrchr(scstr_t string, int chr);
    513 
    526 scstr_t scstrrchr(scstr_t string, int chr);
    527 
    543 sstr_t scstrsstr(sstr_t string, scstr_t match);
    544 
    560 #define sstrstr(string, match) scstrsstr(string, SCSTR(match))
    561 
    577 scstr_t scstrscstr(scstr_t string, scstr_t match);
    578 
    594 #define sstrscstr(string, match) scstrscstr(string, SCSTR(match))
    595 
    643 sstr_t* scstrsplit(scstr_t string, scstr_t delim, ssize_t *count);
    644 
    692 #define sstrsplit(string, delim, count) \
    693  scstrsplit(SCSTR(string), SCSTR(delim), count)
    694 
    714 sstr_t* scstrsplit_a(UcxAllocator *allocator, scstr_t string, scstr_t delim,
    715  ssize_t *count);
    716 
    736 #define sstrsplit_a(allocator, string, delim, count) \
    737  scstrsplit_a(allocator, SCSTR(string), SCSTR(delim), count)
    738 
    751 int scstrcmp(scstr_t s1, scstr_t s2);
    752 
    765 #define sstrcmp(s1, s2) scstrcmp(SCSTR(s1), SCSTR(s2))
    766 
    780 int scstrcasecmp(scstr_t s1, scstr_t s2);
    781 
    795 #define sstrcasecmp(s1, s2) scstrcasecmp(SCSTR(s1), SCSTR(s2))
    796 
    811 sstr_t scstrdup(scstr_t string);
    812 
    827 #define sstrdup(string) scstrdup(SCSTR(string))
    828 
    845 sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t string);
    846 
    863 #define sstrdup_a(allocator, string) scstrdup_a(allocator, SCSTR(string))
    864 
    865 
    883 sstr_t sstrtrim(sstr_t string);
    884 
    902 scstr_t scstrtrim(scstr_t string);
    903 
    911 int scstrprefix(scstr_t string, scstr_t prefix);
    912 
    920 #define sstrprefix(string, prefix) scstrprefix(SCSTR(string), SCSTR(prefix))
    921 
    929 int scstrsuffix(scstr_t string, scstr_t suffix);
    930 
    938 #define sstrsuffix(string, suffix) scstrsuffix(SCSTR(string), SCSTR(suffix))
    939 
    947 int scstrcaseprefix(scstr_t string, scstr_t prefix);
    948 
    956 #define sstrcaseprefix(string, prefix) \
    957  scstrcaseprefix(SCSTR(string), SCSTR(prefix))
    958 
    966 int scstrcasesuffix(scstr_t string, scstr_t suffix);
    967 
    975 #define sstrcasesuffix(string, suffix) \
    976  scstrcasesuffix(SCSTR(string), SCSTR(suffix))
    977 
    988 sstr_t scstrlower(scstr_t string);
    989 
    999 #define sstrlower(string) scstrlower(SCSTR(string))
    1000 
    1012 sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string);
    1013 
    1014 
    1025 #define sstrlower_a(allocator, string) scstrlower_a(allocator, SCSTR(string))
    1026 
    1037 sstr_t scstrupper(scstr_t string);
    1038 
    1048 #define sstrupper(string) scstrupper(SCSTR(string))
    1049 
    1061 sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string);
    1062 
    1073 #define sstrupper_a(allocator, string) scstrupper_a(allocator, string)
    1074 
    1075 #ifdef __cplusplus
    1076 }
    1077 #endif
    1078 
    1079 #endif /* UCX_STRING_H */
    sstr
    sstr_t sstr(char *cstring)
    Creates a new sstr_t based on a C string.
    Definition: string.c:43
    +
    scstrdup
    sstr_t scstrdup(scstr_t string)
    Creates a duplicate of the specified string.
    Definition: string.c:520
    +
    sstr_t
    The UCX string structure.
    Definition: string.h:90
    +
    scstrlower
    sstr_t scstrlower(scstr_t string)
    Returns a lower case version of a string.
    Definition: string.c:633
    +
    sstrsubsl
    sstr_t sstrsubsl(sstr_t string, size_t start, size_t length)
    Returns a substring with the given length starting at the specified location.
    Definition: string.c:201
    +
    scstrtrim
    scstr_t scstrtrim(scstr_t string)
    Omits leading and trailing spaces.
    Definition: string.c:563
    +
    scstrsplit_a
    sstr_t * scstrsplit_a(UcxAllocator *allocator, scstr_t string, scstr_t delim, ssize_t *count)
    Performing scstrsplit() using a UcxAllocator.
    Definition: string.c:400
    +
    ucx.h
    Main UCX Header providing most common definitions.
    +
    scstrrchr
    scstr_t scstrrchr(scstr_t string, int chr)
    Returns an immutable substring starting at the location of the last occurrence of the specified chara...
    Definition: string.c:270
    +
    ucx_sc2sc
    scstr_t ucx_sc2sc(scstr_t str)
    One of two type adjustment functions that return an scstr_t.
    Definition: string.c:666
    +
    scstrprefix
    int scstrprefix(scstr_t string, scstr_t prefix)
    Checks, if a string has a specific prefix.
    Definition: string.c:570
    +
    sstrrchr
    sstr_t sstrrchr(sstr_t string, int chr)
    Returns a substring starting at the location of the last occurrence of the specified character...
    Definition: string.c:254
    +
    sstrtrim
    sstr_t sstrtrim(sstr_t string)
    Omits leading and trailing spaces.
    Definition: string.c:556
    +
    scstr_t::ptr
    const char * ptr
    A constant pointer to the immutable string (not necessarily NULL-terminated)
    Definition: string.h:104
    +
    scstr_t
    The UCX string structure for immutable (constant) strings.
    Definition: string.h:101
    +
    scstrnlen
    size_t scstrnlen(size_t count,...)
    Returns the accumulated length of all specified strings.
    Definition: string.c:72
    +
    sstrsubs
    sstr_t sstrsubs(sstr_t string, size_t start)
    Returns a substring starting at the specified location.
    Definition: string.c:197
    +
    scstrcasecmp
    int scstrcasecmp(scstr_t s1, scstr_t s2)
    Compares two UCX strings ignoring the case.
    Definition: string.c:506
    +
    ucx_ss2sc
    scstr_t ucx_ss2sc(sstr_t str)
    One of two type adjustment functions that return an scstr_t.
    Definition: string.c:669
    +
    scstrcmp
    int scstrcmp(scstr_t s1, scstr_t s2)
    Compares two UCX strings with standard memcmp().
    Definition: string.c:496
    +
    sstr_t::ptr
    char * ptr
    A pointer to the string (not necessarily NULL-terminated)
    Definition: string.h:93
    +
    UcxAllocator
    UCX allocator data structure containing memory management functions.
    Definition: allocator.h:88
    +
    scstrsplit
    sstr_t * scstrsplit(scstr_t string, scstr_t delim, ssize_t *count)
    Splits a string into parts by using a delimiter string.
    Definition: string.c:396
    +
    scstrlower_a
    sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string)
    Returns a lower case version of a string.
    Definition: string.c:641
    +
    sstr_t::length
    size_t length
    The length of the string.
    Definition: string.h:95
    +
    sstrchr
    sstr_t sstrchr(sstr_t string, int chr)
    Returns a substring starting at the location of the first occurrence of the specified character...
    Definition: string.c:246
    +
    scstrdup_a
    sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t string)
    Creates a duplicate of the specified string using a UcxAllocator.
    Definition: string.c:524
    +
    scstrn
    scstr_t scstrn(const char *cstring, size_t length)
    Creates a new scstr_t of the specified length based on a constant C string.
    Definition: string.c:64
    +
    ucx_ss2c_s
    scstr_t ucx_ss2c_s()
    Converts a UCX string to an immutable UCX string (scstr_t).
    +
    scstrsuffix
    int scstrsuffix(scstr_t string, scstr_t suffix)
    Checks, if a string has a specific suffix.
    Definition: string.c:585
    +
    scstr
    scstr_t scstr(const char *cstring)
    Creates a new scstr_t based on a constant C string.
    Definition: string.c:57
    +
    allocator.h
    Allocator for custom memory management.
    +
    scstrscstr
    scstr_t scstrscstr(scstr_t string, scstr_t match)
    Returns an immutable substring starting at the location of the first occurrence of the specified immu...
    Definition: string.c:375
    +
    scstrcat_a
    sstr_t scstrcat_a(UcxAllocator *alloc, size_t count, scstr_t s1,...)
    Concatenates two or more strings using a UcxAllocator.
    Definition: string.c:167
    +
    scstrcat
    sstr_t scstrcat(size_t count, scstr_t s1,...)
    Concatenates two or more strings.
    Definition: string.c:159
    +
    scstrupper_a
    sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string)
    Returns a upper case version of a string.
    Definition: string.c:657
    +
    scstrupper
    sstr_t scstrupper(scstr_t string)
    Returns a upper case version of a string.
    Definition: string.c:649
    +
    scstrsubsl
    scstr_t scstrsubsl(scstr_t string, size_t start, size_t length)
    Returns a substring of an immutable string with a maximum length starting at the specified location...
    Definition: string.c:214
    +
    sstrn
    sstr_t sstrn(char *cstring, size_t length)
    Creates a new sstr_t of the specified length based on a C string.
    Definition: string.c:50
    +
    scstr_t::length
    size_t length
    The length of the string.
    Definition: string.h:106
    +
    scstrcasesuffix
    int scstrcasesuffix(scstr_t string, scstr_t suffix)
    Checks, if a string has a specific suffix, ignoring the case.
    Definition: string.c:617
    +
    scstrchr
    scstr_t scstrchr(scstr_t string, int chr)
    Returns an immutable substring starting at the location of the first occurrence of the specified char...
    Definition: string.c:262
    +
    scstrsubs
    scstr_t scstrsubs(scstr_t string, size_t start)
    Returns a substring of an immutable string starting at the specified location.
    Definition: string.c:210
    +
    scstrsstr
    sstr_t scstrsstr(sstr_t string, scstr_t match)
    Returns a substring starting at the location of the first occurrence of the specified string...
    Definition: string.c:357
    +
    scstrcaseprefix
    int scstrcaseprefix(scstr_t string, scstr_t prefix)
    Checks, if a string has a specific prefix, ignoring the case.
    Definition: string.c:601
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxAVLNode.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxAVLNode.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,115 @@ + + + + + + + +ucx: UcxAVLNode Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxAVLNode Struct Reference
    +
    +
    + +

    UCX AVL Node. + More...

    + +

    #include <avl.h>

    + + + + + + + + + + + + + + + + + + + + +

    +Data Fields

    +intptr_t key
     The key for this node.
     
    +void * value
     Data contained by this node.
     
    +size_t height
     The height of this (sub)-tree.
     
    +UcxAVLNode * parent
     Parent node.
     
    +UcxAVLNode * left
     Root node of left subtree.
     
    +UcxAVLNode * right
     Root node of right subtree.
     
    +

    Detailed Description

    +

    UCX AVL Node.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/avl.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxAVLTree.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxAVLTree.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,140 @@ + + + + + + + +ucx: UcxAVLTree Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxAVLTree Struct Reference
    +
    +
    + +

    UCX AVL Tree. + More...

    + +

    #include <avl.h>

    + + + + + + + + + + + + + + +

    +Data Fields

    +UcxAllocator * allocator
     The UcxAllocator that shall be used to manage the memory for node data.
     
    +UcxAVLNode * root
     Root node of the tree.
     
    cmp_func cmpfunc
     Compare function that shall be used to compare the UcxAVLNode keys. More...
     
    void * userdata
     Custom user data. More...
     
    +

    Detailed Description

    +

    UCX AVL Tree.

    +

    Field Documentation

    + +

    ◆ cmpfunc

    + +
    +
    + + + + +
    cmp_func UcxAVLTree::cmpfunc
    +
    + +

    Compare function that shall be used to compare the UcxAVLNode keys.

    +
    See also
    UcxAVLNode.key
    + +
    +
    + +

    ◆ userdata

    + +
    +
    + + + + +
    void* UcxAVLTree::userdata
    +
    + +

    Custom user data.

    +

    This data will also be provided to the cmpfunc.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/avl.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxAllocator.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxAllocator.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,128 @@ + + + + + + + +ucx: UcxAllocator Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxAllocator Struct Reference
    +
    +
    + +

    UCX allocator data structure containing memory management functions. + More...

    + +

    #include <allocator.h>

    + + + + + + + + + + + + + + + + + +

    +Data Fields

    void * pool
     Pointer to an area of memory or a complex memory pool. More...
     
    +ucx_allocator_malloc malloc
     The malloc() function for this allocator.
     
    +ucx_allocator_calloc calloc
     The calloc() function for this allocator.
     
    +ucx_allocator_realloc realloc
     The realloc() function for this allocator.
     
    +ucx_allocator_free free
     The free() function for this allocator.
     
    +

    Detailed Description

    +

    UCX allocator data structure containing memory management functions.

    +

    Field Documentation

    + +

    ◆ pool

    + +
    +
    + + + + +
    void* UcxAllocator::pool
    +
    + +

    Pointer to an area of memory or a complex memory pool.

    +

    This pointer will be passed to any memory management function as first argument.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxArray.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxArray.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,111 @@ + + + + + + + +ucx: UcxArray Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxArray Struct Reference
    +
    +
    + +

    UCX array type. + More...

    + +

    #include <array.h>

    + + + + + + + + + + + + + + + + + +

    +Data Fields

    +size_t capacity
     The current capacity of the array.
     
    +size_t size
     The actual number of elements in the array.
     
    +size_t elemsize
     The size of an individual element in bytes.
     
    +void * data
     A pointer to the data.
     
    +UcxAllocator * allocator
     The allocator used for the data.
     
    +

    Detailed Description

    +

    UCX array type.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/array.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxBuffer.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxBuffer.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,193 @@ + + + + + + + +ucx: UcxBuffer Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxBuffer Struct Reference
    +
    +
    + +

    UCX Buffer. + More...

    + +

    #include <buffer.h>

    + + + + + + + + + + + + + + + + + +

    +Data Fields

    char * space
     A pointer to the buffer contents. More...
     
    size_t pos
     Current position of the buffer. More...
     
    size_t capacity
     Current capacity (i.e. More...
     
    size_t size
     Current size of the buffer content. More...
     
    int flags
     Flag register for buffer features. More...
     
    +

    Detailed Description

    +

    UCX Buffer.

    +

    Field Documentation

    + +

    ◆ capacity

    + +
    +
    + + + + +
    size_t UcxBuffer::capacity
    +
    + +

    Current capacity (i.e.

    +

    maximum size) of the buffer.

    + +
    +
    + +

    ◆ flags

    + +
    +
    + + + + +
    int UcxBuffer::flags
    +
    + +

    Flag register for buffer features.

    +
    See also
    UCX_BUFFER_DEFAULT
    +
    +UCX_BUFFER_AUTOFREE
    +
    +UCX_BUFFER_AUTOEXTEND
    + +
    +
    + +

    ◆ pos

    + +
    +
    + + + + +
    size_t UcxBuffer::pos
    +
    + +

    Current position of the buffer.

    + +
    +
    + +

    ◆ size

    + +
    +
    + + + + +
    size_t UcxBuffer::size
    +
    + +

    Current size of the buffer content.

    + +
    +
    + +

    ◆ space

    + +
    +
    + + + + +
    char* UcxBuffer::space
    +
    + +

    A pointer to the buffer contents.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/buffer.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxKey.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxKey.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,149 @@ + + + + + + + +ucx: UcxKey Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxKey Struct Reference
    +
    +
    + +

    Structure to publicly denote a key of a UcxMap. + More...

    + +

    #include <map.h>

    + + + + + + + + + + + +

    +Data Fields

    const void * data
     The key data. More...
     
    size_t len
     The length of the key data. More...
     
    int hash
     A cache for the hash value of the key data. More...
     
    +

    Detailed Description

    +

    Structure to publicly denote a key of a UcxMap.

    +

    Field Documentation

    + +

    ◆ data

    + +
    +
    + + + + +
    const void* UcxKey::data
    +
    + +

    The key data.

    + +
    +
    + +

    ◆ hash

    + +
    +
    + + + + +
    int UcxKey::hash
    +
    + +

    A cache for the hash value of the key data.

    + +
    +
    + +

    ◆ len

    + +
    +
    + + + + +
    size_t UcxKey::len
    +
    + +

    The length of the key data.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/map.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxList.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxList.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,103 @@ + + + + + + + +ucx: UcxList Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxList Struct Reference
    +
    +
    + +

    UCX list structure. + More...

    + +

    #include <list.h>

    + + + + + + + + + + + +

    +Data Fields

    +void * data
     List element payload.
     
    +UcxList * next
     Pointer to the next list element or NULL, if this is the last element.
     
    +UcxList * prev
     Pointer to the previous list element or NULL, if this is the first element.
     
    +

    Detailed Description

    +

    UCX list structure.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/list.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxLogger.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxLogger.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,213 @@ + + + + + + + +ucx: UcxLogger Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxLogger Struct Reference
    +
    +
    + +

    The UCX Logger object. + More...

    + +

    #include <logging.h>

    + + + + + + + + + + + + + + + + + + + + +

    +Data Fields

    void * stream
     The stream this logger writes its messages to. More...
     
    write_func writer
     The write function that shall be used. More...
     
    char * dateformat
     The date format for timestamp outputs including the delimiter (default: "%F %T %z "). More...
     
    unsigned int level
     The level, this logger operates on. More...
     
    unsigned int mask
     A configuration mask for automatic output. More...
     
    UcxMap * levels
     A map of valid log levels for this logger. More...
     
    +

    Detailed Description

    +

    The UCX Logger object.

    +

    Field Documentation

    + +

    ◆ dateformat

    + +
    +
    + + + + +
    char* UcxLogger::dateformat
    +
    + +

    The date format for timestamp outputs including the delimiter (default: "%F %T %z ").

    +
    See also
    UCX_LOGGER_TIMESTAMP
    + +
    +
    + +

    ◆ level

    + +
    +
    + + + + +
    unsigned int UcxLogger::level
    +
    + +

    The level, this logger operates on.

    +

    If a log command is issued, the message will only be logged, if the log level of the message is less or equal than the log level of the logger.

    + +
    +
    + +

    ◆ levels

    + +
    +
    + + + + +
    UcxMap* UcxLogger::levels
    +
    + +

    A map of valid log levels for this logger.

    +

    The keys represent all valid log levels and the values provide string representations, that are used, if the UCX_LOGGER_LEVEL flag is set.

    +

    The exact data types are unsigned int for the key and const char* for the value.

    +
    See also
    UCX_LOGGER_LEVEL
    + +
    +
    + +

    ◆ mask

    + +
    +
    + + + + +
    unsigned int UcxLogger::mask
    +
    + +

    A configuration mask for automatic output.

    +

    For each flag that is set, the logger automatically outputs some extra information like the timestamp or the source file and line number. See the documentation for the flags for details.

    + +
    +
    + +

    ◆ stream

    + +
    +
    + + + + +
    void* UcxLogger::stream
    +
    + +

    The stream this logger writes its messages to.

    + +
    +
    + +

    ◆ writer

    + +
    +
    + + + + +
    write_func UcxLogger::writer
    +
    + +

    The write function that shall be used.

    +

    For standard file or stdout loggers this might be standard fwrite (default).

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/logging.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxMap.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxMap.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,168 @@ + + + + + + + +ucx: UcxMap Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxMap Struct Reference
    +
    +
    + +

    Structure for the UCX map. + More...

    + +

    #include <map.h>

    + + + + + + + + + + + + + + +

    +Data Fields

    UcxAllocator * allocator
     An allocator that is used for the map elements. More...
     
    UcxMapElement ** map
     The array of map element lists. More...
     
    size_t size
     The size of the map is the length of the element list array. More...
     
    size_t count
     The count of elements currently stored in this map. More...
     
    +

    Detailed Description

    +

    Structure for the UCX map.

    +

    Field Documentation

    + +

    ◆ allocator

    + +
    +
    + + + + +
    UcxAllocator* UcxMap::allocator
    +
    + +

    An allocator that is used for the map elements.

    + +
    +
    + +

    ◆ count

    + +
    +
    + + + + +
    size_t UcxMap::count
    +
    + +

    The count of elements currently stored in this map.

    + +
    +
    + +

    ◆ map

    + +
    +
    + + + + +
    UcxMapElement** UcxMap::map
    +
    + +

    The array of map element lists.

    + +
    +
    + +

    ◆ size

    + +
    +
    + + + + +
    size_t UcxMap::size
    +
    + +

    The size of the map is the length of the element list array.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/map.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxMapElement.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxMapElement.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,149 @@ + + + + + + + +ucx: UcxMapElement Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxMapElement Struct Reference
    +
    +
    + +

    Structure for an element of a UcxMap. + More...

    + +

    #include <map.h>

    + + + + + + + + + + + +

    +Data Fields

    void * data
     The value data. More...
     
    UcxMapElement * next
     A pointer to the next element in the current list. More...
     
    struct UcxMapKey key
     The corresponding key. More...
     
    +

    Detailed Description

    +

    Structure for an element of a UcxMap.

    +

    Field Documentation

    + +

    ◆ data

    + +
    +
    + + + + +
    void* UcxMapElement::data
    +
    + +

    The value data.

    + +
    +
    + +

    ◆ key

    + +
    +
    + + + + +
    struct UcxMapKey UcxMapElement::key
    +
    + +

    The corresponding key.

    + +
    +
    + +

    ◆ next

    + +
    +
    + + + + +
    UcxMapElement* UcxMapElement::next
    +
    + +

    A pointer to the next element in the current list.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/map.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxMapIterator.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxMapIterator.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,150 @@ + + + + + + + +ucx: UcxMapIterator Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxMapIterator Struct Reference
    +
    +
    + +

    Structure for an iterator over a UcxMap. + More...

    + +

    #include <map.h>

    + + + + + + + + + + + +

    +Data Fields

    UcxMap const * map
     The map to iterate over. More...
     
    UcxMapElement * cur
     The current map element. More...
     
    size_t index
     The current index of the element list array. More...
     
    +

    Detailed Description

    +

    Structure for an iterator over a UcxMap.

    +

    Field Documentation

    + +

    ◆ cur

    + +
    +
    + + + + +
    UcxMapElement* UcxMapIterator::cur
    +
    + +

    The current map element.

    + +
    +
    + +

    ◆ index

    + +
    +
    + + + + +
    size_t UcxMapIterator::index
    +
    + +

    The current index of the element list array.

    +

    Attention: this is NOT the element index! Do NOT manually iterate over the map by increasing this index. Use ucx_map_iter_next().

    See also
    UcxMap.map
    + +
    +
    + +

    ◆ map

    + +
    +
    + + + + +
    UcxMap const* UcxMapIterator::map
    +
    + +

    The map to iterate over.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/map.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxMapKey.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxMapKey.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,149 @@ + + + + + + + +ucx: UcxMapKey Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxMapKey Struct Reference
    +
    +
    + +

    Internal structure for a key of a UcxMap. + More...

    + +

    #include <map.h>

    + + + + + + + + + + + +

    +Data Fields

    void * data
     The key data. More...
     
    size_t len
     The length of the key data. More...
     
    int hash
     The hash value of the key data. More...
     
    +

    Detailed Description

    +

    Internal structure for a key of a UcxMap.

    +

    Field Documentation

    + +

    ◆ data

    + +
    +
    + + + + +
    void* UcxMapKey::data
    +
    + +

    The key data.

    + +
    +
    + +

    ◆ hash

    + +
    +
    + + + + +
    int UcxMapKey::hash
    +
    + +

    The hash value of the key data.

    + +
    +
    + +

    ◆ len

    + +
    +
    + + + + +
    size_t UcxMapKey::len
    +
    + +

    The length of the key data.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/map.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxMempool.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxMempool.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,153 @@ + + + + + + + +ucx: UcxMempool Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxMempool Struct Reference
    +
    +
    + +

    UCX mempool structure. + More...

    + +

    #include <mempool.h>

    + + + + + + + + + + + + + + +

    +Data Fields

    +UcxAllocator * allocator
     UcxAllocator based on this pool.
     
    void ** data
     List of pointers to pooled memory. More...
     
    size_t ndata
     Count of pooled memory items. More...
     
    size_t size
     Memory pool size. More...
     
    +

    Detailed Description

    +

    UCX mempool structure.

    +

    Field Documentation

    + +

    ◆ data

    + +
    +
    + + + + +
    void** UcxMempool::data
    +
    + +

    List of pointers to pooled memory.

    + +
    +
    + +

    ◆ ndata

    + +
    +
    + + + + +
    size_t UcxMempool::ndata
    +
    + +

    Count of pooled memory items.

    + +
    +
    + +

    ◆ size

    + +
    +
    + + + + +
    size_t UcxMempool::size
    +
    + +

    Memory pool size.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/mempool.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxProperties.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxProperties.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,313 @@ + + + + + + + +ucx: UcxProperties Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxProperties Struct Reference
    +
    +
    + +

    UcxProperties object for parsing properties data. + More...

    + +

    #include <properties.h>

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Data Fields

    char * buffer
     Input buffer (don't set manually). More...
     
    size_t buflen
     Length of the input buffer (don't set manually). More...
     
    size_t pos
     Current buffer position (don't set manually). More...
     
    char * tmp
     Internal temporary buffer (don't set manually). More...
     
    size_t tmplen
     Internal temporary buffer length (don't set manually). More...
     
    size_t tmpcap
     Internal temporary buffer capacity (don't set manually). More...
     
    int error
     Parser error code. More...
     
    char delimiter
     The delimiter that shall be used. More...
     
    char comment1
     The first comment character. More...
     
    char comment2
     The second comment character. More...
     
    char comment3
     The third comment character. More...
     
    +

    Detailed Description

    +

    UcxProperties object for parsing properties data.

    +

    Most of the fields are for internal use only. You may configure the properties parser, e.g. by changing the used delimiter or specifying up to three different characters that shall introduce comments.

    +

    Field Documentation

    + +

    ◆ buffer

    + +
    +
    + + + + +
    char* UcxProperties::buffer
    +
    + +

    Input buffer (don't set manually).

    +

    Automatically set by calls to ucx_properties_fill().

    + +
    +
    + +

    ◆ buflen

    + +
    +
    + + + + +
    size_t UcxProperties::buflen
    +
    + +

    Length of the input buffer (don't set manually).

    +

    Automatically set by calls to ucx_properties_fill().

    + +
    +
    + +

    ◆ comment1

    + +
    +
    + + + + +
    char UcxProperties::comment1
    +
    + +

    The first comment character.

    +

    This is '#' by default.

    + +
    +
    + +

    ◆ comment2

    + +
    +
    + + + + +
    char UcxProperties::comment2
    +
    + +

    The second comment character.

    +

    This is not set by default.

    + +
    +
    + +

    ◆ comment3

    + +
    +
    + + + + +
    char UcxProperties::comment3
    +
    + +

    The third comment character.

    +

    This is not set by default.

    + +
    +
    + +

    ◆ delimiter

    + +
    +
    + + + + +
    char UcxProperties::delimiter
    +
    + +

    The delimiter that shall be used.

    +

    This is '=' by default.

    + +
    +
    + +

    ◆ error

    + +
    +
    + + + + +
    int UcxProperties::error
    +
    + +

    Parser error code.

    +

    This is always 0 on success and a nonzero value on syntax errors. The value is set by ucx_properties_next().

    + +
    +
    + +

    ◆ pos

    + +
    +
    + + + + +
    size_t UcxProperties::pos
    +
    + +

    Current buffer position (don't set manually).

    +

    Used by ucx_properties_next().

    + +
    +
    + +

    ◆ tmp

    + +
    +
    + + + + +
    char* UcxProperties::tmp
    +
    + +

    Internal temporary buffer (don't set manually).

    +

    Used by ucx_properties_next().

    + +
    +
    + +

    ◆ tmpcap

    + +
    +
    + + + + +
    size_t UcxProperties::tmpcap
    +
    + +

    Internal temporary buffer capacity (don't set manually).

    +

    Used by ucx_properties_next().

    + +
    +
    + +

    ◆ tmplen

    + +
    +
    + + + + +
    size_t UcxProperties::tmplen
    +
    + +

    Internal temporary buffer length (don't set manually).

    +

    Used by ucx_properties_next().

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxStack.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxStack.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,123 @@ + + + + + + + +ucx: UcxStack Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxStack Struct Reference
    +
    +
    + +

    UCX stack structure. + More...

    + +

    #include <stack.h>

    + + + + + + + + + + + + + + +

    +Data Fields

    +UcxAllocator allocator
     UcxAllocator based on this stack.
     
    size_t size
     Stack size. More...
     
    +char * space
     Pointer to the bottom of the stack.
     
    +char * top
     Pointer to the top of the stack.
     
    +

    Detailed Description

    +

    UCX stack structure.

    +

    Field Documentation

    + +

    ◆ size

    + +
    +
    + + + + +
    size_t UcxStack::size
    +
    + +

    Stack size.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/stack.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxTestList.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxTestList.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,130 @@ + + + + + + + +ucx: UcxTestList Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxTestList Struct Reference
    +
    +
    + +

    Structure for the internal list of test cases. + More...

    + +

    #include <test.h>

    + + + + + + + + +

    +Data Fields

    UcxTest test
     Test case. More...
     
    UcxTestList * next
     Pointer to the next list element. More...
     
    +

    Detailed Description

    +

    Structure for the internal list of test cases.

    +

    Field Documentation

    + +

    ◆ next

    + +
    +
    + + + + +
    UcxTestList* UcxTestList::next
    +
    + +

    Pointer to the next list element.

    + +
    +
    + +

    ◆ test

    + +
    +
    + + + + +
    UcxTest UcxTestList::test
    +
    + +

    Test case.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/test.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structUcxTestSuite.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structUcxTestSuite.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,150 @@ + + + + + + + +ucx: UcxTestSuite Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    UcxTestSuite Struct Reference
    +
    +
    + +

    A test suite containing multiple test cases. + More...

    + +

    #include <test.h>

    + + + + + + + + + + + +

    +Data Fields

    unsigned int success
     The number of successful tests after the suite has been run. More...
     
    unsigned int failure
     The number of failed tests after the suite has been run. More...
     
    UcxTestList * tests
     Internal list of test cases. More...
     
    +

    Detailed Description

    +

    A test suite containing multiple test cases.

    +

    Field Documentation

    + +

    ◆ failure

    + +
    +
    + + + + +
    unsigned int UcxTestSuite::failure
    +
    + +

    The number of failed tests after the suite has been run.

    + +
    +
    + +

    ◆ success

    + +
    +
    + + + + +
    unsigned int UcxTestSuite::success
    +
    + +

    The number of successful tests after the suite has been run.

    + +
    +
    + +

    ◆ tests

    + +
    +
    + + + + +
    UcxTestList* UcxTestSuite::tests
    +
    + +

    Internal list of test cases.

    +

    Use ucx_test_register() to add tests to this list.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/test.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structscstr__t.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structscstr__t.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,99 @@ + + + + + + + +ucx: scstr_t Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    scstr_t Struct Reference
    +
    +
    + +

    The UCX string structure for immutable (constant) strings. + More...

    + +

    #include <string.h>

    + + + + + + + + +

    +Data Fields

    +const char * ptr
     A constant pointer to the immutable string (not necessarily NULL-terminated)
     
    +size_t length
     The length of the string.
     
    +

    Detailed Description

    +

    The UCX string structure for immutable (constant) strings.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/string.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structsstr__t.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structsstr__t.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,99 @@ + + + + + + + +ucx: sstr_t Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    sstr_t Struct Reference
    +
    +
    + +

    The UCX string structure. + More...

    + +

    #include <string.h>

    + + + + + + + + +

    +Data Fields

    +char * ptr
     A pointer to the string (not necessarily NULL-terminated)
     
    +size_t length
     The length of the string.
     
    +

    Detailed Description

    +

    The UCX string structure.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/string.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structucx__memchunk.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structucx__memchunk.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,129 @@ + + + + + + + +ucx: ucx_memchunk Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    ucx_memchunk Struct Reference
    +
    +
    + +

    Capsule for destructible memory chunks. + More...

    + + + + + + + + +

    +Data Fields

    ucx_destructor destructor
     The destructor for the memory chunk. More...
     
    char c
     First byte of the memory chunk. More...
     
    +

    Detailed Description

    +

    Capsule for destructible memory chunks.

    +

    Field Documentation

    + +

    ◆ c

    + +
    +
    + + + + +
    char ucx_memchunk::c
    +
    + +

    First byte of the memory chunk.

    +

    Note, that the address &c is also the address of the whole memory chunk.

    + +
    +
    + +

    ◆ destructor

    + +
    +
    + + + + +
    ucx_destructor ucx_memchunk::destructor
    +
    + +

    The destructor for the memory chunk.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/mempool.c
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structucx__regdestr.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structucx__regdestr.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,128 @@ + + + + + + + +ucx: ucx_regdestr Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    ucx_regdestr Struct Reference
    +
    +
    + +

    Capsule for data and its destructor. + More...

    + + + + + + + + +

    +Data Fields

    ucx_destructor destructor
     The destructor for the data. More...
     
    void * ptr
     A pointer to the data. More...
     
    +

    Detailed Description

    +

    Capsule for data and its destructor.

    +

    Field Documentation

    + +

    ◆ destructor

    + +
    +
    + + + + +
    ucx_destructor ucx_regdestr::destructor
    +
    + +

    The destructor for the data.

    + +
    +
    + +

    ◆ ptr

    + +
    +
    + + + + +
    void* ucx_regdestr::ptr
    +
    + +

    A pointer to the data.

    + +
    +
    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/mempool.c
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/structucx__stack__metadata.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/structucx__stack__metadata.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,99 @@ + + + + + + + +ucx: ucx_stack_metadata Struct Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +Data Fields
    +
    +
    ucx_stack_metadata Struct Reference
    +
    +
    + +

    Metadata for each UCX stack element. + More...

    + +

    #include <stack.h>

    + + + + + + + + +

    +Data Fields

    +char * prev
     Location of the previous element (NULL if this is the first)
     
    +size_t size
     Size of this element.
     
    +

    Detailed Description

    +

    Metadata for each UCX stack element.

    +
    The documentation for this struct was generated from the following file:
      +
    • /home/mike/workspace/c/ucx/src/ucx/stack.h
      • +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/sync_off.png Binary file docs/api-2.1/sync_off.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/sync_on.png Binary file docs/api-2.1/sync_on.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/tab_a.png Binary file docs/api-2.1/tab_a.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/tab_b.png Binary file docs/api-2.1/tab_b.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/tab_h.png Binary file docs/api-2.1/tab_h.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/tab_s.png Binary file docs/api-2.1/tab_s.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/tabs.css --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/tabs.css Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,1 @@ +.sm{position:relative;z-index:9999}.sm,.sm ul,.sm li{display:block;list-style:none;margin:0;padding:0;line-height:normal;direction:ltr;text-align:left;-webkit-tap-highlight-color:transparent}.sm-rtl,.sm-rtl ul,.sm-rtl li{direction:rtl;text-align:right}.sm>li>h1,.sm>li>h2,.sm>li>h3,.sm>li>h4,.sm>li>h5,.sm>li>h6{margin:0;padding:0}.sm ul{display:none}.sm li,.sm a{position:relative}.sm a{display:block}.sm a.disabled{cursor:not-allowed}.sm:after{content:"\00a0";display:block;height:0;font:0px/0 serif;clear:both;visibility:hidden;overflow:hidden}.sm,.sm *,.sm *:before,.sm *:after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sm-dox{background-image:url("tab_b.png")}.sm-dox a,.sm-dox a:focus,.sm-dox a:hover,.sm-dox a:active{padding:0px 12px;padding-right:43px;font-family:"Lucida Grande","Geneva","Helvetica",Arial,sans-serif;font-size:13px;font-weight:bold;line-height:36px;text-decoration:none;text-shadow:0px 1px 1px rgba(255,255,255,0.9);color:#283A5D;outline:none}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a.current{color:#D23600}.sm-dox a.disabled{color:#bbb}.sm-dox a span.sub-arrow{position:absolute;top:50%;margin-top:-14px;left:auto;right:3px;width:28px;height:28px;overflow:hidden;font:bold 12px/28px monospace !important;text-align:center;text-shadow:none;background:rgba(255,255,255,0.5);border-radius:5px}.sm-dox a.highlighted span.sub-arrow:before{display:block;content:'-'}.sm-dox>li:first-child>a,.sm-dox>li:first-child>:not(ul) a{border-radius:5px 5px 0 0}.sm-dox>li:last-child>a,.sm-dox>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul{border-radius:0 0 5px 5px}.sm-dox>li:last-child>a.highlighted,.sm-dox>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted{border-radius:0}.sm-dox ul{background:rgba(162,162,162,0.1)}.sm-dox ul a,.sm-dox ul a:focus,.sm-dox ul a:hover,.sm-dox ul a:active{font-size:12px;border-left:8px solid transparent;line-height:36px;text-shadow:none;background-color:white;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul ul a,.sm-dox ul ul a:hover,.sm-dox ul ul a:focus,.sm-dox ul ul a:active{border-left:16px solid transparent}.sm-dox ul ul ul a,.sm-dox ul ul ul a:hover,.sm-dox ul ul ul a:focus,.sm-dox ul ul ul a:active{border-left:24px solid transparent}.sm-dox ul ul ul ul a,.sm-dox ul ul ul ul a:hover,.sm-dox ul ul ul ul a:focus,.sm-dox ul ul ul ul a:active{border-left:32px solid transparent}.sm-dox ul ul ul ul ul a,.sm-dox ul ul ul ul ul a:hover,.sm-dox ul ul ul ul ul a:focus,.sm-dox ul ul ul ul ul a:active{border-left:40px solid transparent}@media (min-width: 768px){.sm-dox ul{position:absolute;width:12em}.sm-dox li{float:left}.sm-dox.sm-rtl li{float:right}.sm-dox ul li,.sm-dox.sm-rtl ul li,.sm-dox.sm-vertical li{float:none}.sm-dox a{white-space:nowrap}.sm-dox ul a,.sm-dox.sm-vertical a{white-space:normal}.sm-dox .sm-nowrap>li>a,.sm-dox .sm-nowrap>li>:not(ul) a{white-space:nowrap}.sm-dox{padding:0 10px;background-image:url("tab_b.png");line-height:36px}.sm-dox a span.sub-arrow{top:50%;margin-top:-2px;right:12px;width:0;height:0;border-width:4px;border-style:solid dashed dashed dashed;border-color:#283A5D transparent transparent transparent;background:transparent;border-radius:0}.sm-dox a,.sm-dox a:focus,.sm-dox a:active,.sm-dox a:hover,.sm-dox a.highlighted{padding:0px 12px;background-image:url("tab_s.png");background-repeat:no-repeat;background-position:right;border-radius:0 !important}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a:hover span.sub-arrow{border-color:#fff transparent transparent transparent}.sm-dox a.has-submenu{padding-right:24px}.sm-dox li{border-top:0}.sm-dox>li>ul:before,.sm-dox>li>ul:after{content:'';position:absolute;top:-18px;left:30px;width:0;height:0;overflow:hidden;border-width:9px;border-style:dashed dashed solid dashed;border-color:transparent transparent #bbb transparent}.sm-dox>li>ul:after{top:-16px;left:31px;border-width:8px;border-color:transparent transparent #fff transparent}.sm-dox ul{border:1px solid #bbb;padding:5px 0;background:#fff;border-radius:5px !important;box-shadow:0 5px 9px rgba(0,0,0,0.2)}.sm-dox ul a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-color:transparent transparent transparent #555;border-style:dashed dashed dashed solid}.sm-dox ul a,.sm-dox ul a:hover,.sm-dox ul a:focus,.sm-dox ul a:active,.sm-dox ul a.highlighted{color:#555;background-image:none;border:0 !important;color:#555;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul a:hover span.sub-arrow{border-color:transparent transparent transparent #fff}.sm-dox span.scroll-up,.sm-dox span.scroll-down{position:absolute;display:none;visibility:hidden;overflow:hidden;background:#fff;height:36px}.sm-dox span.scroll-up:hover,.sm-dox span.scroll-down:hover{background:#eee}.sm-dox span.scroll-up:hover span.scroll-up-arrow,.sm-dox span.scroll-up:hover span.scroll-down-arrow{border-color:transparent transparent #D23600 transparent}.sm-dox span.scroll-down:hover span.scroll-down-arrow{border-color:#D23600 transparent transparent transparent}.sm-dox span.scroll-up-arrow,.sm-dox span.scroll-down-arrow{position:absolute;top:0;left:50%;margin-left:-6px;width:0;height:0;overflow:hidden;border-width:6px;border-style:dashed dashed solid dashed;border-color:transparent transparent #555 transparent}.sm-dox span.scroll-down-arrow{top:8px;border-style:solid dashed dashed dashed;border-color:#555 transparent transparent transparent}.sm-dox.sm-rtl a.has-submenu{padding-right:12px;padding-left:24px}.sm-dox.sm-rtl a span.sub-arrow{right:auto;left:12px}.sm-dox.sm-rtl.sm-vertical a.has-submenu{padding:10px 20px}.sm-dox.sm-rtl.sm-vertical a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-rtl>li>ul:before{left:auto;right:30px}.sm-dox.sm-rtl>li>ul:after{left:auto;right:31px}.sm-dox.sm-rtl ul a.has-submenu{padding:10px 20px !important}.sm-dox.sm-rtl ul a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-vertical{padding:10px 0;border-radius:5px}.sm-dox.sm-vertical a{padding:10px 20px}.sm-dox.sm-vertical a:hover,.sm-dox.sm-vertical a:focus,.sm-dox.sm-vertical a:active,.sm-dox.sm-vertical a.highlighted{background:#fff}.sm-dox.sm-vertical a.disabled{background-image:url("tab_b.png")}.sm-dox.sm-vertical a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-style:dashed dashed dashed solid;border-color:transparent transparent transparent #555}.sm-dox.sm-vertical>li>ul:before,.sm-dox.sm-vertical>li>ul:after{display:none}.sm-dox.sm-vertical ul a{padding:10px 20px}.sm-dox.sm-vertical ul a:hover,.sm-dox.sm-vertical ul a:focus,.sm-dox.sm-vertical ul a:active,.sm-dox.sm-vertical ul a.highlighted{background:#eee}.sm-dox.sm-vertical ul a.disabled{background:#fff}} diff -r 92e482410453 -r d345541018fa docs/api-2.1/test_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/test_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,547 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/test.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Data Structures | +Macros | +Typedefs | +Functions
    +
    +
    test.h File Reference
    +
    +
    + +

    UCX Test Framework. +More...

    +
    #include "ucx.h"
    +#include <stdio.h>
    +#include <string.h>
    +#include <setjmp.h>
    +
    +

    Go to the source code of this file.

    + + + + + + + + +

    +Data Structures

    struct  UcxTestList
     Structure for the internal list of test cases. More...
     
    struct  UcxTestSuite
     A test suite containing multiple test cases. More...
     
    + + + + + + + + + + + + + + + + + + + + + + +

    +Macros

    #define __FUNCTION__   __func__
     Alias for the __func__ preprocessor macro. More...
     
    #define UCX_TEST(name)   void name(UcxTestSuite* _suite_,FILE *_output_)
     Macro for a UcxTest function header. More...
     
    #define UCX_TEST_BEGIN
     Marks the begin of a test. More...
     
    #define UCX_TEST_ASSERT(condition, message)
     Checks a test assertion. More...
     
    #define UCX_TEST_SUBROUTINE(name, ...)
     Macro for a test subroutine function header. More...
     
    #define UCX_TEST_CALL_SUBROUTINE(name, ...)   name(_suite_,_output_,_env_,__VA_ARGS__);
     Macro for calling a test subroutine. More...
     
    #define UCX_TEST_END   fwrite("success.\n", 1, 9, _output_); _suite_->success++;}
     Marks the end of a test. More...
     
    + + + + + + + + + + +

    +Typedefs

    typedef struct UcxTestSuite UcxTestSuite
     Type for the UcxTestSuite. More...
     
    typedef void(* UcxTest) (UcxTestSuite *, FILE *)
     Pointer to a test function. More...
     
    typedef struct UcxTestList UcxTestList
     Type for the internal list of test cases. More...
     
    + + + + + + + + + + + + + +

    +Functions

    UcxTestSuite * ucx_test_suite_new ()
     Creates a new test suite. More...
     
    void ucx_test_suite_free (UcxTestSuite *suite)
     Destroys a test suite. More...
     
    int ucx_test_register (UcxTestSuite *suite, UcxTest test)
     Registers a test function with the specified test suite. More...
     
    void ucx_test_run (UcxTestSuite *suite, FILE *outstream)
     Runs a test suite and writes the test log to the specified stream. More...
     
    +

    Detailed Description

    +

    UCX Test Framework.

    +

    Usage of this test framework:

    +

    **** IN HEADER FILE: ****

    +
    +UCX_TEST(function_name);
+UCX_TEST_SUBROUTINE(subroutine_name, paramlist); // optional
+

    **** IN SOURCE FILE: **** 

    +UCX_TEST_SUBROUTINE(subroutine_name, paramlist) {
+  // tests with UCX_TEST_ASSERT()
+}
    UCX_TEST(function_name) {
+  // memory allocation and other stuff here
+  UCX_TEST_BEGIN
+  // tests with UCX_TEST_ASSERT() and/or
+  // calls with UCX_TEST_CALL_SUBROUTINE() here
+  UCX_TEST_END
+  // cleanup of memory here
+}
+

    Note: if a test fails, a longjump is performed back to the UCX_TEST_BEGIN macro!

    +

    Attention: Do not call own functions within a test, that use UCX_TEST_ASSERT() macros and are not defined by using UCX_TEST_SUBROUTINE().

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Macro Definition Documentation

    + +

    ◆ __FUNCTION__

    + +
    +
    + + + + +
    #define __FUNCTION__   __func__
    +
    + +

    Alias for the __func__ preprocessor macro.

    +

    Some compilers use __func__ and others use FUNCTION. We use FUNCTION so we define it for those compilers which use __func__.

    + +
    +
    + +

    ◆ UCX_TEST

    + +
    +
    + + + + + + + + +
    #define UCX_TEST( name)   void name(UcxTestSuite* _suite_,FILE *_output_)
    +
    + +

    Macro for a UcxTest function header.

    +

    Use this macro to declare and/or define a UcxTest function.

    +
    Parameters
    + + +
    namethe name of the test function
    +
    +
    + +
    +
    + +

    ◆ UCX_TEST_ASSERT

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define UCX_TEST_ASSERT( condition,
     message 
    )
    +
    +Value:
    if (!(condition)) { \
    fwrite(message".\n", 1, 2+strlen(message), _output_); \
    _suite_->failure++; \
    longjmp(_env_, 1);\
    }
    +

    Checks a test assertion.

    +

    If the assertion is correct, the test carries on. If the assertion is not correct, the specified message (terminated by a dot and a line break) is written to the test suites output stream.

    Parameters
    + + + +
    conditionthe condition to check
    messagethe message that shall be printed out on failure
    +
    +
    + +
    +
    + +

    ◆ UCX_TEST_BEGIN

    + +
    +
    + + + + +
    #define UCX_TEST_BEGIN
    +
    +Value:
    fwrite("Running ", 1, 8, _output_);\
    fwrite(__FUNCTION__, 1, strlen(__FUNCTION__), _output_);\
    fwrite("... ", 1, 4, _output_);\
    jmp_buf _env_; \
    if (!setjmp(_env_)) {
    __FUNCTION__
    #define __FUNCTION__
    Alias for the __func__ preprocessor macro.
    Definition: test.h:91
    +
    +

    Marks the begin of a test.

    +

    Note: Any UCX_TEST_ASSERT() calls must be performed after UCX_TEST_BEGIN.

    +
    See also
    UCX_TEST_END
    + +
    +
    + +

    ◆ UCX_TEST_CALL_SUBROUTINE

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define UCX_TEST_CALL_SUBROUTINE( name,
     ... 
    )   name(_suite_,_output_,_env_,__VA_ARGS__);
    +
    + +

    Macro for calling a test subroutine.

    +

    Subroutines declared with UCX_TEST_SUBROUTINE() can be called by using this macro.

    +

    Note: You may only call subroutines within a UCX_TEST_BEGIN- UCX_TEST_END-block.

    +
    Parameters
    + + + +
    namethe name of the subroutine
    ...the argument list
    +
    +
    +
    See also
    UCX_TEST_SUBROUTINE()
    + +
    +
    + +

    ◆ UCX_TEST_END

    + +
    +
    + + + + +
    #define UCX_TEST_END   fwrite("success.\n", 1, 9, _output_); _suite_->success++;}
    +
    + +

    Marks the end of a test.

    +

    Note: Any UCX_TEST_ASSERT() calls must be performed before UCX_TEST_END.

    +
    See also
    UCX_TEST_BEGIN
    + +
    +
    + +

    ◆ UCX_TEST_SUBROUTINE

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define UCX_TEST_SUBROUTINE( name,
     ... 
    )
    +
    +Value:
    void name(UcxTestSuite* _suite_,\
    FILE *_output_, jmp_buf _env_, __VA_ARGS__)
    UcxTestSuite
    A test suite containing multiple test cases.
    Definition: test.h:116
    +
    +

    Macro for a test subroutine function header.

    +

    Use this to declare and/or define a subroutine that can be called by using UCX_TEST_CALL_SUBROUTINE().

    +
    Parameters
    + + + +
    namethe name of the subroutine
    ...the parameter list
    +
    +
    +
    See also
    UCX_TEST_CALL_SUBROUTINE()
    + +
    +
    +

    Typedef Documentation

    + +

    ◆ UcxTest

    + +
    +
    + + + + +
    typedef void(* UcxTest) (UcxTestSuite *, FILE *)
    +
    + +

    Pointer to a test function.

    + +
    +
    + +

    ◆ UcxTestList

    + +
    +
    + + + + +
    typedef struct UcxTestList UcxTestList
    +
    + +

    Type for the internal list of test cases.

    + +
    +
    + +

    ◆ UcxTestSuite

    + +
    +
    + + + + +
    typedef struct UcxTestSuite UcxTestSuite
    +
    + +

    Type for the UcxTestSuite.

    + +
    +
    +

    Function Documentation

    + +

    ◆ ucx_test_register()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    int ucx_test_register (UcxTestSuite * suite,
    UcxTest test 
    )
    +
    + +

    Registers a test function with the specified test suite.

    +
    Parameters
    + + + +
    suitethe suite, the test function shall be added to
    testthe test function to register
    +
    +
    +
    Returns
    EXIT_SUCCESS on success or EXIT_FAILURE on failure
    + +
    +
    + +

    ◆ ucx_test_run()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void ucx_test_run (UcxTestSuite * suite,
    FILE * outstream 
    )
    +
    + +

    Runs a test suite and writes the test log to the specified stream.

    +
    Parameters
    + + + +
    suitethe test suite to run
    outstreamthe stream the log shall be written to
    +
    +
    + +
    +
    + +

    ◆ ucx_test_suite_free()

    + +
    +
    + + + + + + + + +
    void ucx_test_suite_free (UcxTestSuite * suite)
    +
    + +

    Destroys a test suite.

    +
    Parameters
    + + +
    suitethe test suite to destroy
    +
    +
    + +
    +
    + +

    ◆ ucx_test_suite_new()

    + +
    +
    + + + + + + + +
    UcxTestSuite* ucx_test_suite_new ()
    +
    + +

    Creates a new test suite.

    +
    Returns
    a new test suite
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/test_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/test_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,93 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/test.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    test.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    71 #ifndef UCX_TEST_H
    72 #define UCX_TEST_H
    73 
    74 #include "ucx.h"
    75 #include <stdio.h>
    76 #include <string.h>
    77 #include <setjmp.h>
    78 
    79 #ifdef __cplusplus
    80 extern "C" {
    81 #endif
    82 
    83 #ifndef __FUNCTION__
    84 
    91 #define __FUNCTION__ __func__
    92 #endif
    93 
    95 typedef struct UcxTestSuite UcxTestSuite;
    96 
    98 typedef void(*UcxTest)(UcxTestSuite*,FILE*);
    99 
    101 typedef struct UcxTestList UcxTestList;
    102 
    104 struct UcxTestList {
    105 
    107  UcxTest test;
    108 
    110  UcxTestList *next;
    111 };
    112 
    116 struct UcxTestSuite {
    117 
    119  unsigned int success;
    120 
    122  unsigned int failure;
    123 
    128  UcxTestList *tests;
    129 };
    130 
    135 UcxTestSuite* ucx_test_suite_new();
    136 
    141 void ucx_test_suite_free(UcxTestSuite* suite);
    142 
    151 int ucx_test_register(UcxTestSuite* suite, UcxTest test);
    152 
    158 void ucx_test_run(UcxTestSuite* suite, FILE* outstream);
    159 
    167 #define UCX_TEST(name) void name(UcxTestSuite* _suite_,FILE *_output_)
    168 
    176 #define UCX_TEST_BEGIN fwrite("Running ", 1, 8, _output_);\
    177  fwrite(__FUNCTION__, 1, strlen(__FUNCTION__), _output_);\
    178  fwrite("... ", 1, 4, _output_);\
    179  jmp_buf _env_; \
    180  if (!setjmp(_env_)) {
    181 
    190 #define UCX_TEST_ASSERT(condition,message) if (!(condition)) { \
    191  fwrite(message".\n", 1, 2+strlen(message), _output_); \
    192  _suite_->failure++; \
    193  longjmp(_env_, 1);\
    194  }
    195 
    207 #define UCX_TEST_SUBROUTINE(name,...) void name(UcxTestSuite* _suite_,\
    208  FILE *_output_, jmp_buf _env_, __VA_ARGS__)
    209 
    224 #define UCX_TEST_CALL_SUBROUTINE(name,...) \
    225  name(_suite_,_output_,_env_,__VA_ARGS__);
    226 
    234 #define UCX_TEST_END fwrite("success.\n", 1, 9, _output_); _suite_->success++;}
    235 
    236 #ifdef __cplusplus
    237 }
    238 #endif
    239 
    240 #endif /* UCX_TEST_H */
    241 
    UcxTestSuite::success
    unsigned int success
    The number of successful tests after the suite has been run.
    Definition: test.h:119
    +
    string.h
    Bounded string implementation.
    +
    ucx.h
    Main UCX Header providing most common definitions.
    +
    UcxTestList::test
    UcxTest test
    Test case.
    Definition: test.h:107
    +
    ucx_test_register
    int ucx_test_register(UcxTestSuite *suite, UcxTest test)
    Registers a test function with the specified test suite.
    Definition: test.c:52
    +
    ucx_test_run
    void ucx_test_run(UcxTestSuite *suite, FILE *outstream)
    Runs a test suite and writes the test log to the specified stream.
    Definition: test.c:82
    +
    UcxTestList
    Structure for the internal list of test cases.
    Definition: test.h:104
    +
    ucx_test_suite_new
    UcxTestSuite * ucx_test_suite_new()
    Creates a new test suite.
    Definition: test.c:31
    +
    UcxTestSuite::tests
    UcxTestList * tests
    Internal list of test cases.
    Definition: test.h:128
    +
    UcxTest
    void(* UcxTest)(UcxTestSuite *, FILE *)
    Pointer to a test function.
    Definition: test.h:98
    +
    ucx_test_suite_free
    void ucx_test_suite_free(UcxTestSuite *suite)
    Destroys a test suite.
    Definition: test.c:42
    +
    UcxTestSuite::failure
    unsigned int failure
    The number of failed tests after the suite has been run.
    Definition: test.h:122
    +
    UcxTestList::next
    UcxTestList * next
    Pointer to the next list element.
    Definition: test.h:110
    +
    UcxTestSuite
    A test suite containing multiple test cases.
    Definition: test.h:116
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/uaplogo.png Binary file docs/api-2.1/uaplogo.png has changed diff -r 92e482410453 -r d345541018fa docs/api-2.1/ucx_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/ucx_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,388 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/ucx.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Macros | +Typedefs | +Functions
    +
    +
    ucx.h File Reference
    +
    +
    + +

    Main UCX Header providing most common definitions. +More...

    +
    #include <stdlib.h>
    +#include <stdint.h>
    +#include <sys/types.h>
    +
    +

    Go to the source code of this file.

    + + + + + + + + + + + + + + +

    +Macros

    #define UCX_VERSION_MAJOR   2
     Major UCX version as integer constant. More...
     
    #define UCX_VERSION_MINOR   1
     Minor UCX version as integer constant. More...
     
    #define UCX_VERSION   (((UCX_VERSION_MAJOR)<<16)|UCX_VERSION_MINOR)
     Version constant which ensures to increase monotonically. More...
     
    #define ucx_szmul(a, b, result)   ucx_szmul_impl(a, b, result)
     Performs a multiplication of size_t values and checks for overflow. More...
     
    + + + + + + + + + + + + + + + + + + + +

    +Typedefs

    typedef void(* ucx_destructor) (void *)
     A function pointer to a destructor function. More...
     
    typedef int(* cmp_func) (const void *, const void *, void *)
     Function pointer to a compare function. More...
     
    typedef intmax_t(* distance_func) (const void *, const void *, void *)
     Function pointer to a distance function. More...
     
    typedef void *(* copy_func) (const void *, void *)
     Function pointer to a copy function. More...
     
    typedef size_t(* write_func) (const void *, size_t, size_t, void *)
     Function pointer to a write function. More...
     
    typedef size_t(* read_func) (void *, size_t, size_t, void *)
     Function pointer to a read function. More...
     
    + + + + +

    +Functions

    int ucx_szmul_impl (size_t a, size_t b, size_t *result)
     Performs a multiplication of size_t values and checks for overflow. More...
     
    +

    Detailed Description

    +

    Main UCX Header providing most common definitions.

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Macro Definition Documentation

    + +

    ◆ ucx_szmul

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    #define ucx_szmul( a,
     b,
     result 
    )   ucx_szmul_impl(a, b, result)
    +
    + +

    Performs a multiplication of size_t values and checks for overflow.

    +
    Parameters
    + + + + +
    afirst operand
    bsecond operand
    resulta pointer to a size_t, where the result should be stored
    +
    +
    +
    Returns
    zero, if no overflow occurred and the result is correct, non-zero otherwise
    + +
    +
    + +

    ◆ UCX_VERSION

    + +
    +
    + + + + +
    #define UCX_VERSION   (((UCX_VERSION_MAJOR)<<16)|UCX_VERSION_MINOR)
    +
    + +

    Version constant which ensures to increase monotonically.

    + +
    +
    + +

    ◆ UCX_VERSION_MAJOR

    + +
    +
    + + + + +
    #define UCX_VERSION_MAJOR   2
    +
    + +

    Major UCX version as integer constant.

    + +
    +
    + +

    ◆ UCX_VERSION_MINOR

    + +
    +
    + + + + +
    #define UCX_VERSION_MINOR   1
    +
    + +

    Minor UCX version as integer constant.

    + +
    +
    +

    Typedef Documentation

    + +

    ◆ cmp_func

    + +
    +
    + + + + +
    typedef int(* cmp_func) (const void *, const void *, void *)
    +
    + +

    Function pointer to a compare function.

    +

    The compare function shall take three arguments: the two values that shall be compared and optional additional data. The function shall then return -1 if the first argument is less than the second argument, 1 if the first argument is greater than the second argument and 0 if both arguments are equal. If the third argument is NULL, it shall be ignored.

    + +
    +
    + +

    ◆ copy_func

    + +
    +
    + + + + +
    typedef void*(* copy_func) (const void *, void *)
    +
    + +

    Function pointer to a copy function.

    +

    The copy function shall create a copy of the first argument and may use additional data provided by the second argument. If the second argument is NULL, it shall be ignored.

    +

    Attention: if pointers returned by functions of this type may be passed to free() depends on the implementation of the respective copy_func.

    + +
    +
    + +

    ◆ distance_func

    + +
    +
    + + + + +
    typedef intmax_t(* distance_func) (const void *, const void *, void *)
    +
    + +

    Function pointer to a distance function.

    +

    The distance function shall take three arguments: the two values for which the distance shall be computed and optional additional data. The function shall then return the signed distance as integer value.

    + +
    +
    + +

    ◆ read_func

    + +
    +
    + + + + +
    typedef size_t(* read_func) (void *, size_t, size_t, void *)
    +
    + +

    Function pointer to a read function.

    +

    The signature of the read function shall be compatible to the signature of standard fread, though it may use arbitrary data types for source and destination.

    +

    The arguments shall contain (in ascending order): a pointer to the destination, the length of one element, the element count and a pointer to the source.

    + +
    +
    + +

    ◆ ucx_destructor

    + +
    +
    + + + + +
    typedef void(* ucx_destructor) (void *)
    +
    + +

    A function pointer to a destructor function.

    +
    See also
    ucx_mempool_setdestr()
    +
    +ucx_mempool_regdestr()
    + +
    +
    + +

    ◆ write_func

    + +
    +
    + + + + +
    typedef size_t(* write_func) (const void *, size_t, size_t, void *)
    +
    + +

    Function pointer to a write function.

    +

    The signature of the write function shall be compatible to the signature of standard fwrite, though it may use arbitrary data types for source and destination.

    +

    The arguments shall contain (in ascending order): a pointer to the source, the length of one element, the element count and a pointer to the destination.

    + +
    +
    +

    Function Documentation

    + +

    ◆ ucx_szmul_impl()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_szmul_impl (size_t a,
    size_t b,
    size_t * result 
    )
    +
    + +

    Performs a multiplication of size_t values and checks for overflow.

    +

    This is a custom implementation in case there is no compiler builtin available.

    +
    Parameters
    + + + + +
    afirst operand
    bsecond operand
    resulta pointer to a size_t where the result should be stored
    +
    +
    +
    Returns
    zero, if no overflow occurred and the result is correct, non-zero otherwise
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/ucx_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/ucx_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,85 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/ucx.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    ucx.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    36 #ifndef UCX_H
    37 #define UCX_H
    38 
    40 #define UCX_VERSION_MAJOR 2
    41 
    43 #define UCX_VERSION_MINOR 1
    44 
    46 #define UCX_VERSION (((UCX_VERSION_MAJOR)<<16)|UCX_VERSION_MINOR)
    47 
    48 #include <stdlib.h>
    49 #include <stdint.h>
    50 
    51 #ifdef _WIN32
    52 #if !(defined __ssize_t_defined || defined _SSIZE_T_)
    53 #include <BaseTsd.h>
    54 typedef SSIZE_T ssize_t;
    55 #define __ssize_t_defined
    56 #define _SSIZE_T_
    57 #endif /* __ssize_t_defined and _SSIZE_T */
    58 #else /* !_WIN32 */
    59 #include <sys/types.h>
    60 #endif /* _WIN32 */
    61 
    62 #ifdef __cplusplus
    63 extern "C" {
    64 #endif
    65 
    66 
    72 typedef void(*ucx_destructor)(void*);
    73 
    84 typedef int(*cmp_func)(const void*,const void*,void*);
    85 
    93 typedef intmax_t(*distance_func)(const void*,const void*,void*);
    94 
    106 typedef void*(*copy_func)(const void*,void*);
    107 
    119 typedef size_t(*write_func)(const void*, size_t, size_t, void*);
    120 
    132 typedef size_t(*read_func)(void*, size_t, size_t, void*);
    133 
    134 
    135 
    136 #if __GNUC__ >= 5 || defined(__clang__)
    137 #define UCX_MUL_BUILTIN
    138 
    139 #if __WORDSIZE == 32
    140 
    152 #define ucx_szmul(a, b, result) __builtin_umul_overflow(a, b, result)
    153 #else /* __WORDSIZE != 32 */
    154 
    166 #define ucx_szmul(a, b, result) __builtin_umull_overflow(a, b, result)
    167 #endif /* __WORDSIZE */
    168 
    169 #else /* no GNUC or clang bultin */
    170 
    181 #define ucx_szmul(a, b, result) ucx_szmul_impl(a, b, result)
    182 
    195 int ucx_szmul_impl(size_t a, size_t b, size_t *result);
    196 
    197 #endif
    198 
    199 #ifdef __cplusplus
    200 }
    201 #endif
    202 
    203 #endif /* UCX_H */
    204 
    cmp_func
    int(* cmp_func)(const void *, const void *, void *)
    Function pointer to a compare function.
    Definition: ucx.h:84
    +
    read_func
    size_t(* read_func)(void *, size_t, size_t, void *)
    Function pointer to a read function.
    Definition: ucx.h:132
    +
    distance_func
    intmax_t(* distance_func)(const void *, const void *, void *)
    Function pointer to a distance function.
    Definition: ucx.h:93
    +
    ucx_szmul_impl
    int ucx_szmul_impl(size_t a, size_t b, size_t *result)
    Performs a multiplication of size_t values and checks for overflow.
    Definition: ucx.c:48
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    ucx_destructor
    void(* ucx_destructor)(void *)
    A function pointer to a destructor function.
    Definition: ucx.h:72
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/utils_8h.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/utils_8h.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,2233 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/utils.h File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Macros | +Functions
    +
    +
    utils.h File Reference
    +
    +
    + +

    Compare, copy and printf functions. +More...

    +
    #include "ucx.h"
    +#include "string.h"
    +#include "allocator.h"
    +#include <inttypes.h>
    +#include <stdarg.h>
    +
    +

    Go to the source code of this file.

    + + + + + + + + + + + + + + + + + + + + +

    +Macros

    +#define UCX_STREAM_COPY_BUFSIZE   4096
     Default buffer size for ucx_stream_copy() and ucx_stream_ncopy().
     
    #define ucx_stream_copy(src, dest, rfnc, wfnc)
     Shorthand for an unbounded ucx_stream_bncopy call using a default buffer. More...
     
    #define ucx_stream_ncopy(src, dest, rfnc, wfnc, n)
     Shorthand for ucx_stream_bncopy using a default copy buffer. More...
     
    #define ucx_stream_bcopy(src, dest, rfnc, wfnc, buf, bufsize)
     Shorthand for an unbounded ucx_stream_bncopy call using the specified buffer. More...
     
    #define ucx_sprintf(...)   ucx_asprintf(ucx_default_allocator(), __VA_ARGS__)
     Shortcut for ucx_asprintf() with default allocator. More...
     
    #define ucx_bprintf(buffer, ...)
     A printf() like function which writes the output to a UcxBuffer. More...
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    void * ucx_strcpy (const void *s, void *data)
     Copies a string. More...
     
    void * ucx_memcpy (const void *m, void *n)
     Copies a memory area. More...
     
    size_t ucx_stream_bncopy (void *src, void *dest, read_func rfnc, write_func wfnc, char *buf, size_t bufsize, size_t n)
     Reads data from a stream and writes it to another stream. More...
     
    int ucx_cmp_str (const void *s1, const void *s2, void *data)
     Wraps the strcmp function. More...
     
    int ucx_cmp_strn (const void *s1, const void *s2, void *n)
     Wraps the strncmp function. More...
     
    int ucx_cmp_sstr (const void *s1, const void *s2, void *data)
     Wraps the sstrcmp function. More...
     
    int ucx_cmp_int (const void *i1, const void *i2, void *data)
     Compares two integers of type int. More...
     
    int ucx_cmp_longint (const void *i1, const void *i2, void *data)
     Compares two integers of type long int. More...
     
    int ucx_cmp_longlong (const void *i1, const void *i2, void *data)
     Compares two integers of type long long. More...
     
    int ucx_cmp_int16 (const void *i1, const void *i2, void *data)
     Compares two integers of type int16_t. More...
     
    int ucx_cmp_int32 (const void *i1, const void *i2, void *data)
     Compares two integers of type int32_t. More...
     
    int ucx_cmp_int64 (const void *i1, const void *i2, void *data)
     Compares two integers of type int64_t. More...
     
    int ucx_cmp_uint (const void *i1, const void *i2, void *data)
     Compares two integers of type unsigned int. More...
     
    int ucx_cmp_ulongint (const void *i1, const void *i2, void *data)
     Compares two integers of type unsigned long int. More...
     
    int ucx_cmp_ulonglong (const void *i1, const void *i2, void *data)
     Compares two integers of type unsigned long long. More...
     
    int ucx_cmp_uint16 (const void *i1, const void *i2, void *data)
     Compares two integers of type uint16_t. More...
     
    int ucx_cmp_uint32 (const void *i1, const void *i2, void *data)
     Compares two integers of type uint32_t. More...
     
    int ucx_cmp_uint64 (const void *i1, const void *i2, void *data)
     Compares two integers of type uint64_t. More...
     
    intmax_t ucx_dist_int (const void *i1, const void *i2, void *data)
     Distance function for integers of type int. More...
     
    intmax_t ucx_dist_longint (const void *i1, const void *i2, void *data)
     Distance function for integers of type long int. More...
     
    intmax_t ucx_dist_longlong (const void *i1, const void *i2, void *data)
     Distance function for integers of type long long. More...
     
    intmax_t ucx_dist_int16 (const void *i1, const void *i2, void *data)
     Distance function for integers of type int16_t. More...
     
    intmax_t ucx_dist_int32 (const void *i1, const void *i2, void *data)
     Distance function for integers of type int32_t. More...
     
    intmax_t ucx_dist_int64 (const void *i1, const void *i2, void *data)
     Distance function for integers of type int64_t. More...
     
    intmax_t ucx_dist_uint (const void *i1, const void *i2, void *data)
     Distance function for integers of type unsigned int. More...
     
    intmax_t ucx_dist_ulongint (const void *i1, const void *i2, void *data)
     Distance function for integers of type unsigned long int. More...
     
    intmax_t ucx_dist_ulonglong (const void *i1, const void *i2, void *data)
     Distance function for integers of type unsigned long long. More...
     
    intmax_t ucx_dist_uint16 (const void *i1, const void *i2, void *data)
     Distance function for integers of type uint16_t. More...
     
    intmax_t ucx_dist_uint32 (const void *i1, const void *i2, void *data)
     Distance function for integers of type uint32_t. More...
     
    intmax_t ucx_dist_uint64 (const void *i1, const void *i2, void *data)
     Distance function for integers of type uint64_t. More...
     
    int ucx_cmp_float (const void *f1, const void *f2, void *data)
     Compares two real numbers of type float. More...
     
    int ucx_cmp_double (const void *d1, const void *d2, void *data)
     Compares two real numbers of type double. More...
     
    int ucx_cmp_ptr (const void *ptr1, const void *ptr2, void *data)
     Compares two pointers. More...
     
    int ucx_cmp_mem (const void *ptr1, const void *ptr2, void *n)
     Compares two memory areas. More...
     
    int ucx_fprintf (void *stream, write_func wfc, const char *fmt,...)
     A printf() like function which writes the output to a stream by using a write_func(). More...
     
    int ucx_vfprintf (void *stream, write_func wfc, const char *fmt, va_list ap)
     va_list version of ucx_fprintf(). More...
     
    sstr_t ucx_asprintf (UcxAllocator *allocator, const char *fmt,...)
     A printf() like function which allocates space for a sstr_t the result is written to. More...
     
    sstr_t ucx_vasprintf (UcxAllocator *allocator, const char *fmt, va_list ap)
     va_list version of ucx_asprintf(). More...
     
    +

    Detailed Description

    +

    Compare, copy and printf functions.

    +
    Author
    Mike Becker
    +
    +Olaf Wintermann
    +

    Macro Definition Documentation

    + +

    ◆ ucx_bprintf

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    #define ucx_bprintf( buffer,
     ... 
    )
    +
    +Value:
    ucx_fprintf((UcxBuffer*)buffer, \
    (write_func)ucx_buffer_write, __VA_ARGS__)
    ucx_buffer_write
    size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems, UcxBuffer *buffer)
    Writes data to a UcxBuffer.
    Definition: buffer.c:152
    +
    UcxBuffer
    UCX Buffer.
    Definition: buffer.h:73
    +
    ucx_fprintf
    int ucx_fprintf(void *stream, write_func wfc, const char *fmt,...)
    A printf() like function which writes the output to a stream by using a write_func().
    Definition: utils.c:343
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    +

    A printf() like function which writes the output to a UcxBuffer.

    +
    Parameters
    + + + +
    bufferthe buffer the data is written to
    ...format string and additional arguments
    +
    +
    +
    Returns
    the total number of bytes written
    +
    See also
    ucx_fprintf()
    + +
    +
    + +

    ◆ ucx_sprintf

    + +
    +
    + + + + + + + + +
    #define ucx_sprintf( ...)   ucx_asprintf(ucx_default_allocator(), __VA_ARGS__)
    +
    + +

    Shortcut for ucx_asprintf() with default allocator.

    + +
    +
    + +

    ◆ ucx_stream_bcopy

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    #define ucx_stream_bcopy( src,
     dest,
     rfnc,
     wfnc,
     buf,
     bufsize 
    )
    +
    +Value:
    ucx_stream_bncopy(\
    src, dest, (read_func)rfnc, (write_func)wfnc, \
    buf, bufsize, (size_t)-1)
    ucx_stream_bncopy
    size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc, char *buf, size_t bufsize, size_t n)
    Reads data from a stream and writes it to another stream.
    Definition: utils.c:52
    +
    read_func
    size_t(* read_func)(void *, size_t, size_t, void *)
    Function pointer to a read function.
    Definition: ucx.h:132
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    +

    Shorthand for an unbounded ucx_stream_bncopy call using the specified buffer.

    +
    Parameters
    + + + + + + + +
    srcthe source stream
    destthe destination stream
    rfncthe read function
    wfncthe write function
    bufa pointer to the copy buffer or NULL if a buffer shall be implicitly created on the heap
    bufsizethe size of the copy buffer - if NULL was provided for buf, this is the size of the buffer that shall be implicitly created
    +
    +
    +
    Returns
    total number of bytes copied
    + +
    +
    + +

    ◆ ucx_stream_copy

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    #define ucx_stream_copy( src,
     dest,
     rfnc,
     wfnc 
    )
    +
    +Value:
    ucx_stream_bncopy(\
    src, dest, (read_func)rfnc, (write_func)wfnc, \
    NULL, UCX_STREAM_COPY_BUFSIZE, (size_t)-1)
    ucx_stream_bncopy
    size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc, char *buf, size_t bufsize, size_t n)
    Reads data from a stream and writes it to another stream.
    Definition: utils.c:52
    +
    UCX_STREAM_COPY_BUFSIZE
    #define UCX_STREAM_COPY_BUFSIZE
    Default buffer size for ucx_stream_copy() and ucx_stream_ncopy().
    Definition: utils.h:55
    +
    read_func
    size_t(* read_func)(void *, size_t, size_t, void *)
    Function pointer to a read function.
    Definition: ucx.h:132
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    +

    Shorthand for an unbounded ucx_stream_bncopy call using a default buffer.

    +
    Parameters
    + + + + + +
    srcthe source stream
    destthe destination stream
    rfncthe read function
    wfncthe write function
    +
    +
    +
    Returns
    total number of bytes copied
    +
    See also
    UCX_STREAM_COPY_BUFSIZE
    + +
    +
    + +

    ◆ ucx_stream_ncopy

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    #define ucx_stream_ncopy( src,
     dest,
     rfnc,
     wfnc,
     n 
    )
    +
    +Value:
    ucx_stream_bncopy(\
    src, dest, (read_func)rfnc, (write_func)wfnc, \
    NULL, UCX_STREAM_COPY_BUFSIZE, n)
    ucx_stream_bncopy
    size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc, char *buf, size_t bufsize, size_t n)
    Reads data from a stream and writes it to another stream.
    Definition: utils.c:52
    +
    UCX_STREAM_COPY_BUFSIZE
    #define UCX_STREAM_COPY_BUFSIZE
    Default buffer size for ucx_stream_copy() and ucx_stream_ncopy().
    Definition: utils.h:55
    +
    read_func
    size_t(* read_func)(void *, size_t, size_t, void *)
    Function pointer to a read function.
    Definition: ucx.h:132
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    +

    Shorthand for ucx_stream_bncopy using a default copy buffer.

    +
    Parameters
    + + + + + + +
    srcthe source stream
    destthe destination stream
    rfncthe read function
    wfncthe write function
    nmaximum number of bytes that shall be copied
    +
    +
    +
    Returns
    total number of bytes copied
    + +
    +
    +

    Function Documentation

    + +

    ◆ ucx_asprintf()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t ucx_asprintf (UcxAllocator * allocator,
    const char * fmt,
     ... 
    )
    +
    + +

    A printf() like function which allocates space for a sstr_t the result is written to.

    +

    Attention: The sstr_t data is allocated with the allocators ucx_allocator_malloc() function. So it is implementation dependent, if the returned sstr_t.ptr pointer must be passed to the allocators ucx_allocator_free() function manually.

    +

    Note: The sstr_t.ptr of the return value will always be NULL-terminated.

    +
    Parameters
    + + + + +
    allocatorthe UcxAllocator used for allocating the result sstr_t
    fmtformat string
    ...additional arguments
    +
    +
    +
    Returns
    a sstr_t containing the formatted string
    + +
    +
    + +

    ◆ ucx_cmp_double()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_double (const void * d1,
    const void * d2,
    void * data 
    )
    +
    + +

    Compares two real numbers of type double.

    +
    Parameters
    + + + + +
    d1pointer to double one
    d2pointer to double two
    dataif provided: a pointer to precision (default: 1e-14)
    +
    +
    +
    Returns
    -1, if *d1 is less than *d2, 0 if both are equal, 1 if *d1 is greater than *d2
    + +
    +
    + +

    ◆ ucx_cmp_float()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_float (const void * f1,
    const void * f2,
    void * data 
    )
    +
    + +

    Compares two real numbers of type float.

    +
    Parameters
    + + + + +
    f1pointer to float one
    f2pointer to float two
    dataif provided: a pointer to precision (default: 1e-6f)
    +
    +
    +
    Returns
    -1, if *f1 is less than *f2, 0 if both are equal, 1 if *f1 is greater than *f2
    + +
    +
    + +

    ◆ ucx_cmp_int()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_int (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type int.

    +
    Parameters
    + + + + +
    i1pointer to integer one
    i2pointer to integer two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_int16()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_int16 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type int16_t.

    +
    Parameters
    + + + + +
    i1pointer to int16_t one
    i2pointer to int16_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_int32()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_int32 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type int32_t.

    +
    Parameters
    + + + + +
    i1pointer to int32_t one
    i2pointer to int32_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_int64()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_int64 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type int64_t.

    +
    Parameters
    + + + + +
    i1pointer to int64_t one
    i2pointer to int64_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_longint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_longint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type long int.

    +
    Parameters
    + + + + +
    i1pointer to long integer one
    i2pointer to long integer two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_longlong()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_longlong (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type long long.

    +
    Parameters
    + + + + +
    i1pointer to long long one
    i2pointer to long long two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_mem()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_mem (const void * ptr1,
    const void * ptr2,
    void * n 
    )
    +
    + +

    Compares two memory areas.

    +
    Parameters
    + + + + +
    ptr1pointer one
    ptr2pointer two
    na pointer to the size_t containing the third parameter for memcmp
    +
    +
    +
    Returns
    the result of memcmp(ptr1, ptr2, *n)
    + +
    +
    + +

    ◆ ucx_cmp_ptr()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_ptr (const void * ptr1,
    const void * ptr2,
    void * data 
    )
    +
    + +

    Compares two pointers.

    +
    Parameters
    + + + + +
    ptr1pointer one
    ptr2pointer two
    dataomitted
    +
    +
    +
    Returns
    -1 if ptr1 is less than ptr2, 0 if both are equal, 1 if ptr1 is greater than ptr2
    + +
    +
    + +

    ◆ ucx_cmp_sstr()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_sstr (const void * s1,
    const void * s2,
    void * data 
    )
    +
    + +

    Wraps the sstrcmp function.

    +
    Parameters
    + + + + +
    s1sstr one
    s2sstr two
    dataignored
    +
    +
    +
    Returns
    the result of sstrcmp(s1, s2)
    + +
    +
    + +

    ◆ ucx_cmp_str()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_str (const void * s1,
    const void * s2,
    void * data 
    )
    +
    + +

    Wraps the strcmp function.

    +
    Parameters
    + + + + +
    s1string one
    s2string two
    dataomitted
    +
    +
    +
    Returns
    the result of strcmp(s1, s2)
    + +
    +
    + +

    ◆ ucx_cmp_strn()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_strn (const void * s1,
    const void * s2,
    void * n 
    )
    +
    + +

    Wraps the strncmp function.

    +
    Parameters
    + + + + +
    s1string one
    s2string two
    na pointer to the size_t containing the third strncmp parameter
    +
    +
    +
    Returns
    the result of strncmp(s1, s2, *n)
    + +
    +
    + +

    ◆ ucx_cmp_uint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_uint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type unsigned int.

    +
    Parameters
    + + + + +
    i1pointer to unsigned integer one
    i2pointer to unsigned integer two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_uint16()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_uint16 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type uint16_t.

    +
    Parameters
    + + + + +
    i1pointer to uint16_t one
    i2pointer to uint16_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_uint32()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_uint32 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type uint32_t.

    +
    Parameters
    + + + + +
    i1pointer to uint32_t one
    i2pointer to uint32_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_uint64()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_uint64 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type uint64_t.

    +
    Parameters
    + + + + +
    i1pointer to uint64_t one
    i2pointer to uint64_t two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_ulongint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_ulongint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type unsigned long int.

    +
    Parameters
    + + + + +
    i1pointer to unsigned long integer one
    i2pointer to unsigned long integer two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_cmp_ulonglong()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_cmp_ulonglong (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Compares two integers of type unsigned long long.

    +
    Parameters
    + + + + +
    i1pointer to unsigned long long one
    i2pointer to unsigned long long two
    dataomitted
    +
    +
    +
    Returns
    -1, if *i1 is less than *i2, 0 if both are equal, 1 if *i1 is greater than *i2
    + +
    +
    + +

    ◆ ucx_dist_int()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_int (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type int.

    +
    Parameters
    + + + + +
    i1pointer to integer one
    i2pointer to integer two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_int16()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_int16 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type int16_t.

    +
    Parameters
    + + + + +
    i1pointer to int16_t one
    i2pointer to int16_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_int32()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_int32 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type int32_t.

    +
    Parameters
    + + + + +
    i1pointer to int32_t one
    i2pointer to int32_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_int64()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_int64 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type int64_t.

    +
    Parameters
    + + + + +
    i1pointer to int64_t one
    i2pointer to int64_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_longint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_longint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type long int.

    +
    Parameters
    + + + + +
    i1pointer to long integer one
    i2pointer to long integer two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_longlong()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_longlong (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type long long.

    +
    Parameters
    + + + + +
    i1pointer to long long one
    i2pointer to long long two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_uint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_uint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type unsigned int.

    +
    Parameters
    + + + + +
    i1pointer to unsigned integer one
    i2pointer to unsigned integer two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_uint16()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_uint16 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type uint16_t.

    +
    Parameters
    + + + + +
    i1pointer to uint16_t one
    i2pointer to uint16_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_uint32()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_uint32 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type uint32_t.

    +
    Parameters
    + + + + +
    i1pointer to uint32_t one
    i2pointer to uint32_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_uint64()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_uint64 (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type uint64_t.

    +
    Parameters
    + + + + +
    i1pointer to uint64_t one
    i2pointer to uint64_t two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_ulongint()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_ulongint (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type unsigned long int.

    +
    Parameters
    + + + + +
    i1pointer to unsigned long integer one
    i2pointer to unsigned long integer two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_dist_ulonglong()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    intmax_t ucx_dist_ulonglong (const void * i1,
    const void * i2,
    void * data 
    )
    +
    + +

    Distance function for integers of type unsigned long long.

    +
    Parameters
    + + + + +
    i1pointer to unsigned long long one
    i2pointer to unsigned long long two
    dataomitted
    +
    +
    +
    Returns
    i1 minus i2
    + +
    +
    + +

    ◆ ucx_fprintf()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_fprintf (void * stream,
    write_func wfc,
    const char * fmt,
     ... 
    )
    +
    + +

    A printf() like function which writes the output to a stream by using a write_func().

    +
    Parameters
    + + + + + +
    streamthe stream the data is written to
    wfcthe write function
    fmtformat string
    ...additional arguments
    +
    +
    +
    Returns
    the total number of bytes written
    + +
    +
    + +

    ◆ ucx_memcpy()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void* ucx_memcpy (const void * m,
    void * n 
    )
    +
    + +

    Copies a memory area.

    +
    Parameters
    + + + +
    ma pointer to the memory area
    na pointer to the size_t containing the size of the memory area
    +
    +
    +
    Returns
    a pointer to a copy of the specified memory area that can be passed to free(void*)
    + +
    +
    + +

    ◆ ucx_strcpy()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void* ucx_strcpy (const void * s,
    void * data 
    )
    +
    + +

    Copies a string.

    +
    Parameters
    + + + +
    sthe string to copy
    dataomitted
    +
    +
    +
    Returns
    a pointer to a copy of s1 that can be passed to free(void*)
    + +
    +
    + +

    ◆ ucx_stream_bncopy()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    size_t ucx_stream_bncopy (void * src,
    void * dest,
    read_func rfnc,
    write_func wfnc,
    char * buf,
    size_t bufsize,
    size_t n 
    )
    +
    + +

    Reads data from a stream and writes it to another stream.

    +
    Parameters
    + + + + + + + + +
    srcthe source stream
    destthe destination stream
    rfncthe read function
    wfncthe write function
    bufa pointer to the copy buffer or NULL if a buffer shall be implicitly created on the heap
    bufsizethe size of the copy buffer - if NULL was provided for buf, this is the size of the buffer that shall be implicitly created
    nthe maximum number of bytes that shall be copied
    +
    +
    +
    Returns
    the total number of bytes copied
    + +
    +
    + +

    ◆ ucx_vasprintf()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sstr_t ucx_vasprintf (UcxAllocator * allocator,
    const char * fmt,
    va_list ap 
    )
    +
    + +

    va_list version of ucx_asprintf().

    +
    Parameters
    + + + + +
    allocatorthe UcxAllocator used for allocating the result sstr_t
    fmtformat string
    apargument list
    +
    +
    +
    Returns
    a sstr_t containing the formatted string
    +
    See also
    ucx_asprintf()
    + +
    +
    + +

    ◆ ucx_vfprintf()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    int ucx_vfprintf (void * stream,
    write_func wfc,
    const char * fmt,
    va_list ap 
    )
    +
    + +

    va_list version of ucx_fprintf().

    +
    Parameters
    + + + + + +
    streamthe stream the data is written to
    wfcthe write function
    fmtformat string
    apargument list
    +
    +
    +
    Returns
    the total number of bytes written
    +
    See also
    ucx_fprintf()
    + +
    +
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/api-2.1/utils_8h_source.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/api-2.1/utils_8h_source.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,124 @@ + + + + + + + +ucx: /home/mike/workspace/c/ucx/src/ucx/utils.h Source File + + + + + + + + + +
    +
    + + + + + + + +
    +
    ucx +
    +
    UAP Common Extensions
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    utils.h
    +
    +
    +Go to the documentation of this file.
    1 /*
    2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3  *
    4  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
    10  * notice, this list of conditions and the following disclaimer.
    11  *
    12  * 2. Redistributions in binary form must reproduce the above copyright
    13  * notice, this list of conditions and the following disclaimer in the
    14  * documentation and/or other materials provided with the distribution.
    15  *
    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    26  * POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    38 #ifndef UCX_UTILS_H
    39 #define UCX_UTILS_H
    40 
    41 #include "ucx.h"
    42 #include "string.h"
    43 #include "allocator.h"
    44 #include <inttypes.h>
    45 #include <string.h>
    46 #include <stdarg.h>
    47 
    48 #ifdef __cplusplus
    49 extern "C" {
    50 #endif
    51 
    55 #define UCX_STREAM_COPY_BUFSIZE 4096
    56 
    63 void *ucx_strcpy(const void *s, void *data);
    64 
    72 void *ucx_memcpy(const void *m, void *n);
    73 
    74 
    90 size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc,
    91  char* buf, size_t bufsize, size_t n);
    92 
    104 #define ucx_stream_copy(src,dest,rfnc,wfnc) ucx_stream_bncopy(\
    105  src, dest, (read_func)rfnc, (write_func)wfnc, \
    106  NULL, UCX_STREAM_COPY_BUFSIZE, (size_t)-1)
    107 
    118 #define ucx_stream_ncopy(src,dest,rfnc,wfnc, n) ucx_stream_bncopy(\
    119  src, dest, (read_func)rfnc, (write_func)wfnc, \
    120  NULL, UCX_STREAM_COPY_BUFSIZE, n)
    121 
    136 #define ucx_stream_bcopy(src,dest,rfnc,wfnc, buf, bufsize) ucx_stream_bncopy(\
    137  src, dest, (read_func)rfnc, (write_func)wfnc, \
    138  buf, bufsize, (size_t)-1)
    139 
    147 int ucx_cmp_str(const void *s1, const void *s2, void *data);
    148 
    156 int ucx_cmp_strn(const void *s1, const void *s2, void *n);
    157 
    165 int ucx_cmp_sstr(const void *s1, const void *s2, void *data);
    166 
    175 int ucx_cmp_int(const void *i1, const void *i2, void *data);
    176 
    185 int ucx_cmp_longint(const void *i1, const void *i2, void *data);
    186 
    195 int ucx_cmp_longlong(const void *i1, const void *i2, void *data);
    196 
    205 int ucx_cmp_int16(const void *i1, const void *i2, void *data);
    206 
    215 int ucx_cmp_int32(const void *i1, const void *i2, void *data);
    216 
    225 int ucx_cmp_int64(const void *i1, const void *i2, void *data);
    226 
    235 int ucx_cmp_uint(const void *i1, const void *i2, void *data);
    236 
    245 int ucx_cmp_ulongint(const void *i1, const void *i2, void *data);
    246 
    255 int ucx_cmp_ulonglong(const void *i1, const void *i2, void *data);
    256 
    265 int ucx_cmp_uint16(const void *i1, const void *i2, void *data);
    266 
    275 int ucx_cmp_uint32(const void *i1, const void *i2, void *data);
    276 
    285 int ucx_cmp_uint64(const void *i1, const void *i2, void *data);
    286 
    294 intmax_t ucx_dist_int(const void *i1, const void *i2, void *data);
    295 
    303 intmax_t ucx_dist_longint(const void *i1, const void *i2, void *data);
    304 
    312 intmax_t ucx_dist_longlong(const void *i1, const void *i2, void *data);
    313 
    321 intmax_t ucx_dist_int16(const void *i1, const void *i2, void *data);
    322 
    330 intmax_t ucx_dist_int32(const void *i1, const void *i2, void *data);
    331 
    339 intmax_t ucx_dist_int64(const void *i1, const void *i2, void *data);
    340 
    348 intmax_t ucx_dist_uint(const void *i1, const void *i2, void *data);
    349 
    357 intmax_t ucx_dist_ulongint(const void *i1, const void *i2, void *data);
    358 
    366 intmax_t ucx_dist_ulonglong(const void *i1, const void *i2, void *data);
    367 
    375 intmax_t ucx_dist_uint16(const void *i1, const void *i2, void *data);
    376 
    384 intmax_t ucx_dist_uint32(const void *i1, const void *i2, void *data);
    385 
    393 intmax_t ucx_dist_uint64(const void *i1, const void *i2, void *data);
    394 
    404 int ucx_cmp_float(const void *f1, const void *f2, void *data);
    405 
    414 int ucx_cmp_double(const void *d1, const void *d2, void *data);
    415 
    424 int ucx_cmp_ptr(const void *ptr1, const void *ptr2, void *data);
    425 
    433 int ucx_cmp_mem(const void *ptr1, const void *ptr2, void *n);
    434 
    444 int ucx_fprintf(void *stream, write_func wfc, const char *fmt, ...);
    445 
    455 int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap);
    456 
    474 sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt, ...);
    475 
    485 sstr_t ucx_vasprintf(UcxAllocator *allocator, const char *fmt, va_list ap);
    486 
    488 #define ucx_sprintf(...) \
    489  ucx_asprintf(ucx_default_allocator(), __VA_ARGS__)
    490 
    500 #define ucx_bprintf(buffer, ...) ucx_fprintf((UcxBuffer*)buffer, \
    501  (write_func)ucx_buffer_write, __VA_ARGS__)
    502 
    503 #ifdef __cplusplus
    504 }
    505 #endif
    506 
    507 #endif /* UCX_UTILS_H */
    508 
    ucx_cmp_uint32
    int ucx_cmp_uint32(const void *i1, const void *i2, void *data)
    Compares two integers of type uint32_t.
    Definition: utils.c:205
    +
    sstr_t
    The UCX string structure.
    Definition: string.h:90
    +
    ucx_cmp_longint
    int ucx_cmp_longint(const void *i1, const void *i2, void *data)
    Compares two integers of type long int.
    Definition: utils.c:115
    +
    ucx_dist_int
    intmax_t ucx_dist_int(const void *i1, const void *i2, void *data)
    Distance function for integers of type int.
    Definition: utils.c:225
    +
    string.h
    Bounded string implementation.
    +
    ucx_cmp_ulonglong
    int ucx_cmp_ulonglong(const void *i1, const void *i2, void *data)
    Compares two integers of type unsigned long long.
    Definition: utils.c:185
    +
    ucx_stream_bncopy
    size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc, char *buf, size_t bufsize, size_t n)
    Reads data from a stream and writes it to another stream.
    Definition: utils.c:52
    +
    ucx_cmp_sstr
    int ucx_cmp_sstr(const void *s1, const void *s2, void *data)
    Wraps the sstrcmp function.
    Definition: utils.c:99
    +
    ucx.h
    Main UCX Header providing most common definitions.
    +
    ucx_cmp_float
    int ucx_cmp_float(const void *f1, const void *f2, void *data)
    Compares two real numbers of type float.
    Definition: utils.c:297
    +
    ucx_cmp_longlong
    int ucx_cmp_longlong(const void *i1, const void *i2, void *data)
    Compares two integers of type long long.
    Definition: utils.c:125
    +
    ucx_cmp_int32
    int ucx_cmp_int32(const void *i1, const void *i2, void *data)
    Compares two integers of type int32_t.
    Definition: utils.c:145
    +
    ucx_cmp_ulongint
    int ucx_cmp_ulongint(const void *i1, const void *i2, void *data)
    Compares two integers of type unsigned long int.
    Definition: utils.c:175
    +
    ucx_cmp_uint64
    int ucx_cmp_uint64(const void *i1, const void *i2, void *data)
    Compares two integers of type uint64_t.
    Definition: utils.c:215
    +
    ucx_dist_longlong
    intmax_t ucx_dist_longlong(const void *i1, const void *i2, void *data)
    Distance function for integers of type long long.
    Definition: utils.c:237
    +
    ucx_cmp_strn
    int ucx_cmp_strn(const void *s1, const void *s2, void *n)
    Wraps the strncmp function.
    Definition: utils.c:95
    +
    ucx_cmp_str
    int ucx_cmp_str(const void *s1, const void *s2, void *data)
    Wraps the strcmp function.
    Definition: utils.c:91
    +
    ucx_cmp_double
    int ucx_cmp_double(const void *d1, const void *d2, void *data)
    Compares two real numbers of type double.
    Definition: utils.c:308
    +
    ucx_dist_uint64
    intmax_t ucx_dist_uint64(const void *i1, const void *i2, void *data)
    Distance function for integers of type uint64_t.
    Definition: utils.c:291
    +
    ucx_dist_uint32
    intmax_t ucx_dist_uint32(const void *i1, const void *i2, void *data)
    Distance function for integers of type uint32_t.
    Definition: utils.c:285
    +
    UcxAllocator
    UCX allocator data structure containing memory management functions.
    Definition: allocator.h:88
    +
    ucx_cmp_ptr
    int ucx_cmp_ptr(const void *ptr1, const void *ptr2, void *data)
    Compares two pointers.
    Definition: utils.c:319
    +
    ucx_cmp_mem
    int ucx_cmp_mem(const void *ptr1, const void *ptr2, void *n)
    Compares two memory areas.
    Definition: utils.c:329
    +
    ucx_dist_ulonglong
    intmax_t ucx_dist_ulonglong(const void *i1, const void *i2, void *data)
    Distance function for integers of type unsigned long long.
    Definition: utils.c:273
    +
    ucx_fprintf
    int ucx_fprintf(void *stream, write_func wfc, const char *fmt,...)
    A printf() like function which writes the output to a stream by using a write_func().
    Definition: utils.c:343
    +
    ucx_cmp_uint16
    int ucx_cmp_uint16(const void *i1, const void *i2, void *data)
    Compares two integers of type uint16_t.
    Definition: utils.c:195
    +
    ucx_cmp_int
    int ucx_cmp_int(const void *i1, const void *i2, void *data)
    Compares two integers of type int.
    Definition: utils.c:105
    +
    ucx_dist_int64
    intmax_t ucx_dist_int64(const void *i1, const void *i2, void *data)
    Distance function for integers of type int64_t.
    Definition: utils.c:255
    +
    read_func
    size_t(* read_func)(void *, size_t, size_t, void *)
    Function pointer to a read function.
    Definition: ucx.h:132
    +
    ucx_cmp_uint
    int ucx_cmp_uint(const void *i1, const void *i2, void *data)
    Compares two integers of type unsigned int.
    Definition: utils.c:165
    +
    ucx_asprintf
    sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt,...)
    A printf() like function which allocates space for a sstr_t the result is written to...
    Definition: utils.c:394
    +
    ucx_dist_uint
    intmax_t ucx_dist_uint(const void *i1, const void *i2, void *data)
    Distance function for integers of type unsigned int.
    Definition: utils.c:261
    +
    ucx_dist_int16
    intmax_t ucx_dist_int16(const void *i1, const void *i2, void *data)
    Distance function for integers of type int16_t.
    Definition: utils.c:243
    +
    ucx_strcpy
    void * ucx_strcpy(const void *s, void *data)
    Copies a string.
    Definition: utils.c:37
    +
    ucx_dist_longint
    intmax_t ucx_dist_longint(const void *i1, const void *i2, void *data)
    Distance function for integers of type long int.
    Definition: utils.c:231
    +
    ucx_dist_uint16
    intmax_t ucx_dist_uint16(const void *i1, const void *i2, void *data)
    Distance function for integers of type uint16_t.
    Definition: utils.c:279
    +
    ucx_dist_int32
    intmax_t ucx_dist_int32(const void *i1, const void *i2, void *data)
    Distance function for integers of type int32_t.
    Definition: utils.c:249
    +
    allocator.h
    Allocator for custom memory management.
    +
    ucx_dist_ulongint
    intmax_t ucx_dist_ulongint(const void *i1, const void *i2, void *data)
    Distance function for integers of type unsigned long int.
    Definition: utils.c:267
    +
    write_func
    size_t(* write_func)(const void *, size_t, size_t, void *)
    Function pointer to a write function.
    Definition: ucx.h:119
    +
    ucx_cmp_int16
    int ucx_cmp_int16(const void *i1, const void *i2, void *data)
    Compares two integers of type int16_t.
    Definition: utils.c:135
    +
    ucx_memcpy
    void * ucx_memcpy(const void *m, void *n)
    Copies a memory area.
    Definition: utils.c:45
    +
    ucx_cmp_int64
    int ucx_cmp_int64(const void *i1, const void *i2, void *data)
    Compares two integers of type int64_t.
    Definition: utils.c:155
    +
    ucx_vfprintf
    int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap)
    va_list version of ucx_fprintf().
    Definition: utils.c:352
    +
    ucx_vasprintf
    sstr_t ucx_vasprintf(UcxAllocator *allocator, const char *fmt, va_list ap)
    va_list version of ucx_asprintf().
    Definition: utils.c:403
    +
    + +
    +Generated on Thu Dec 19 2019 19:58:24 for ucx by   +doxygen + 1.8.13 +
    + + diff -r 92e482410453 -r d345541018fa docs/src/CMakeLists.txt --- a/docs/src/CMakeLists.txt Mon Dec 30 09:54:10 2019 +0100 +++ b/docs/src/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 @@ -1,7 +1,7 @@ # # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. # -# Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. +# Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: @@ -28,7 +28,7 @@ set(PANDOC_DESTDIR ${CMAKE_BINARY_DIR}/docs/web) set(PANDOC_ARGS -c ucx.css -B header.html -A footer.html -T 'UAP Common Extensions') -set(PANDOC_SRC index.md license.md modules.md install.md) +set(PANDOC_SRC index.md license.md install.md) set(LOGO_PATH ../../uaplogo.png) if (NOT EXISTS ${PANDOC_EXECUTABLE}) @@ -42,6 +42,7 @@ message(STATUS "HTML Documentation will be generated at: ${PANDOC_DESTDIR}.") file(MAKE_DIRECTORY ${PANDOC_DESTDIR}) +# UCX 3.0 documentation foreach(source_file ${PANDOC_SRC}) string(REPLACE .md .html dest_file ${source_file}) string(PREPEND dest_file "${PANDOC_DESTDIR}/") @@ -54,10 +55,20 @@ ) endforeach() +# UCX 2.1 documentation +add_custom_target(docs-html-21 + COMMAND ${PANDOC_EXECUTABLE} -c ucx.css -B header-ucx2.html -A footer.html + -T 'UAP Common Extensions' -o ${PANDOC_DESTDIR}/modules-ucx2.html modules-ucx2.md + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + DEPENDS modules-ucx2.md + COMMENT "Adding UCX 2.1 HTML documentation." +) + +# Collect all HTML documentation add_custom_target(docs-html COMMAND ${CMAKE_COMMAND} -E copy ucx.css ${PANDOC_DESTDIR}/ucx.css COMMAND ${CMAKE_COMMAND} -E copy ${LOGO_PATH} ${PANDOC_DESTDIR}/uaplogo.png - DEPENDS ${PANDOC_DEST} + DEPENDS ${PANDOC_DEST} docs-html-21 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMENT "Generating HTML documentation with pandoc." ) diff -r 92e482410453 -r d345541018fa docs/src/Makefile --- a/docs/src/Makefile Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,66 +0,0 @@ -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. -# -# Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# - -PD=pandoc -PFLAGS=-c ucx.css -B header.html -A footer.html -T 'UAP Common Extensions' - -SRC = index.md -SRC += install.md -SRC += license.md -SRC += modules.md - -DEST = ../web - -PROJROOT = ../.. -LOGO = uaplogo.png - -HTML = $(SRC:%.md=$(DEST)/%.html) - -all: html api - - -html: $(DEST) $(DEST)/ucx.css $(DEST)/$(LOGO) $(HTML) - - -api: $(DEST) - cd $(PROJROOT); doxygen - -$(DEST): - mkdir -p $@ - -$(DEST)/%.html: %.md - $(PD) $(PFLAGS) $< -o $@ - -$(DEST)/ucx.css: ucx.css - cp $< $@ - -$(DEST)/$(LOGO): $(PROJROOT)/$(LOGO) - cp $< $@ - -clean: - rm -Rf $(DEST) diff -r 92e482410453 -r d345541018fa docs/src/header-ucx2.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/src/header-ucx2.html Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,58 @@ + +
    + UAP Common Extensions + UAP Core +
    + + + + + + + +
    \ No newline at end of file diff -r 92e482410453 -r d345541018fa docs/src/header.html --- a/docs/src/header.html Mon Dec 30 09:54:10 2019 +0100 +++ b/docs/src/header.html Sat Feb 06 19:11:44 2021 +0100 @@ -18,24 +18,9 @@

    Documentation

    diff -r 92e482410453 -r d345541018fa docs/src/index.md --- a/docs/src/index.md Mon Dec 30 09:54:10 2019 +0100 +++ b/docs/src/index.md Sat Feb 06 19:11:44 2021 +0100 @@ -29,6 +29,10 @@ Changelog --------- +### Version 3.0 + + * under construction... + ### Version 2.1 - 2019-12-30 * adds string replace functions diff -r 92e482410453 -r d345541018fa docs/src/install.md --- a/docs/src/install.md Mon Dec 30 09:54:10 2019 +0100 +++ b/docs/src/install.md Sat Feb 06 19:11:44 2021 +0100 @@ -2,14 +2,32 @@ title: Build Instructions --- -The install procedure is the same on all supported platforms. -For Microsoft Windows, however, you will need an appropriate port of the linux -tools (like MinGW or Cygwin). +The build processes uses CMake starting with UCX 3.0. First, download the source code from [Source Forge][1]. wget https://sourceforge.net/projects/ucx/files/ucx-latest.tar.gz tar -xzf ucx-latest.tar.gz cd ucx-latest + +Then create a build directory and issue the cmake command and then make. + + mkdir build + cd build + cmake .. + make + +--- + +### UCX 2.1 + +The build procedure for UCX 2.1 uses a configure script. +For Microsoft Windows, you will need an appropriate port of the linux +tools (like MinGW or Cygwin). +First, download the source code from [Source Forge][1]. + + wget https://sourceforge.net/projects/ucx/files/ucx-2.1.0.tar.gz + tar -xzf ucx-2.1.0.tar.gz + cd ucx-2.1.0 Then issue the `configure` and `make` commands. diff -r 92e482410453 -r d345541018fa docs/src/license.md --- a/docs/src/license.md Mon Dec 30 09:54:10 2019 +0100 +++ b/docs/src/license.md Sat Feb 06 19:11:44 2021 +0100 @@ -2,7 +2,7 @@ title: License --- -Copyright 2017 Mike Becker, Olaf Wintermann. All rights reserved. +Copyright 2021 Mike Becker, Olaf Wintermann. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff -r 92e482410453 -r d345541018fa docs/src/modules-ucx2.md --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/src/modules-ucx2.md Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,873 @@ +--- +title: UCX 2.1 Modules +--- + +UCX 2.1 provided several modules for data structures and algorithms. +You may choose to use specific modules by inclueding the corresponding header +file. +Please note, that some modules make use of other UCX 2.1 modules. +For instance, the [Allocator](#allocator) module is used by many other modules +to allow flexible memory allocation. +By default the header files are placed into an `ucx` directory within your +systems include directory. In this case you can use a module by including it +via `#include `. +Required modules are included automatically. + +
    + +----------------------- ---------------------- -------------------------------- --------------------------- +[String](#string) [Buffer](#buffer) +[Allocator](#allocator) [Stack](#stack) [Memory Pool](#memory-pool) +[Array](#array) [List](#list) [Map](#map) [AVL Tree](#avl-tree) +[Logging](#logging) [Testing](#testing) [Utilities](#utilities) [Properties](#properties) +----------------------- ---------------------- -------------------------------- --------------------------- + +
    + +## Allocator + +*Header file:* [allocator.h](api-2.1/allocator_8h.html) +*Required modules:* None. + +A UCX allocator consists of a pointer to the memory area / pool and four +function pointers to memory management functions operating on this memory +area / pool. These functions shall behave equivalent to the standard libc +functions `malloc`, `calloc`, `realloc` and `free`. + +The signature of the memory management functions is based on the signature +of the respective libc function but each of them takes the pointer to the +memory area / pool as first argument. + +As the pointer to the memory area / pool can be arbitrarily chosen, any data +can be provided to the memory management functions. One example is the +[UCX Memory Pool](#memory-pool). + +## Array + +*Header file:* [array.h](api-2.1/array_8h.html) +*Required modules:* [Allocator](#allocator) + +The UCX Array is an implementation of a dynamic array with automatic +reallocation. The array structure contains a capacity, the current size, +the size of each element, the raw pointer to the memory area and an allocator. +Arrays are in most cases much faster than linked list. +One can decide, whether to create a new array on the heap with `ucx_array_new()` +or to save one indirection by initializing a `UcxArray` structure on the stack +with `ucx_array_init()`. + +### Remove duplicates from an array of strings + +The following example shows, how a `UcxArray` can be built with +a standard dynamic C array (pointer+length) as basis. + +```C +UcxArray* create_unique(sstr_t* array, size_t arrlen) { + // worst case is no duplicates, hence the capacity is set to arrlen + UcxArray* result = ucx_array_new(arrlen, sizeof(sstr_t)); + // only append elements, if they are not already present in the array + for (size_t i = 0 ; i < arrlen ; ++i) { + if (!ucx_array_contains(result, array+i, ucx_cmp_sstr, NULL)) { + ucx_array_append_from(result, array+i, 1); + } + } + // make the array as small as possible + ucx_array_shrink(result); + return result; +} + +/* ... */ + +sstr_t* array = /* some standard array of strings */ +size_t arrlen = /* the length of the array */ + +UcxArray* result = create_unique(array,arrlen); + +/* Iterate over the array and print the elements */ +sstr_t* unique = result->data; +for (size_t i = 0 ; i < result->size ; i++) { + printf("%" PRIsstr "\n", SFMT(unique[i])); +} + +/* Free the array. */ +ucx_array_free(result); +``` +### Preventing out of bounds writes + +The functions `ucx_array_reserve()`, `ucx_array_resize()`, `ucx_array_grow()`, +and `ucx_array_shrink()` allow easy management of the array capacity. +Imagine you want to add `n` elements to an array. If your `n` elements are +already somewhere else consecutively in memory, you can use +`ucx_array_append_from()` and benefit from the autogrow facility in this family +of functions. Otherwise, you can ask the array to have enough capacity for +holding additional `n` elements. + +```C +size_t n = // ... elements to add +if (ucx_array_grow(array, n)) { + fprintf(stderr, "Cannot add %zu elements to the array.\n", n); + return 1; +} +for (size_t i = 0 ; i < n ; i++) { + ((int*)array->data)[array->size++] = 80; +} +``` + +## AVL Tree + +*Header file:* [avl.h](api-2.1/avl_8h.html) +*Required modules:* [Allocator](#allocator) + +This binary search tree implementation allows average O(1) insertion and +removal of elements (excluding binary search time). +All common binary tree operations are implemented. Furthermore, this module +provides search functions via lower and upper bounds. + +### Filtering items with a time window + +Suppose you have a list of items which contain a `time_t` value and your task +is to find all items within a time window `[t_start, t_end]`. +With AVL Trees this is easy: +```C +/* --------------------- + * Somewhere in a header + */ +typedef struct { + time_t ts; + /* other important data */ +} MyObject; + +/* ----------- + * Source code + */ + +UcxAVLTree* tree = ucx_avl_new(ucx_cmp_longint); +/* ... populate tree with objects, use '& MyObject.ts' as key ... */ + + +/* Now find every item, with 30 <= ts <= 70 */ +time_t ts_start = 30; +time_t ts_end = 70; + +printf("Values in range:\n"); +for ( + UcxAVLNode* node = ucx_avl_find_node( + tree, (intptr_t) &ts_start, + ucx_dist_longint, UCX_AVL_FIND_LOWER_BOUNDED); + node && (*(time_t*)node->key) <= ts_end; + node = ucx_avl_succ(node) + ) { + printf(" ts: %ld\n", ((MyObject*)node->value)->ts); +} + +ucx_avl_free_content(tree, free); +ucx_avl_free(tree); +``` + +## Buffer + +*Header file:* [buffer.h](api-2.1/buffer_8h.html) +*Required modules:* None. + +Instances of this buffer implementation can be used to read from or to write to +memory like you would do with a stream. This allows the use of +`ucx_stream_copy()` from the [Utilities](#utilities) module to copy contents +from one buffer to another or from file or network streams to the buffer and +vice-versa. + +More features for convenient use of the buffer can be enabled, like automatic +memory management and automatic resizing of the buffer space. +See the documentation of the macro constants in the header file for more +information. + +### Add line numbers to a file + +When reading a file line by line, you have three options: first, you could limit +the maximum supported line length. +Second, you allocate a god buffer large +enough for the most lines a text file could have. +And third, undoubtedly the best option, you start with a small buffer, which +adjusts on demand. +An `UcxBuffer` can be created to do just that for you. +Just pass the `UCX_BUFFER_AUTOEXTEND` option to the initialization function. +Here is a full working program, which adds line numbers to a file. +```C +#include +#include +#include + +int main(int argc, char** argv) { + + if (argc != 2) { + fprintf(stderr, "Usage: %s \n", argv[0]); + return 1; + } + + FILE* input = fopen(argv[1], "r"); + if (!input) { + perror("Canno read input"); + return 1; + } + + const size_t chunksize = 256; + + UcxBuffer* linebuf = + ucx_buffer_new( + NULL, /* the buffer should manage the memory area for us */ + 2*chunksize, /* initial size should be twice the chunk size */ + UCX_BUFFER_AUTOEXTEND); /* the buffer will grow when necessary */ + + size_t lineno = 1; + do { + /* read line chunk */ + size_t read = ucx_stream_ncopy( + input, linebuf, fread, ucx_buffer_write, chunksize); + if (read == 0) break; + + /* handle line endings */ + do { + sstr_t bufstr = ucx_buffer_to_sstr(linebuf); + sstr_t nl = sstrchr(bufstr, '\n'); + if (nl.length == 0) break; + + size_t linelen = bufstr.length - nl.length; + sstr_t linestr = sstrsubsl(bufstr, 0, linelen); + + printf("%zu: %" PRIsstr "\n", lineno++, SFMT(linestr)); + + /* shift the buffer to the next line */ + ucx_buffer_shift_left(linebuf, linelen+1); + } while(1); + + } while(1); + + /* print the 'noeol' line, if any */ + sstr_t lastline = ucx_buffer_to_sstr(linebuf); + if (lastline.length > 0) { + printf("%zu: %" PRIsstr, lineno, SFMT(lastline)); + } + + fclose(input); + ucx_buffer_free(linebuf); + + return 0; +} +``` + +## List + +*Header file:* [list.h](api-2.1/list_8h.html) +*Required modules:* [Allocator](#allocator) + +This module provides the data structure and several functions for a doubly +linked list. Among the common operations like insert, remove, search and sort, +we allow convenient iteration via a special `UCX_FOREACH` macro. + +### Remove duplicates from an array of strings + +Assume you are given an array of `sstr_t` and want to create a list of these +strings without duplicates. +This is a similar example to the one [above](#array), but here we are +using a `UcxList`. +```C +#include +#include +#include +#include + +UcxList* remove_duplicates(sstr_t* array, size_t arrlen) { + UcxList* list = NULL; + for (size_t i = 0 ; i < arrlen ; ++i) { + if (ucx_list_find(list, array+i, ucx_cmp_sstr, NULL) == -1) { + sstr_t* s = malloc(sizeof(sstr_t)); + *s = sstrdup(array[i]); + list = ucx_list_append(list, s); + } + } + return list; +} + +/* we will need this function to clean up the list contents later */ +void free_sstr(void* ptr) { + sstr_t* s = ptr; + free(s->ptr); + free(s); +} + +/* ... */ + +sstr_t* array = /* some array of strings */ +size_t arrlen = /* the length of the array */ + +UcxList* list = remove_duplicates(array,arrlen); + +/* Iterate over the list and print the elements */ +UCX_FOREACH(elem, list) { + sstr_t s = *((sstr_t*)elem->data); + printf("%" PRIsstr "\n", SFMT(s)); +} + +/* Use our free function to free the duplicated strings. */ +ucx_list_free_content(list, free_sstr); +ucx_list_free(list); +``` + +## Logging + +*Header file:* [logging.h](api-2.1/logging_8h.html) +*Required modules:* [Map](#map), [String](#string) + +The logging module comes with some predefined log levels and allows some more +customization. You may choose if you want to get timestamps or source file and +line number logged automatically when outputting a message. +The following function call initializes a debug logger with all of the above +information: +```C + log = ucx_logger_new(stdout, UCX_LOGGER_DEBUG, + UCX_LOGGER_LEVEL | UCX_LOGGER_TIMESTAMP | UCX_LOGGER_SOURCE); +``` +Afterwards you can use this logger with the predefined macros +```C + ucx_logger_trace(log, "Verbose output"); + ucx_logger_debug(log, "Debug message"); + ucx_logger_info(log, "Information"); + ucx_logger_warn(log, "Warning"); + ucx_logger_error(log, "Error message"); +``` +or you use +```C + ucx_logger_log(log, CUSTOM_LEVEL, "Some message") +``` +When you use your custom log level, don't forget to register it with +```C + ucx_logger_register_level(log, CUSTOM_LEVEL, "CUSTOM") +``` +where the last argument must be a string literal. + +## Map + +*Header file:* [map.h](api-2.1/map_8h.html) +*Required modules:* [Allocator](#allocator), [String](#string) + +This module provides a hash map implementation using murmur hash 2 and separate +chaining with linked lists. Similarly to the list module, we provide a +`UCX_MAP_FOREACH` macro to conveniently iterate through the key/value pairs. + +### Parsing command line options + +Assume you want to parse command line options and record them within a map. +One way to do this is shown by the following code sample: +```C + UcxMap* options = ucx_map_new(16); + const char *NOARG = ""; + + char *option = NULL; + char optchar = 0; + for(int i=1;i 1 && arg[0] == '-') { + for(int c=1;c +#include +#include +#include +#include +#include + +typedef struct { + sstr_t column_a; + sstr_t column_b; + sstr_t column_c; +} CSVData; + +int main(int argc, char** argv) { + + UcxMempool* pool = ucx_mempool_new(128); + + FILE *f = fopen("test.csv", "r"); + if (!f) { + perror("Cannot open file"); + return 1; + } + /* close the file automatically at pool destruction*/ + ucx_mempool_reg_destr(pool, f, (ucx_destructor) fclose); + + /* create a buffer and register it at the memory pool for destruction */ + UcxBuffer* content = ucx_buffer_new(NULL, 256, UCX_BUFFER_AUTOEXTEND); + ucx_mempool_reg_destr(pool, content, (ucx_destructor) ucx_buffer_free); + + /* read the file and split it by lines first */ + ucx_stream_copy(f, content, fread, ucx_buffer_write); + sstr_t contentstr = ucx_buffer_to_sstr(content); + ssize_t lc = 0; + sstr_t* lines = sstrsplit_a(pool->allocator, contentstr, S("\n"), &lc); + + /* skip the header and parse the remaining data */ + UcxList* datalist = NULL; + for (size_t i = 1 ; i < lc ; i++) { + if (lines[i].length == 0) continue; + ssize_t fc = 3; + sstr_t* fields = sstrsplit_a(pool->allocator, lines[i], S(";"), &fc); + if (fc != 3) { + fprintf(stderr, "Syntax error in line %zu.\n", i); + ucx_mempool_destroy(pool); + return 1; + } + CSVData* data = ucx_mempool_malloc(pool, sizeof(CSVData)); + data->column_a = fields[0]; + data->column_b = fields[1]; + data->column_c = fields[2]; + datalist = ucx_list_append_a(pool->allocator, datalist, data); + } + + /* control output */ + UCX_FOREACH(elem, datalist) { + CSVData* data = elem->data; + printf("Column A: %" PRIsstr " | " + "Column B: %" PRIsstr " | " + "Column C: %" PRIsstr "\n", + SFMT(data->column_a), SFMT(data->column_b), SFMT(data->column_c) + ); + } + + /* cleanup everything, no manual free() needed */ + ucx_mempool_destroy(pool); + + return 0; +} +``` + +### Overriding the default destructor + +Sometimes you need to allocate memory with `ucx_mempool_malloc()`, but the +memory is not supposed to be freed with a simple call to `free()`. +In this case, you can overwrite the default destructor as follows: +```C + MyObject* obj = ucx_mempool_malloc(pool, sizeof(MyObject)); + + /* some special initialization with own resource management */ + my_object_init(obj); + + /* register destructor function */ + ucx_mempool_set_destr(obj, (ucx_destructor) my_object_destroy); +``` +Be aware, that your destructor function should not free any memory, that is +also managed by the pool. +Otherwise you might be risking a double-free. +More precisely, a destructor function set with `ucx_mempool_set_destr()` MUST +NOT call `free()` on the specified pointer whereas a desructor function +registered with `ucx_mempool_reg_destr()` MAY (and in most cases will) call +`free()`. + +## Properties + +*Header file:* [properties.h](api-2.1/properties_8h.html) +*Required modules:* [Map](#map) + +This module provides load and store function for `*.properties` files. +The key/value pairs are stored within an UCX Map. + +### Example: Loading properties from a file + +```C +/* Open the file as usual */ +FILE* file = fopen("myprops.properties", "r"); +if (!file) { + // error handling + return 1; +} + +/* Load the properties from the file */ +UcxMap* myprops = ucx_map_new(16); +if (ucx_properties_load(myprops, file)) { + /* ... error handling ... */ + fclose(file); + ucx_map_free(myprops); + return 1; +} + +/* Print out the key/value pairs */ +char* propval; +UcxMapIterator propiter = ucx_map_iterator(myprops); +UCX_MAP_FOREACH(key, propval, propiter) { + printf("%s = %s\n", (char*)key.data, propval); +} + +/* Don't forget to free the values before freeing the map */ +ucx_map_free_content(myprops, NULL); +ucx_map_free(myprops); +fclose(file); +``` + +## Stack + +*Header file:* [stack.h](api-2.1/stack_8h.html) +*Required modules:* [Allocator](#allocator) + +This concrete implementation of an UCX Allocator allows you to grab some amount +of memory which is then handled as a stack. +Please note, that the term *stack* only refers to the behavior of this +allocator. You may still choose to use either stack or heap memory +for the underlying space. +A typical use case is an algorithm where you need to allocate and free large +amounts of memory very frequently. + +The following code sample shows how to initialize a stack and push and pop +simple data. +```C + const size_t len = 1024; + char space[len]; + UcxStack stack; + ucx_stack_init(&stack, space, len); + + int i = 42; + float f = 3.14f; + const char* str = "Hello!"; + size_t strn = 7; + + /* push the integer */ + ucx_stack_push(&stack, sizeof(int), &i); + + /* push the float and rember the address */ + float* remember = ucx_stack_push(&stack, sizeof(float), &f); + + /* push the string with zero terminator */ + ucx_stack_push(&stack, strn, str); + + /* if we forget, how big an element was, we can ask the stack */ + printf("Length of string: %zu\n", ucx_stack_topsize(&stack)-1); + + /* retrieve the string as sstr_t, without zero terminator! */ + sstr_t s; + s.length = ucx_stack_topsize(&stack)-1; + s.ptr = malloc(s.length); + ucx_stack_popn(&stack, s.ptr, s.length); + printf("%" PRIsstr "\n", SFMT(s)); + + /* print the float directly from the stack and free it */ + printf("Float: %f\n", *remember); + ucx_stack_free(&stack, remember); + + /* the last element is the integer */ + int j; + ucx_stack_pop(&stack, &j); + printf("Integer: %d\n", j); +``` + + + +## String + +*Header file:* [string.h](api-2.1/string_8h.html) +*Required modules:* [Allocator](#allocator) + +This module provides a safe implementation of bounded string. +Usually C strings do not carry a length. While for zero-terminated strings you +can easily get the length with `strlen`, this is not generally possible for +arbitrary strings. +The `sstr_t` type of this module always carries the string and its length to +reduce the risk of buffer overflows dramatically. + +### Initialization + +There are several ways to create an `sstr_t`: + +```C +/* (1) sstr() uses strlen() internally, hence cstr MUST be zero-terminated */ +sstr_t a = sstr(cstr); + +/* (2) cstr does not need to be zero-terminated, if length is specified */ +sstr_t b = sstrn(cstr, len); + +/* (3) S() macro creates sstr_t from a string using sizeof() and using sstrn(). + This version is especially useful for function arguments */ +sstr_t c = S("hello"); + +/* (4) SC() macro works like S(), but makes the string immutable using scstr_t. + (available since UCX 2.0) */ +scstr_t d = SC("hello"); + +/* (5) ST() macro creates sstr_t struct literal using sizeof() */ +sstr_t e = ST("hello"); +``` + +You should not use the `S()`, `SC()`, or `ST()` macro with string of unknown +origin, since the `sizeof()` call might not coincide with the string length in +those cases. If you know what you are doing, it can save you some performance, +because you do not need the `strlen()` call. + +### Handling immutable strings + +*(Since: UCX 2.0)* + +For immutable strings (i.e. `const char*` strings), UCX provides the `scstr_t` +type, which works exactly as the `sstr_t` type but with a pointer +to `const char`. All UCX string functions come in two flavors: one that enforces +the `scstr_t` type, and another that usually accepts both types and performs +a conversion automatically, if necessary. + +There are some exceptions to this rule, as the return type may depend on the +argument type. +E.g. the `sstrchr()` function returns a substring starting at +the first occurrence of the specified character. +Since this substring points to the memory of the argument string, it does not +accept `scstr_t` as input argument, because the return type would break the +constness. + + +### Finding the position of a substring + +The `sstrstr()` function gives you a new `sstr_t` object starting with the +requested substring. Thus determining the position comes down to a simple +subtraction. + +```C +sstr_t haystack = ST("Here we go!"); +sstr_t needle = ST("we"); +sstr_t result = sstrstr(haystack, needle); +if (result.ptr) + printf("Found at position %zd.\n", haystack.length-result.length); +else + printf("Not found.\n"); +``` + +### Spliting a string by a delimiter + +The `sstrsplit()` function (and its allocator based version `sstrsplit_a()`) is +very powerful and might look a bit nasty at a first glance. But it is indeed +very simple to use. It is even more convenient in combination with a memory +pool. + +```C +sstr_t test = ST("here::are::some::strings"); +sstr_t delim = ST("::"); + +ssize_t count = 0; /* no limit */ +UcxMempool* pool = ucx_mempool_new_default(); + +sstr_t* result = sstrsplit_a(pool->allocator, test, delim, &count); +for (ssize_t i = 0 ; i < count ; i++) { + /* don't forget to specify the length via the %*s format specifier */ + printf("%*s\n", result[i].length, result[i].ptr); +} + +ucx_mempool_destroy(pool); +``` +The output is: + + here + are + some + strings + +The memory pool ensures, that all strings are freed. + +### Disabling convenience macros + +If you are experiencing any troubles with the short convenience macros `S()`, +`SC()`, or `ST()`, you can disable them by setting the macro +`UCX_NO_SSTR_SHORTCUTS` before including the header (or via a compiler option). +For the formatting macros `SFMT()` and `PRIsstr` you can use the macro +`UCX_NO_SSTR_FORMAT_MACROS` to disable them. + +Please keep in mind, that after disabling the macros, you cannot use them in +your code *and* foreign code that you might have included. +You should only disable the macros, if you are experiencing a nasty name clash +which cannot be otherwise resolved. + +## Testing + +*Header file:* [test.h](api-2.1/test_8h.html) +*Required modules:* None. + +This module provides a testing framework which allows you to execute test cases +within test suites. +To avoid code duplication within tests, we also provide the possibility to +define test subroutines. + +You should declare test cases and subroutines in a header file per test unit +and implement them as you would implement normal functions. +```C + /* myunit.h */ + UCX_TEST(function_name); + UCX_TEST_SUBROUTINE(subroutine_name, paramlist); /* optional */ + + + /* myunit.c */ + UCX_TEST_SUBROUTINE(subroutine_name, paramlist) { + /* ... reusable tests with UCX_TEST_ASSERT() ... */ + } + + UCX_TEST(function_name) { + /* ... resource allocation and other test preparation ... */ + + /* mandatory marker for the start of the tests */ + UCX_TEST_BEGIN + + /* ... verifications with UCX_TEST_ASSERT() ... + * (and/or calls with UCX_TEST_CALL_SUBROUTINE()) + */ + + /* mandatory marker for the end of the tests */ + UCX_TEST_END + + /* ... resource cleanup ... + * (all code after UCX_TEST_END is always executed) + */ + } +``` +If you want to use the `UCX_TEST_ASSERT()` macro in a function, you are +*required* to use a `UCX_TEST_SUBROUTINE`. +Otherwise the testing framework does not know where to jump, when the assertion +fails. + +After implementing the tests, you can easily build a test suite and execute it: +```C + UcxTestSuite* suite = ucx_test_suite_new(); + ucx_test_register(suite, testMyTestCase01); + ucx_test_register(suite, testMyTestCase02); + /* ... */ + ucx_test_run(suite, stdout); /* stdout, or any other FILE stream */ +``` + +## Utilities + +*Header file:* [utils.h](api-2.1/utils_8h.html) +*Required modules:* [Allocator](#allocator), [String](#string) + +In this module we provide very general utility function for copy and compare +operations. +We also provide several `printf` variants to conveniently print formatted data +to streams or strings. + +### A simple copy program + +The utilities package provides several stream copy functions. +One of them has a very simple interface and can, for instance, be used to copy +whole files in a single call. +This is a minimal working example: +```C +#include +#include + +int main(int argc, char** argv) { + + if (argc != 3) { + fprintf(stderr, "Use %s ", argv[0]); + return 1; + } + + FILE *srcf = fopen(argv[1], "r"); /* insert error handling on your own */ + FILE *destf = fopen(argv[2], "w"); + + size_t n = ucx_stream_copy(srcf, destf, fread, fwrite); + printf("%zu bytes copied.\n", n); + + fclose(srcf); + fclose(destf); + + + return 0; +} +``` + +### Automatic allocation for formatted strings + +The UCX utility function `ucx_asprintf()` and it's convenient shortcut +`ucx_sprintf` allow easy formatting of strings, without ever having to worry +about the required space. +```C +sstr_t mystring = ucx_sprintf("The answer is: %d!", 42); +``` +Still, you have to pass `mystring.ptr` to `free()` (or the free function of +your allocator, if you use `ucx_asprintf`). +If you don't have all the information ready to build your string, you can even +use a [UcxBuffer](#buffer) as a target with the utility function +`ucx_bprintf()`. +```C +UcxBuffer* strbuffer = ucx_buffer_new(NULL, 512, UCX_BUFFER_AUTOEXTEND); + +for (unsigned int i = 2 ; i < 100 ; i++) { + ucx_bprintf(strbuffer, "Integer %d is %s\n", + i, prime(i) ? "prime" : "not prime"); +} + +/* print the result to stdout */ +printf("%s", (char*)strbuffer->space); + +ucx_buffer_free(strbuffer); +``` diff -r 92e482410453 -r d345541018fa docs/src/modules.md --- a/docs/src/modules.md Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,873 +0,0 @@ ---- -title: Modules ---- - -UCX provides several modules for data structures and algorithms. -You may choose to use specific modules by inclueding the corresponding header -file. -Please note, that some modules make use of other UCX modules. -For instance, the [Allocator](#allocator) module is used by many other modules -to allow flexible memory allocation. -By default the header files are placed into an `ucx` directory within your -systems include directory. In this case you can use a module by including it -via `#include `. -Required modules are included automatically. - -
    - ------------------------ ---------------------- -------------------------------- --------------------------- -[String](#string) [Buffer](#buffer) -[Allocator](#allocator) [Stack](#stack) [Memory Pool](#memory-pool) -[Array](#array) [List](#list) [Map](#map) [AVL Tree](#avl-tree) -[Logging](#logging) [Testing](#testing) [Utilities](#utilities) [Properties](#properties) ------------------------ ---------------------- -------------------------------- --------------------------- - -
    - -## Allocator - -*Header file:* [allocator.h](api/allocator_8h.html) -*Required modules:* None. - -A UCX allocator consists of a pointer to the memory area / pool and four -function pointers to memory management functions operating on this memory -area / pool. These functions shall behave equivalent to the standard libc -functions `malloc`, `calloc`, `realloc` and `free`. - -The signature of the memory management functions is based on the signature -of the respective libc function but each of them takes the pointer to the -memory area / pool as first argument. - -As the pointer to the memory area / pool can be arbitrarily chosen, any data -can be provided to the memory management functions. One example is the -[UCX Memory Pool](#memory-pool). - -## Array - -*Header file:* [array.h](api/array_8h.html) -*Required modules:* [Allocator](#allocator) - -The UCX Array is an implementation of a dynamic array with automatic -reallocation. The array structure contains a capacity, the current size, -the size of each element, the raw pointer to the memory area and an allocator. -Arrays are in most cases much faster than linked list. -One can decide, whether to create a new array on the heap with `ucx_array_new()` -or to save one indirection by initializing a `UcxArray` structure on the stack -with `ucx_array_init()`. - -### Remove duplicates from an array of strings - -The following example shows, how a `UcxArray` can be built with -a standard dynamic C array (pointer+length) as basis. - -```C -UcxArray* create_unique(sstr_t* array, size_t arrlen) { - // worst case is no duplicates, hence the capacity is set to arrlen - UcxArray* result = ucx_array_new(arrlen, sizeof(sstr_t)); - // only append elements, if they are not already present in the array - for (size_t i = 0 ; i < arrlen ; ++i) { - if (!ucx_array_contains(result, array+i, ucx_cmp_sstr, NULL)) { - ucx_array_append_from(result, array+i, 1); - } - } - // make the array as small as possible - ucx_array_shrink(result); - return result; -} - -/* ... */ - -sstr_t* array = /* some standard array of strings */ -size_t arrlen = /* the length of the array */ - -UcxArray* result = create_unique(array,arrlen); - -/* Iterate over the array and print the elements */ -sstr_t* unique = result->data; -for (size_t i = 0 ; i < result->size ; i++) { - printf("%" PRIsstr "\n", SFMT(unique[i])); -} - -/* Free the array. */ -ucx_array_free(result); -``` -### Preventing out of bounds writes - -The functions `ucx_array_reserve()`, `ucx_array_resize()`, `ucx_array_grow()`, -and `ucx_array_shrink()` allow easy management of the array capacity. -Imagine you want to add `n` elements to an array. If your `n` elements are -already somewhere else consecutively in memory, you can use -`ucx_array_append_from()` and benefit from the autogrow facility in this family -of functions. Otherwise, you can ask the array to have enough capacity for -holding additional `n` elements. - -```C -size_t n = // ... elements to add -if (ucx_array_grow(array, n)) { - fprintf(stderr, "Cannot add %zu elements to the array.\n", n); - return 1; -} -for (size_t i = 0 ; i < n ; i++) { - ((int*)array->data)[array->size++] = 80; -} -``` - -## AVL Tree - -*Header file:* [avl.h](api/avl_8h.html) -*Required modules:* [Allocator](#allocator) - -This binary search tree implementation allows average O(1) insertion and -removal of elements (excluding binary search time). -All common binary tree operations are implemented. Furthermore, this module -provides search functions via lower and upper bounds. - -### Filtering items with a time window - -Suppose you have a list of items which contain a `time_t` value and your task -is to find all items within a time window `[t_start, t_end]`. -With AVL Trees this is easy: -```C -/* --------------------- - * Somewhere in a header - */ -typedef struct { - time_t ts; - /* other important data */ -} MyObject; - -/* ----------- - * Source code - */ - -UcxAVLTree* tree = ucx_avl_new(ucx_cmp_longint); -/* ... populate tree with objects, use '& MyObject.ts' as key ... */ - - -/* Now find every item, with 30 <= ts <= 70 */ -time_t ts_start = 30; -time_t ts_end = 70; - -printf("Values in range:\n"); -for ( - UcxAVLNode* node = ucx_avl_find_node( - tree, (intptr_t) &ts_start, - ucx_dist_longint, UCX_AVL_FIND_LOWER_BOUNDED); - node && (*(time_t*)node->key) <= ts_end; - node = ucx_avl_succ(node) - ) { - printf(" ts: %ld\n", ((MyObject*)node->value)->ts); -} - -ucx_avl_free_content(tree, free); -ucx_avl_free(tree); -``` - -## Buffer - -*Header file:* [buffer.h](api/buffer_8h.html) -*Required modules:* None. - -Instances of this buffer implementation can be used to read from or to write to -memory like you would do with a stream. This allows the use of -`ucx_stream_copy()` from the [Utilities](#utilities) module to copy contents -from one buffer to another or from file or network streams to the buffer and -vice-versa. - -More features for convenient use of the buffer can be enabled, like automatic -memory management and automatic resizing of the buffer space. -See the documentation of the macro constants in the header file for more -information. - -### Add line numbers to a file - -When reading a file line by line, you have three options: first, you could limit -the maximum supported line length. -Second, you allocate a god buffer large -enough for the most lines a text file could have. -And third, undoubtedly the best option, you start with a small buffer, which -adjusts on demand. -An `UcxBuffer` can be created to do just that for you. -Just pass the `UCX_BUFFER_AUTOEXTEND` option to the initialization function. -Here is a full working program, which adds line numbers to a file. -```C -#include -#include -#include - -int main(int argc, char** argv) { - - if (argc != 2) { - fprintf(stderr, "Usage: %s \n", argv[0]); - return 1; - } - - FILE* input = fopen(argv[1], "r"); - if (!input) { - perror("Canno read input"); - return 1; - } - - const size_t chunksize = 256; - - UcxBuffer* linebuf = - ucx_buffer_new( - NULL, /* the buffer should manage the memory area for us */ - 2*chunksize, /* initial size should be twice the chunk size */ - UCX_BUFFER_AUTOEXTEND); /* the buffer will grow when necessary */ - - size_t lineno = 1; - do { - /* read line chunk */ - size_t read = ucx_stream_ncopy( - input, linebuf, fread, ucx_buffer_write, chunksize); - if (read == 0) break; - - /* handle line endings */ - do { - sstr_t bufstr = ucx_buffer_to_sstr(linebuf); - sstr_t nl = sstrchr(bufstr, '\n'); - if (nl.length == 0) break; - - size_t linelen = bufstr.length - nl.length; - sstr_t linestr = sstrsubsl(bufstr, 0, linelen); - - printf("%zu: %" PRIsstr "\n", lineno++, SFMT(linestr)); - - /* shift the buffer to the next line */ - ucx_buffer_shift_left(linebuf, linelen+1); - } while(1); - - } while(1); - - /* print the 'noeol' line, if any */ - sstr_t lastline = ucx_buffer_to_sstr(linebuf); - if (lastline.length > 0) { - printf("%zu: %" PRIsstr, lineno, SFMT(lastline)); - } - - fclose(input); - ucx_buffer_free(linebuf); - - return 0; -} -``` - -## List - -*Header file:* [list.h](api/list_8h.html) -*Required modules:* [Allocator](#allocator) - -This module provides the data structure and several functions for a doubly -linked list. Among the common operations like insert, remove, search and sort, -we allow convenient iteration via a special `UCX_FOREACH` macro. - -### Remove duplicates from an array of strings - -Assume you are given an array of `sstr_t` and want to create a list of these -strings without duplicates. -This is a similar example to the one [above](#array), but here we are -using a `UcxList`. -```C -#include -#include -#include -#include - -UcxList* remove_duplicates(sstr_t* array, size_t arrlen) { - UcxList* list = NULL; - for (size_t i = 0 ; i < arrlen ; ++i) { - if (ucx_list_find(list, array+i, ucx_cmp_sstr, NULL) == -1) { - sstr_t* s = malloc(sizeof(sstr_t)); - *s = sstrdup(array[i]); - list = ucx_list_append(list, s); - } - } - return list; -} - -/* we will need this function to clean up the list contents later */ -void free_sstr(void* ptr) { - sstr_t* s = ptr; - free(s->ptr); - free(s); -} - -/* ... */ - -sstr_t* array = /* some array of strings */ -size_t arrlen = /* the length of the array */ - -UcxList* list = remove_duplicates(array,arrlen); - -/* Iterate over the list and print the elements */ -UCX_FOREACH(elem, list) { - sstr_t s = *((sstr_t*)elem->data); - printf("%" PRIsstr "\n", SFMT(s)); -} - -/* Use our free function to free the duplicated strings. */ -ucx_list_free_content(list, free_sstr); -ucx_list_free(list); -``` - -## Logging - -*Header file:* [logging.h](api/logging_8h.html) -*Required modules:* [Map](#map), [String](#string) - -The logging module comes with some predefined log levels and allows some more -customization. You may choose if you want to get timestamps or source file and -line number logged automatically when outputting a message. -The following function call initializes a debug logger with all of the above -information: -```C - log = ucx_logger_new(stdout, UCX_LOGGER_DEBUG, - UCX_LOGGER_LEVEL | UCX_LOGGER_TIMESTAMP | UCX_LOGGER_SOURCE); -``` -Afterwards you can use this logger with the predefined macros -```C - ucx_logger_trace(log, "Verbose output"); - ucx_logger_debug(log, "Debug message"); - ucx_logger_info(log, "Information"); - ucx_logger_warn(log, "Warning"); - ucx_logger_error(log, "Error message"); -``` -or you use -```C - ucx_logger_log(log, CUSTOM_LEVEL, "Some message") -``` -When you use your custom log level, don't forget to register it with -```C - ucx_logger_register_level(log, CUSTOM_LEVEL, "CUSTOM") -``` -where the last argument must be a string literal. - -## Map - -*Header file:* [map.h](api/map_8h.html) -*Required modules:* [Allocator](#allocator), [String](#string) - -This module provides a hash map implementation using murmur hash 2 and separate -chaining with linked lists. Similarly to the list module, we provide a -`UCX_MAP_FOREACH` macro to conveniently iterate through the key/value pairs. - -### Parsing command line options - -Assume you want to parse command line options and record them within a map. -One way to do this is shown by the following code sample: -```C - UcxMap* options = ucx_map_new(16); - const char *NOARG = ""; - - char *option = NULL; - char optchar = 0; - for(int i=1;i 1 && arg[0] == '-') { - for(int c=1;c -#include -#include -#include -#include -#include - -typedef struct { - sstr_t column_a; - sstr_t column_b; - sstr_t column_c; -} CSVData; - -int main(int argc, char** argv) { - - UcxMempool* pool = ucx_mempool_new(128); - - FILE *f = fopen("test.csv", "r"); - if (!f) { - perror("Cannot open file"); - return 1; - } - /* close the file automatically at pool destruction*/ - ucx_mempool_reg_destr(pool, f, (ucx_destructor) fclose); - - /* create a buffer and register it at the memory pool for destruction */ - UcxBuffer* content = ucx_buffer_new(NULL, 256, UCX_BUFFER_AUTOEXTEND); - ucx_mempool_reg_destr(pool, content, (ucx_destructor) ucx_buffer_free); - - /* read the file and split it by lines first */ - ucx_stream_copy(f, content, fread, ucx_buffer_write); - sstr_t contentstr = ucx_buffer_to_sstr(content); - ssize_t lc = 0; - sstr_t* lines = sstrsplit_a(pool->allocator, contentstr, S("\n"), &lc); - - /* skip the header and parse the remaining data */ - UcxList* datalist = NULL; - for (size_t i = 1 ; i < lc ; i++) { - if (lines[i].length == 0) continue; - ssize_t fc = 3; - sstr_t* fields = sstrsplit_a(pool->allocator, lines[i], S(";"), &fc); - if (fc != 3) { - fprintf(stderr, "Syntax error in line %zu.\n", i); - ucx_mempool_destroy(pool); - return 1; - } - CSVData* data = ucx_mempool_malloc(pool, sizeof(CSVData)); - data->column_a = fields[0]; - data->column_b = fields[1]; - data->column_c = fields[2]; - datalist = ucx_list_append_a(pool->allocator, datalist, data); - } - - /* control output */ - UCX_FOREACH(elem, datalist) { - CSVData* data = elem->data; - printf("Column A: %" PRIsstr " | " - "Column B: %" PRIsstr " | " - "Column C: %" PRIsstr "\n", - SFMT(data->column_a), SFMT(data->column_b), SFMT(data->column_c) - ); - } - - /* cleanup everything, no manual free() needed */ - ucx_mempool_destroy(pool); - - return 0; -} -``` - -### Overriding the default destructor - -Sometimes you need to allocate memory with `ucx_mempool_malloc()`, but the -memory is not supposed to be freed with a simple call to `free()`. -In this case, you can overwrite the default destructor as follows: -```C - MyObject* obj = ucx_mempool_malloc(pool, sizeof(MyObject)); - - /* some special initialization with own resource management */ - my_object_init(obj); - - /* register destructor function */ - ucx_mempool_set_destr(obj, (ucx_destructor) my_object_destroy); -``` -Be aware, that your destructor function should not free any memory, that is -also managed by the pool. -Otherwise you might be risking a double-free. -More precisely, a destructor function set with `ucx_mempool_set_destr()` MUST -NOT call `free()` on the specified pointer whereas a desructor function -registered with `ucx_mempool_reg_destr()` MAY (and in most cases will) call -`free()`. - -## Properties - -*Header file:* [properties.h](api/properties_8h.html) -*Required modules:* [Map](#map) - -This module provides load and store function for `*.properties` files. -The key/value pairs are stored within an UCX Map. - -### Example: Loading properties from a file - -```C -/* Open the file as usual */ -FILE* file = fopen("myprops.properties", "r"); -if (!file) { - // error handling - return 1; -} - -/* Load the properties from the file */ -UcxMap* myprops = ucx_map_new(16); -if (ucx_properties_load(myprops, file)) { - /* ... error handling ... */ - fclose(file); - ucx_map_free(myprops); - return 1; -} - -/* Print out the key/value pairs */ -char* propval; -UcxMapIterator propiter = ucx_map_iterator(myprops); -UCX_MAP_FOREACH(key, propval, propiter) { - printf("%s = %s\n", (char*)key.data, propval); -} - -/* Don't forget to free the values before freeing the map */ -ucx_map_free_content(myprops, NULL); -ucx_map_free(myprops); -fclose(file); -``` - -## Stack - -*Header file:* [stack.h](api/stack_8h.html) -*Required modules:* [Allocator](#allocator) - -This concrete implementation of an UCX Allocator allows you to grab some amount -of memory which is then handled as a stack. -Please note, that the term *stack* only refers to the behavior of this -allocator. You may still choose to use either stack or heap memory -for the underlying space. -A typical use case is an algorithm where you need to allocate and free large -amounts of memory very frequently. - -The following code sample shows how to initialize a stack and push and pop -simple data. -```C - const size_t len = 1024; - char space[len]; - UcxStack stack; - ucx_stack_init(&stack, space, len); - - int i = 42; - float f = 3.14f; - const char* str = "Hello!"; - size_t strn = 7; - - /* push the integer */ - ucx_stack_push(&stack, sizeof(int), &i); - - /* push the float and rember the address */ - float* remember = ucx_stack_push(&stack, sizeof(float), &f); - - /* push the string with zero terminator */ - ucx_stack_push(&stack, strn, str); - - /* if we forget, how big an element was, we can ask the stack */ - printf("Length of string: %zu\n", ucx_stack_topsize(&stack)-1); - - /* retrieve the string as sstr_t, without zero terminator! */ - sstr_t s; - s.length = ucx_stack_topsize(&stack)-1; - s.ptr = malloc(s.length); - ucx_stack_popn(&stack, s.ptr, s.length); - printf("%" PRIsstr "\n", SFMT(s)); - - /* print the float directly from the stack and free it */ - printf("Float: %f\n", *remember); - ucx_stack_free(&stack, remember); - - /* the last element is the integer */ - int j; - ucx_stack_pop(&stack, &j); - printf("Integer: %d\n", j); -``` - - - -## String - -*Header file:* [string.h](api/string_8h.html) -*Required modules:* [Allocator](#allocator) - -This module provides a safe implementation of bounded string. -Usually C strings do not carry a length. While for zero-terminated strings you -can easily get the length with `strlen`, this is not generally possible for -arbitrary strings. -The `sstr_t` type of this module always carries the string and its length to -reduce the risk of buffer overflows dramatically. - -### Initialization - -There are several ways to create an `sstr_t`: - -```C -/* (1) sstr() uses strlen() internally, hence cstr MUST be zero-terminated */ -sstr_t a = sstr(cstr); - -/* (2) cstr does not need to be zero-terminated, if length is specified */ -sstr_t b = sstrn(cstr, len); - -/* (3) S() macro creates sstr_t from a string using sizeof() and using sstrn(). - This version is especially useful for function arguments */ -sstr_t c = S("hello"); - -/* (4) SC() macro works like S(), but makes the string immutable using scstr_t. - (available since UCX 2.0) */ -scstr_t d = SC("hello"); - -/* (5) ST() macro creates sstr_t struct literal using sizeof() */ -sstr_t e = ST("hello"); -``` - -You should not use the `S()`, `SC()`, or `ST()` macro with string of unknown -origin, since the `sizeof()` call might not coincide with the string length in -those cases. If you know what you are doing, it can save you some performance, -because you do not need the `strlen()` call. - -### Handling immutable strings - -*(Since: UCX 2.0)* - -For immutable strings (i.e. `const char*` strings), UCX provides the `scstr_t` -type, which works exactly as the `sstr_t` type but with a pointer -to `const char`. All UCX string functions come in two flavors: one that enforces -the `scstr_t` type, and another that usually accepts both types and performs -a conversion automatically, if necessary. - -There are some exceptions to this rule, as the return type may depend on the -argument type. -E.g. the `sstrchr()` function returns a substring starting at -the first occurrence of the specified character. -Since this substring points to the memory of the argument string, it does not -accept `scstr_t` as input argument, because the return type would break the -constness. - - -### Finding the position of a substring - -The `sstrstr()` function gives you a new `sstr_t` object starting with the -requested substring. Thus determining the position comes down to a simple -subtraction. - -```C -sstr_t haystack = ST("Here we go!"); -sstr_t needle = ST("we"); -sstr_t result = sstrstr(haystack, needle); -if (result.ptr) - printf("Found at position %zd.\n", haystack.length-result.length); -else - printf("Not found.\n"); -``` - -### Spliting a string by a delimiter - -The `sstrsplit()` function (and its allocator based version `sstrsplit_a()`) is -very powerful and might look a bit nasty at a first glance. But it is indeed -very simple to use. It is even more convenient in combination with a memory -pool. - -```C -sstr_t test = ST("here::are::some::strings"); -sstr_t delim = ST("::"); - -ssize_t count = 0; /* no limit */ -UcxMempool* pool = ucx_mempool_new_default(); - -sstr_t* result = sstrsplit_a(pool->allocator, test, delim, &count); -for (ssize_t i = 0 ; i < count ; i++) { - /* don't forget to specify the length via the %*s format specifier */ - printf("%*s\n", result[i].length, result[i].ptr); -} - -ucx_mempool_destroy(pool); -``` -The output is: - - here - are - some - strings - -The memory pool ensures, that all strings are freed. - -### Disabling convenience macros - -If you are experiencing any troubles with the short convenience macros `S()`, -`SC()`, or `ST()`, you can disable them by setting the macro -`UCX_NO_SSTR_SHORTCUTS` before including the header (or via a compiler option). -For the formatting macros `SFMT()` and `PRIsstr` you can use the macro -`UCX_NO_SSTR_FORMAT_MACROS` to disable them. - -Please keep in mind, that after disabling the macros, you cannot use them in -your code *and* foreign code that you might have included. -You should only disable the macros, if you are experiencing a nasty name clash -which cannot be otherwise resolved. - -## Testing - -*Header file:* [test.h](api/test_8h.html) -*Required modules:* None. - -This module provides a testing framework which allows you to execute test cases -within test suites. -To avoid code duplication within tests, we also provide the possibility to -define test subroutines. - -You should declare test cases and subroutines in a header file per test unit -and implement them as you would implement normal functions. -```C - /* myunit.h */ - UCX_TEST(function_name); - UCX_TEST_SUBROUTINE(subroutine_name, paramlist); /* optional */ - - - /* myunit.c */ - UCX_TEST_SUBROUTINE(subroutine_name, paramlist) { - /* ... reusable tests with UCX_TEST_ASSERT() ... */ - } - - UCX_TEST(function_name) { - /* ... resource allocation and other test preparation ... */ - - /* mandatory marker for the start of the tests */ - UCX_TEST_BEGIN - - /* ... verifications with UCX_TEST_ASSERT() ... - * (and/or calls with UCX_TEST_CALL_SUBROUTINE()) - */ - - /* mandatory marker for the end of the tests */ - UCX_TEST_END - - /* ... resource cleanup ... - * (all code after UCX_TEST_END is always executed) - */ - } -``` -If you want to use the `UCX_TEST_ASSERT()` macro in a function, you are -*required* to use a `UCX_TEST_SUBROUTINE`. -Otherwise the testing framework does not know where to jump, when the assertion -fails. - -After implementing the tests, you can easily build a test suite and execute it: -```C - UcxTestSuite* suite = ucx_test_suite_new(); - ucx_test_register(suite, testMyTestCase01); - ucx_test_register(suite, testMyTestCase02); - /* ... */ - ucx_test_run(suite, stdout); /* stdout, or any other FILE stream */ -``` - -## Utilities - -*Header file:* [utils.h](api/utils_8h.html) -*Required modules:* [Allocator](#allocator), [String](#string) - -In this module we provide very general utility function for copy and compare -operations. -We also provide several `printf` variants to conveniently print formatted data -to streams or strings. - -### A simple copy program - -The utilities package provides several stream copy functions. -One of them has a very simple interface and can, for instance, be used to copy -whole files in a single call. -This is a minimal working example: -```C -#include -#include - -int main(int argc, char** argv) { - - if (argc != 3) { - fprintf(stderr, "Use %s ", argv[0]); - return 1; - } - - FILE *srcf = fopen(argv[1], "r"); /* insert error handling on your own */ - FILE *destf = fopen(argv[2], "w"); - - size_t n = ucx_stream_copy(srcf, destf, fread, fwrite); - printf("%zu bytes copied.\n", n); - - fclose(srcf); - fclose(destf); - - - return 0; -} -``` - -### Automatic allocation for formatted strings - -The UCX utility function `ucx_asprintf()` and it's convenient shortcut -`ucx_sprintf` allow easy formatting of strings, without ever having to worry -about the required space. -```C -sstr_t mystring = ucx_sprintf("The answer is: %d!", 42); -``` -Still, you have to pass `mystring.ptr` to `free()` (or the free function of -your allocator, if you use `ucx_asprintf`). -If you don't have all the information ready to build your string, you can even -use a [UcxBuffer](#buffer) as a target with the utility function -`ucx_bprintf()`. -```C -UcxBuffer* strbuffer = ucx_buffer_new(NULL, 512, UCX_BUFFER_AUTOEXTEND); - -for (unsigned int i = 2 ; i < 100 ; i++) { - ucx_bprintf(strbuffer, "Integer %d is %s\n", - i, prime(i) ? "prime" : "not prime"); -} - -/* print the result to stdout */ -printf("%s", (char*)strbuffer->space); - -ucx_buffer_free(strbuffer); -``` diff -r 92e482410453 -r d345541018fa src/CMakeLists.txt --- a/src/CMakeLists.txt Mon Dec 30 09:54:10 2019 +0100 +++ b/src/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 @@ -1,34 +1,8 @@ set(sources - allocator.c - array.c - avl.c - buffer.c list.c - logging.c - map.c - mempool.c - properties.c - stack.c - string.c - test.c - ucx.c - utils.c ) set(headers - ucx/allocator.h - ucx/array.h - ucx/avl.h - ucx/buffer.h - ucx/list.h - ucx/logging.h - ucx/map.h - ucx/mempool.h - ucx/properties.h - ucx/stack.h - ucx/string.h - ucx/test.h - ucx/ucx.h - ucx/utils.h + cx/list.h ) add_library(ucx SHARED ${sources}) @@ -37,7 +11,7 @@ target_include_directories(ucx PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) target_include_directories(ucx_static PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) -set_target_properties(ucx PROPERTIES SOVERSION 3 VERSION 3.1.0) +set_target_properties(ucx PROPERTIES SOVERSION 4 VERSION 4.0.0) set_target_properties(ucx_static PROPERTIES VERSION ${CMAKE_PROJECT_VERSION}) # it is sufficient to specify the headers for one of the targets diff -r 92e482410453 -r d345541018fa src/Makefile.am --- a/src/Makefile.am Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. -# -# Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# - -lib_LTLIBRARIES = libucx.la -libucx_la_LDFLAGS = -version-info $(UCX_LIB_VERSION) -libucx_la_SOURCES = utils.c -libucx_la_SOURCES += array.c -libucx_la_SOURCES += list.c -libucx_la_SOURCES += map.c -libucx_la_SOURCES += avl.c -libucx_la_SOURCES += properties.c -libucx_la_SOURCES += mempool.c -libucx_la_SOURCES += string.c -libucx_la_SOURCES += test.c -libucx_la_SOURCES += allocator.c -libucx_la_SOURCES += logging.c -libucx_la_SOURCES += buffer.c -libucx_la_SOURCES += stack.c -libucx_la_SOURCES += ucx.c - -ucxdir = $(includedir)/ucx -ucx_HEADERS = ucx/allocator.h -ucx_HEADERS += ucx/array.h -ucx_HEADERS += ucx/avl.h -ucx_HEADERS += ucx/buffer.h -ucx_HEADERS += ucx/list.h -ucx_HEADERS += ucx/logging.h -ucx_HEADERS += ucx/map.h -ucx_HEADERS += ucx/mempool.h -ucx_HEADERS += ucx/properties.h -ucx_HEADERS += ucx/stack.h -ucx_HEADERS += ucx/string.h -ucx_HEADERS += ucx/test.h -ucx_HEADERS += ucx/ucx.h -ucx_HEADERS += ucx/utils.h - - diff -r 92e482410453 -r d345541018fa src/allocator.c --- a/src/allocator.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,60 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/allocator.h" - -#include - -static UcxAllocator default_allocator = { - NULL, - ucx_default_malloc, - ucx_default_calloc, - ucx_default_realloc, - ucx_default_free -}; - -UcxAllocator *ucx_default_allocator() { - UcxAllocator *allocator = &default_allocator; - return allocator; -} - -void *ucx_default_malloc(void *ignore, size_t n) { - return malloc(n); -} - -void *ucx_default_calloc(void *ignore, size_t n, size_t size) { - return calloc(n, size); -} - -void *ucx_default_realloc(void *ignore, void *data, size_t n) { - return realloc(data, n); -} - -void ucx_default_free(void *ignore, void *data) { - free(data); -} diff -r 92e482410453 -r d345541018fa src/array.c --- a/src/array.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,467 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#define _GNU_SOURCE /* we want to use qsort_r(), if available */ -#define __STDC_WANT_LIB_EXT1__ 1 /* use qsort_s, if available */ - - -#include "ucx/array.h" -#include "ucx/utils.h" - -#include -#include -#include - -#ifndef UCX_ARRAY_DISABLE_QSORT -#ifdef __GLIBC__ -#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) -#define ucx_array_sort_impl qsort_r -#endif /* glibc version >= 2.8 */ -#elif /* not __GLIBC__ */ defined(__APPLE__) || defined(__FreeBSD__) -#define ucx_array_sort_impl ucx_qsort_r -#define USE_UCX_QSORT_R -#elif /* not (__APPLE || __FreeBSD__) */ defined(__sun) -#if __STDC_VERSION__ >= 201112L -#define ucx_array_sort_impl qsort_s -#endif -#endif /* __GLIBC__, __APLE__, __FreeBSD__, __sun */ -#endif /* UCX_ARRAY_DISABLE_QSORT */ - -#ifndef ucx_array_sort_impl -#define ucx_array_sort_impl ucx_mergesort -#endif - -static int ucx_array_ensurecap(UcxArray *array, size_t reqcap) { - size_t required_capacity = array->capacity; - while (reqcap > required_capacity) { - if (required_capacity * 2 < required_capacity) - return 1; - required_capacity <<= 1; - } - if (ucx_array_reserve(array, required_capacity)) { - return 1; - } - return 0; -} - -int ucx_array_util_set_a(UcxAllocator* alloc, void** array, size_t* capacity, - size_t elmsize, size_t index, void* data) { - - if(!alloc || !capacity || !array) { - errno = EINVAL; - return 1; - } - - size_t newcapacity = *capacity; - while(index >= newcapacity) { - if(ucx_szmul(newcapacity, 2, &newcapacity)) { - errno = EOVERFLOW; - return 1; - } - } - - size_t memlen, offset; - if(ucx_szmul(newcapacity, elmsize, &memlen)) { - errno = EOVERFLOW; - return 1; - } - /* we don't need to check index*elmsize - it is smaller than memlen */ - - - void* newptr = alrealloc(alloc, *array, memlen); - if(newptr == NULL) { - errno = ENOMEM; /* we cannot assume that every allocator sets this */ - return 1; - } - *array = newptr; - *capacity = newcapacity; - - - char* dest = *array; - dest += elmsize*index; - memcpy(dest, data, elmsize); - - return 0; -} - -int ucx_array_util_setptr_a(UcxAllocator* alloc, void** array, size_t* capacity, - size_t index, void* data) { - - return ucx_array_util_set_a(alloc, array, capacity, sizeof(void*), - index, &data); -} - -UcxArray* ucx_array_new(size_t capacity, size_t elemsize) { - return ucx_array_new_a(capacity, elemsize, ucx_default_allocator()); -} - -UcxArray* ucx_array_new_a(size_t capacity, size_t elemsize, - UcxAllocator* allocator) { - UcxArray* array = almalloc(allocator, sizeof(UcxArray)); - if(array) { - ucx_array_init_a(array, capacity, elemsize, allocator); - } - return array; -} - -void ucx_array_init(UcxArray* array, size_t capacity, size_t elemsize) { - ucx_array_init_a(array, capacity, elemsize, ucx_default_allocator()); -} - -void ucx_array_init_a(UcxArray* array, size_t capacity, size_t elemsize, - UcxAllocator* allocator) { - - array->allocator = allocator; - array->elemsize = elemsize; - array->size = 0; - array->data = alcalloc(allocator, capacity, elemsize); - - if (array->data) { - array->capacity = capacity; - } else { - array->capacity = 0; - } -} - -int ucx_array_clone(UcxArray* dest, UcxArray const* src) { - if (ucx_array_ensurecap(dest, src->capacity)) { - return 1; - } - - dest->elemsize = src->elemsize; - dest->size = src->size; - - if (dest->data) { - memcpy(dest->data, src->data, src->size*src->elemsize); - } - - return 0; -} - -int ucx_array_equals(UcxArray const *array1, UcxArray const *array2, - cmp_func cmpfnc, void* data) { - - if (array1->size != array2->size || array1->elemsize != array2->elemsize) { - return 0; - } else { - if (array1->size == 0) - return 1; - - size_t elemsize; - if (cmpfnc == NULL) { - cmpfnc = ucx_cmp_mem; - elemsize = array1->elemsize; - data = &elemsize; - } - - for (size_t i = 0 ; i < array1->size ; i++) { - int r = cmpfnc( - ucx_array_at(array1, i), - ucx_array_at(array2, i), - data); - if (r != 0) - return 0; - } - return 1; - } -} - -void ucx_array_destroy(UcxArray *array) { - if(array->data) - alfree(array->allocator, array->data); - array->data = NULL; - array->capacity = array->size = 0; -} - -void ucx_array_free(UcxArray *array) { - ucx_array_destroy(array); - alfree(array->allocator, array); -} - -int ucx_array_append_from(UcxArray *array, void *data, size_t count) { - if (ucx_array_ensurecap(array, array->size + count)) - return 1; - - void* dest = ucx_array_at(array, array->size); - if (data) { - memcpy(dest, data, array->elemsize*count); - } else { - memset(dest, 0, array->elemsize*count); - } - array->size += count; - - return 0; -} - -int ucx_array_prepend_from(UcxArray *array, void *data, size_t count) { - if (ucx_array_ensurecap(array, array->size + count)) - return 1; - - if (array->size > 0) { - void *dest = ucx_array_at(array, count); - memmove(dest, array->data, array->elemsize*array->size); - } - - if (data) { - memcpy(array->data, data, array->elemsize*count); - } else { - memset(array->data, 0, array->elemsize*count); - } - array->size += count; - - return 0; -} - -int ucx_array_set_from(UcxArray *array, size_t index, - void *data, size_t count) { - if (ucx_array_ensurecap(array, index + count)) - return 1; - - if (index+count > array->size) { - array->size = index+count; - } - - void *dest = ucx_array_at(array, index); - if (data) { - memcpy(dest, data, array->elemsize*count); - } else { - memset(dest, 0, array->elemsize*count); - } - - return 0; -} - -int ucx_array_concat(UcxArray *array1, const UcxArray *array2) { - - if (array1->elemsize != array2->elemsize) - return 1; - - size_t capacity = array1->capacity+array2->capacity; - - if (array1->capacity < capacity) { - if (ucx_array_reserve(array1, capacity)) { - return 1; - } - } - - void* dest = ucx_array_at(array1, array1->size); - memcpy(dest, array2->data, array2->size*array2->elemsize); - - array1->size += array2->size; - - return 0; -} - -void *ucx_array_at(UcxArray const *array, size_t index) { - char* memory = array->data; - char* loc = memory + index*array->elemsize; - return loc; -} - -size_t ucx_array_find(UcxArray const *array, void *elem, - cmp_func cmpfnc, void *data) { - - size_t elemsize; - if (cmpfnc == NULL) { - cmpfnc = ucx_cmp_mem; - elemsize = array->elemsize; - data = &elemsize; - } - - if (array->size > 0) { - for (size_t i = 0 ; i < array->size ; i++) { - void* ptr = ucx_array_at(array, i); - if (cmpfnc(ptr, elem, data) == 0) { - return i; - } - } - return array->size; - } else { - return 0; - } -} - -int ucx_array_contains(UcxArray const *array, void *elem, - cmp_func cmpfnc, void *data) { - return ucx_array_find(array, elem, cmpfnc, data) != array->size; -} - -static void ucx_mergesort_merge(void *arrdata,size_t elemsize, - cmp_func cmpfnc, void *data, - size_t start, size_t mid, size_t end) { - - char* array = arrdata; - - size_t rightstart = mid + 1; - - if (cmpfnc(array + mid*elemsize, - array + rightstart*elemsize, data) <= 0) { - /* already sorted */ - return; - } - - /* we need memory for one element */ - void *value = malloc(elemsize); - - while (start <= mid && rightstart <= end) { - if (cmpfnc(array + start*elemsize, - array + rightstart*elemsize, data) <= 0) { - start++; - } else { - /* save the value from the right */ - memcpy(value, array + rightstart*elemsize, elemsize); - - /* shift all left elements one element to the right */ - size_t shiftcount = rightstart-start; - void *startptr = array + start*elemsize; - void *dest = array + (start+1)*elemsize; - memmove(dest, startptr, shiftcount*elemsize); - - /* bring the first value from the right to the left */ - memcpy(startptr, value, elemsize); - - start++; - mid++; - rightstart++; - } - } - - /* free the temporary memory */ - free(value); -} - -static void ucx_mergesort_impl(void *arrdata, size_t elemsize, - cmp_func cmpfnc, void *data, size_t l, size_t r) { - if (l < r) { - size_t m = l + (r - l) / 2; - - ucx_mergesort_impl(arrdata, elemsize, cmpfnc, data, l, m); - ucx_mergesort_impl(arrdata, elemsize, cmpfnc, data, m + 1, r); - ucx_mergesort_merge(arrdata, elemsize, cmpfnc, data, l, m, r); - } -} - -static void ucx_mergesort(void *arrdata, size_t count, size_t elemsize, - cmp_func cmpfnc, void *data) { - - ucx_mergesort_impl(arrdata, elemsize, cmpfnc, data, 0, count-1); -} - -#ifdef USE_UCX_QSORT_R -struct cmpfnc_swapargs_info { - cmp_func func; - void *data; -}; - -static int cmp_func_swap_args(void *data, const void *x, const void *y) { - struct cmpfnc_swapargs_info* info = data; - return info->func(x, y, info->data); -} - -static void ucx_qsort_r(void *array, size_t count, size_t elemsize, - cmp_func cmpfnc, void *data) { - struct cmpfnc_swapargs_info info; - info.func = cmpfnc; - info.data = data; - qsort_r(array, count, elemsize, &info, cmp_func_swap_args); -} -#endif /* USE_UCX_QSORT_R */ - -void ucx_array_sort(UcxArray* array, cmp_func cmpfnc, void *data) { - ucx_array_sort_impl(array->data, array->size, array->elemsize, - cmpfnc, data); -} - -void ucx_array_remove(UcxArray *array, size_t index) { - array->size--; - if (index < array->size) { - void* dest = ucx_array_at(array, index); - void* src = ucx_array_at(array, index+1); - memmove(dest, src, (array->size - index)*array->elemsize); - } -} - -void ucx_array_remove_fast(UcxArray *array, size_t index) { - array->size--; - if (index < array->size) { - void* dest = ucx_array_at(array, index); - void* src = ucx_array_at(array, array->size); - memcpy(dest, src, array->elemsize); - } -} - -int ucx_array_shrink(UcxArray* array) { - void* newptr = alrealloc(array->allocator, array->data, - array->size*array->elemsize); - if (newptr) { - array->data = newptr; - array->capacity = array->size; - return 0; - } else { - return 1; - } -} - -int ucx_array_resize(UcxArray* array, size_t capacity) { - if (array->capacity >= capacity) { - void* newptr = alrealloc(array->allocator, array->data, - capacity*array->elemsize); - if (newptr) { - array->data = newptr; - array->capacity = capacity; - if (array->size > array->capacity) { - array->size = array->capacity; - } - return 0; - } else { - return 1; - } - } else { - return ucx_array_reserve(array, capacity); - } -} - -int ucx_array_reserve(UcxArray* array, size_t capacity) { - if (array->capacity > capacity) { - return 0; - } else { - void* newptr = alrealloc(array->allocator, array->data, - capacity*array->elemsize); - if (newptr) { - array->data = newptr; - array->capacity = capacity; - return 0; - } else { - return 1; - } - } -} - -int ucx_array_grow(UcxArray* array, size_t count) { - return ucx_array_reserve(array, array->size+count); -} diff -r 92e482410453 -r d345541018fa src/avl.c --- a/src/avl.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,373 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/avl.h" - -#include - -#define ptrcast(ptr) ((void*)(ptr)) -#define alloc_tree(al) (UcxAVLTree*) almalloc((al), sizeof(UcxAVLTree)) -#define alloc_node(al) (UcxAVLNode*) almalloc((al), sizeof(UcxAVLNode)) - -static void ucx_avl_connect(UcxAVLTree *tree, - UcxAVLNode *node, UcxAVLNode *child, intptr_t nullkey) { - if (child) { - child->parent = node; - } - // if child is NULL, nullkey decides if left or right pointer is cleared - if (tree->cmpfunc( - ptrcast(child ? child->key : nullkey), - ptrcast(node->key), tree->userdata) > 0) { - node->right = child; - } else { - node->left = child; - } - size_t lh = node->left ? node->left->height : 0; - size_t rh = node->right ? node->right->height : 0; - node->height = 1 + (lh > rh ? lh : rh); -} - -#define avlheight(node) ((node) ? (node)->height : 0) - -static UcxAVLNode* avl_rotright(UcxAVLTree *tree, UcxAVLNode *l0) { - UcxAVLNode *p = l0->parent; - UcxAVLNode *l1 = l0->left; - if (p) { - ucx_avl_connect(tree, p, l1, 0); - } else { - l1->parent = NULL; - } - ucx_avl_connect(tree, l0, l1->right, l1->key); - ucx_avl_connect(tree, l1, l0, 0); - return l1; -} - -static UcxAVLNode* avl_rotleft(UcxAVLTree *tree, UcxAVLNode *l0) { - UcxAVLNode *p = l0->parent; - UcxAVLNode *l1 = l0->right; - if (p) { - ucx_avl_connect(tree, p, l1, 0); - } else { - l1->parent = NULL; - } - ucx_avl_connect(tree, l0, l1->left, l1->key); - ucx_avl_connect(tree, l1, l0, 0); - return l1; -} - -static void ucx_avl_balance(UcxAVLTree *tree, UcxAVLNode *n) { - int lh = avlheight(n->left); - int rh = avlheight(n->right); - n->height = 1 + (lh > rh ? lh : rh); - - if (lh - rh == 2) { - UcxAVLNode *c = n->left; - if (avlheight(c->right) - avlheight(c->left) == 1) { - avl_rotleft(tree, c); - } - n = avl_rotright(tree, n); - } else if (rh - lh == 2) { - UcxAVLNode *c = n->right; - if (avlheight(c->left) - avlheight(c->right) == 1) { - avl_rotright(tree, c); - } - n = avl_rotleft(tree, n); - } - - if (n->parent) { - ucx_avl_balance(tree, n->parent); - } else { - tree->root = n; - } -} - -UcxAVLTree *ucx_avl_new(cmp_func cmpfunc) { - return ucx_avl_new_a(cmpfunc, ucx_default_allocator()); -} - -UcxAVLTree *ucx_avl_new_a(cmp_func cmpfunc, UcxAllocator *allocator) { - UcxAVLTree* tree = alloc_tree(allocator); - if (tree) { - tree->allocator = allocator; - tree->cmpfunc = cmpfunc; - tree->root = NULL; - tree->userdata = NULL; - } - - return tree; -} - -static void ucx_avl_free_node(UcxAllocator *al, UcxAVLNode *node) { - if (node) { - ucx_avl_free_node(al, node->left); - ucx_avl_free_node(al, node->right); - alfree(al, node); - } -} - -void ucx_avl_free(UcxAVLTree *tree) { - UcxAllocator *al = tree->allocator; - ucx_avl_free_node(al, tree->root); - alfree(al, tree); -} - -static void ucx_avl_free_content_node(UcxAllocator *al, UcxAVLNode *node, - ucx_destructor destr) { - if (node) { - ucx_avl_free_content_node(al, node->left, destr); - ucx_avl_free_content_node(al, node->right, destr); - if (destr) { - destr(node->value); - } else { - alfree(al, node->value); - } - } -} - -void ucx_avl_free_content(UcxAVLTree *tree, ucx_destructor destr) { - ucx_avl_free_content_node(tree->allocator, tree->root, destr); -} - -UcxAVLNode *ucx_avl_get_node(UcxAVLTree *tree, intptr_t key) { - UcxAVLNode *n = tree->root; - int cmpresult; - while (n && (cmpresult = tree->cmpfunc( - ptrcast(key), ptrcast(n->key), tree->userdata))) { - n = cmpresult > 0 ? n->right : n->left; - } - return n; -} - -void *ucx_avl_get(UcxAVLTree *tree, intptr_t key) { - UcxAVLNode *n = ucx_avl_get_node(tree, key); - return n ? n->value : NULL; -} - -UcxAVLNode *ucx_avl_find_node(UcxAVLTree *tree, intptr_t key, - distance_func dfnc, int mode) { - UcxAVLNode *n = tree->root; - UcxAVLNode *closest = NULL; - - intmax_t cmpresult; - intmax_t closest_dist; - closest_dist = mode == UCX_AVL_FIND_LOWER_BOUNDED ? INTMAX_MIN : INTMAX_MAX; - - while (n && (cmpresult = dfnc( - ptrcast(key), ptrcast(n->key), tree->userdata))) { - if (mode == UCX_AVL_FIND_CLOSEST) { - intmax_t dist = cmpresult; - if (dist < 0) dist *= -1; - if (dist < closest_dist) { - closest_dist = dist; - closest = n; - } - } else if (mode == UCX_AVL_FIND_LOWER_BOUNDED && cmpresult <= 0) { - if (cmpresult > closest_dist) { - closest_dist = cmpresult; - closest = n; - } - } else if (mode == UCX_AVL_FIND_UPPER_BOUNDED && cmpresult >= 0) { - if (cmpresult < closest_dist) { - closest_dist = cmpresult; - closest = n; - } - } - n = cmpresult > 0 ? n->right : n->left; - } - return n ? n : closest; -} - -void *ucx_avl_find(UcxAVLTree *tree, intptr_t key, - distance_func dfnc, int mode) { - UcxAVLNode *n = ucx_avl_find_node(tree, key, dfnc, mode); - return n ? n->value : NULL; -} - -int ucx_avl_put(UcxAVLTree *tree, intptr_t key, void *value) { - return ucx_avl_put_s(tree, key, value, NULL); -} - -int ucx_avl_put_s(UcxAVLTree *tree, intptr_t key, void *value, - void **oldvalue) { - if (tree->root) { - UcxAVLNode *n = tree->root; - int cmpresult; - while ((cmpresult = tree->cmpfunc( - ptrcast(key), ptrcast(n->key), tree->userdata))) { - UcxAVLNode *m = cmpresult > 0 ? n->right : n->left; - if (m) { - n = m; - } else { - break; - } - } - - if (cmpresult) { - UcxAVLNode* e = alloc_node(tree->allocator); - if (e) { - e->key = key; e->value = value; e->height = 1; - e->parent = e->left = e->right = NULL; - ucx_avl_connect(tree, n, e, 0); - ucx_avl_balance(tree, n); - return 0; - } else { - return 1; - } - } else { - if (oldvalue) { - *oldvalue = n->value; - } - n->value = value; - return 0; - } - } else { - tree->root = alloc_node(tree->allocator); - if (tree->root) { - tree->root->key = key; tree->root->value = value; - tree->root->height = 1; - tree->root->parent = tree->root->left = tree->root->right = NULL; - - if (oldvalue) { - *oldvalue = NULL; - } - - return 0; - } else { - return 1; - } - } -} - -int ucx_avl_remove(UcxAVLTree *tree, intptr_t key) { - return ucx_avl_remove_s(tree, key, NULL, NULL); -} - -int ucx_avl_remove_node(UcxAVLTree *tree, UcxAVLNode *node) { - return ucx_avl_remove_s(tree, node->key, NULL, NULL); -} - -int ucx_avl_remove_s(UcxAVLTree *tree, intptr_t key, - intptr_t *oldkey, void **oldvalue) { - - UcxAVLNode *n = tree->root; - int cmpresult; - while (n && (cmpresult = tree->cmpfunc( - ptrcast(key), ptrcast(n->key), tree->userdata))) { - n = cmpresult > 0 ? n->right : n->left; - } - if (n) { - if (oldkey) { - *oldkey = n->key; - } - if (oldvalue) { - *oldvalue = n->value; - } - - UcxAVLNode *p = n->parent; - if (n->left && n->right) { - UcxAVLNode *s = n->right; - while (s->left) { - s = s->left; - } - ucx_avl_connect(tree, s->parent, s->right, s->key); - n->key = s->key; n->value = s->value; - p = s->parent; - alfree(tree->allocator, s); - } else { - if (p) { - ucx_avl_connect(tree, p, n->right ? n->right:n->left, n->key); - } else { - tree->root = n->right ? n->right : n->left; - if (tree->root) { - tree->root->parent = NULL; - } - } - alfree(tree->allocator, n); - } - - if (p) { - ucx_avl_balance(tree, p); - } - - return 0; - } else { - return 1; - } -} - -static size_t ucx_avl_countn(UcxAVLNode *node) { - if (node) { - return 1 + ucx_avl_countn(node->left) + ucx_avl_countn(node->right); - } else { - return 0; - } -} - -size_t ucx_avl_count(UcxAVLTree *tree) { - return ucx_avl_countn(tree->root); -} - -UcxAVLNode* ucx_avl_pred(UcxAVLNode* node) { - if (node->left) { - UcxAVLNode* n = node->left; - while (n->right) { - n = n->right; - } - return n; - } else { - UcxAVLNode* n = node; - while (n->parent) { - if (n->parent->right == n) { - return n->parent; - } else { - n = n->parent; - } - } - return NULL; - } -} - -UcxAVLNode* ucx_avl_succ(UcxAVLNode* node) { - if (node->right) { - UcxAVLNode* n = node->right; - while (n->left) { - n = n->left; - } - return n; - } else { - UcxAVLNode* n = node; - while (n->parent) { - if (n->parent->left == n) { - return n->parent; - } else { - n = n->parent; - } - } - return NULL; - } -} diff -r 92e482410453 -r d345541018fa src/buffer.c --- a/src/buffer.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,297 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/buffer.h" - -#include -#include -#include - -UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags) { - UcxBuffer *buffer = (UcxBuffer*) malloc(sizeof(UcxBuffer)); - if (buffer) { - buffer->flags = flags; - if (!space) { - buffer->space = (char*)malloc(capacity); - if (!buffer->space) { - free(buffer); - return NULL; - } - memset(buffer->space, 0, capacity); - buffer->flags |= UCX_BUFFER_AUTOFREE; - } else { - buffer->space = (char*)space; - } - buffer->capacity = capacity; - buffer->size = 0; - - buffer->pos = 0; - } - - return buffer; -} - -void ucx_buffer_free(UcxBuffer *buffer) { - if ((buffer->flags & UCX_BUFFER_AUTOFREE) == UCX_BUFFER_AUTOFREE) { - free(buffer->space); - } - free(buffer); -} - -UcxBuffer* ucx_buffer_extract( - UcxBuffer *src, size_t start, size_t length, int flags) { - if (src->size == 0 || length == 0 || - ((size_t)-1) - start < length || start+length > src->capacity) - { - return NULL; - } - - UcxBuffer *dst = (UcxBuffer*) malloc(sizeof(UcxBuffer)); - if (dst) { - dst->space = (char*)malloc(length); - if (!dst->space) { - free(dst); - return NULL; - } - dst->capacity = length; - dst->size = length; - dst->flags = flags | UCX_BUFFER_AUTOFREE; - dst->pos = 0; - memcpy(dst->space, src->space+start, length); - } - return dst; -} - -int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence) { - size_t npos; - switch (whence) { - case SEEK_CUR: - npos = buffer->pos; - break; - case SEEK_END: - npos = buffer->size; - break; - case SEEK_SET: - npos = 0; - break; - default: - return -1; - } - - size_t opos = npos; - npos += offset; - - if ((offset > 0 && npos < opos) || (offset < 0 && npos > opos)) { - return -1; - } - - if (npos >= buffer->size) { - return -1; - } else { - buffer->pos = npos; - return 0; - } - -} - -int ucx_buffer_eof(UcxBuffer *buffer) { - return buffer->pos >= buffer->size; -} - -int ucx_buffer_extend(UcxBuffer *buffer, size_t len) { - size_t newcap = buffer->capacity; - - if (buffer->capacity + len < buffer->capacity) { - return -1; - } - - while (buffer->capacity + len > newcap) { - newcap <<= 1; - if (newcap < buffer->capacity) { - return -1; - } - } - - char *newspace = (char*)realloc(buffer->space, newcap); - if (newspace) { - memset(newspace+buffer->size, 0, newcap-buffer->size); - buffer->space = newspace; - buffer->capacity = newcap; - } else { - return -1; - } - - return 0; -} - -size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems, - UcxBuffer *buffer) { - size_t len; - if(ucx_szmul(size, nitems, &len)) { - return 0; - } - size_t required = buffer->pos + len; - if (buffer->pos > required) { - return 0; - } - - if (required > buffer->capacity) { - if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) { - if (ucx_buffer_extend(buffer, required - buffer->capacity)) { - return 0; - } - } else { - len = buffer->capacity - buffer->pos; - if (size > 1) { - len -= len%size; - } - } - } - - if (len == 0) { - return len; - } - - memcpy(buffer->space + buffer->pos, ptr, len); - buffer->pos += len; - if(buffer->pos > buffer->size) { - buffer->size = buffer->pos; - } - - return len / size; -} - -size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems, - UcxBuffer *buffer) { - size_t len; - if(ucx_szmul(size, nitems, &len)) { - return 0; - } - if (buffer->pos + len > buffer->size) { - len = buffer->size - buffer->pos; - if (size > 1) len -= len%size; - } - - if (len <= 0) { - return len; - } - - memcpy(ptr, buffer->space + buffer->pos, len); - buffer->pos += len; - - return len / size; -} - -int ucx_buffer_putc(UcxBuffer *buffer, int c) { - if(buffer->pos >= buffer->capacity) { - if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) { - if(ucx_buffer_extend(buffer, 1)) { - return EOF; - } - } else { - return EOF; - } - } - - c &= 0xFF; - buffer->space[buffer->pos] = (char) c; - buffer->pos++; - if(buffer->pos > buffer->size) { - buffer->size = buffer->pos; - } - return c; -} - -int ucx_buffer_getc(UcxBuffer *buffer) { - if (ucx_buffer_eof(buffer)) { - return EOF; - } else { - int c = ((unsigned char*)buffer->space)[buffer->pos]; - buffer->pos++; - return c; - } -} - -size_t ucx_buffer_puts(UcxBuffer *buffer, const char *str) { - return ucx_buffer_write((const void*)str, 1, strlen(str), buffer); -} - -int ucx_buffer_shift_left(UcxBuffer* buffer, size_t shift) { - if (shift >= buffer->size) { - buffer->pos = buffer->size = 0; - } else { - memmove(buffer->space, buffer->space + shift, buffer->size - shift); - buffer->size -= shift; - - if (buffer->pos >= shift) { - buffer->pos -= shift; - } else { - buffer->pos = 0; - } - } - return 0; -} - -int ucx_buffer_shift_right(UcxBuffer* buffer, size_t shift) { - size_t req_capacity = buffer->size + shift; - size_t movebytes; - - // auto extend buffer, if required and enabled - if (buffer->capacity < req_capacity) { - if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) { - if (ucx_buffer_extend(buffer, req_capacity - buffer->capacity)) { - return 1; - } - movebytes = buffer->size; - } else { - movebytes = buffer->capacity - shift; - } - } else { - movebytes = buffer->size; - } - - memmove(buffer->space + shift, buffer->space, movebytes); - buffer->size = shift+movebytes; - - buffer->pos += shift; - if (buffer->pos > buffer->size) { - buffer->pos = buffer->size; - } - - return 0; -} - -int ucx_buffer_shift(UcxBuffer* buffer, off_t shift) { - if (shift < 0) { - return ucx_buffer_shift_left(buffer, (size_t) (-shift)); - } else if (shift > 0) { - return ucx_buffer_shift_right(buffer, (size_t) shift); - } else { - return 0; - } -} diff -r 92e482410453 -r d345541018fa src/cx/list.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cx/list.h Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,32 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef UCX_LIST_H +#define UCX_LIST_H + +#endif //UCX_LIST_H diff -r 92e482410453 -r d345541018fa src/list.c --- a/src/list.c Mon Dec 30 09:54:10 2019 +0100 +++ b/src/list.c Sat Feb 06 19:11:44 2021 +0100 @@ -1,7 +1,7 @@ /* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: @@ -26,403 +26,4 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "ucx/list.h" - -UcxList *ucx_list_clone(const UcxList *l, copy_func fnc, void *data) { - return ucx_list_clone_a(ucx_default_allocator(), l, fnc, data); -} - -UcxList *ucx_list_clone_a(UcxAllocator *alloc, const UcxList *l, - copy_func fnc, void *data) { - UcxList *ret = NULL; - while (l) { - if (fnc) { - ret = ucx_list_append_a(alloc, ret, fnc(l->data, data)); - } else { - ret = ucx_list_append_a(alloc, ret, l->data); - } - l = l->next; - } - return ret; -} - -int ucx_list_equals(const UcxList *l1, const UcxList *l2, - cmp_func fnc, void* data) { - if (l1 == l2) return 1; - - while (l1 != NULL && l2 != NULL) { - if (fnc == NULL) { - if (l1->data != l2->data) return 0; - } else { - if (fnc(l1->data, l2->data, data) != 0) return 0; - } - l1 = l1->next; - l2 = l2->next; - } - - return (l1 == NULL && l2 == NULL); -} - -void ucx_list_free(UcxList *l) { - ucx_list_free_a(ucx_default_allocator(), l); -} - -void ucx_list_free_a(UcxAllocator *alloc, UcxList *l) { - UcxList *e = l, *f; - while (e != NULL) { - f = e; - e = e->next; - alfree(alloc, f); - } -} - -void ucx_list_free_content(UcxList* list, ucx_destructor destr) { - if (!destr) destr = free; - while (list != NULL) { - destr(list->data); - list = list->next; - } -} - -UcxList *ucx_list_append(UcxList *l, void *data) { - return ucx_list_append_a(ucx_default_allocator(), l, data); -} - -UcxList *ucx_list_append_a(UcxAllocator *alloc, UcxList *l, void *data) { - UcxList *nl = (UcxList*) almalloc(alloc, sizeof(UcxList)); - if (!nl) { - return NULL; - } - - nl->data = data; - nl->next = NULL; - if (l) { - UcxList *t = ucx_list_last(l); - t->next = nl; - nl->prev = t; - return l; - } else { - nl->prev = NULL; - return nl; - } -} - -UcxList *ucx_list_prepend(UcxList *l, void *data) { - return ucx_list_prepend_a(ucx_default_allocator(), l, data); -} - -UcxList *ucx_list_prepend_a(UcxAllocator *alloc, UcxList *l, void *data) { - UcxList *nl = ucx_list_append_a(alloc, NULL, data); - if (!nl) { - return NULL; - } - l = ucx_list_first(l); - - if (l) { - nl->next = l; - l->prev = nl; - } - return nl; -} - -UcxList *ucx_list_concat(UcxList *l1, UcxList *l2) { - if (l1) { - UcxList *last = ucx_list_last(l1); - last->next = l2; - if (l2) { - l2->prev = last; - } - return l1; - } else { - return l2; - } -} - -UcxList *ucx_list_last(const UcxList *l) { - if (l == NULL) return NULL; - - const UcxList *e = l; - while (e->next != NULL) { - e = e->next; - } - return (UcxList*)e; -} - -ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem) { - ssize_t index = 0; - while (list) { - if (list == elem) { - return index; - } - list = list->next; - index++; - } - return -1; -} - -UcxList *ucx_list_get(const UcxList *l, size_t index) { - if (l == NULL) return NULL; - - const UcxList *e = l; - while (e->next && index > 0) { - e = e->next; - index--; - } - - return (UcxList*)(index == 0 ? e : NULL); -} - -ssize_t ucx_list_find(const UcxList *l, void *elem, - cmp_func fnc, void *cmpdata) { - ssize_t index = 0; - UCX_FOREACH(e, l) { - if (fnc) { - if (fnc(elem, e->data, cmpdata) == 0) { - return index; - } - } else { - if (elem == e->data) { - return index; - } - } - index++; - } - return -1; -} - -int ucx_list_contains(const UcxList *l, void *elem, - cmp_func fnc, void *cmpdata) { - return ucx_list_find(l, elem, fnc, cmpdata) > -1; -} - -size_t ucx_list_size(const UcxList *l) { - if (l == NULL) return 0; - - const UcxList *e = l; - size_t s = 1; - while (e->next != NULL) { - e = e->next; - s++; - } - - return s; -} - -static UcxList *ucx_list_sort_merge(size_t length, - UcxList* ls, UcxList* le, UcxList* re, - cmp_func fnc, void* data) { - - UcxList** sorted = (UcxList**) malloc(sizeof(UcxList*)*length); - UcxList *rc, *lc; - - lc = ls; rc = le; - size_t n = 0; - while (lc && lc != le && rc != re) { - if (fnc(lc->data, rc->data, data) <= 0) { - sorted[n] = lc; - lc = lc->next; - } else { - sorted[n] = rc; - rc = rc->next; - } - n++; - } - while (lc && lc != le) { - sorted[n] = lc; - lc = lc->next; - n++; - } - while (rc && rc != re) { - sorted[n] = rc; - rc = rc->next; - n++; - } - - // Update pointer - sorted[0]->prev = NULL; - for (int i = 0 ; i < length-1 ; i++) { - sorted[i]->next = sorted[i+1]; - sorted[i+1]->prev = sorted[i]; - } - sorted[length-1]->next = NULL; - - UcxList *ret = sorted[0]; - free(sorted); - return ret; -} - -UcxList *ucx_list_sort(UcxList *l, cmp_func fnc, void *data) { - if (l == NULL) { - return NULL; - } - - UcxList *lc; - size_t ln = 1; - - UcxList *ls = l, *le, *re; - - // check how many elements are already sorted - lc = ls; - while (lc->next != NULL && fnc(lc->next->data, lc->data, data) > 0) { - lc = lc->next; - ln++; - } - le = lc->next; - - if (le == NULL) { - return l; // this list is already sorted :) - } else { - UcxList *rc; - size_t rn = 1; - rc = le; - // skip already sorted elements - while (rc->next != NULL && fnc(rc->next->data, rc->data, data) > 0) { - rc = rc->next; - rn++; - } - re = rc->next; - - // {ls,...,le->prev} and {rs,...,re->prev} are sorted - merge them - UcxList *sorted = ucx_list_sort_merge(ln+rn, - ls, le, re, - fnc, data); - - // Something left? Sort it! - size_t remainder_length = ucx_list_size(re); - if (remainder_length > 0) { - UcxList *remainder = ucx_list_sort(re, fnc, data); - - // merge sorted list with (also sorted) remainder - l = ucx_list_sort_merge(ln+rn+remainder_length, - sorted, remainder, NULL, fnc, data); - } else { - // no remainder - we've got our sorted list - l = sorted; - } - - return l; - } -} - -UcxList *ucx_list_first(const UcxList *l) { - if (!l) { - return NULL; - } - - const UcxList *e = l; - while (e->prev) { - e = e->prev; - } - return (UcxList *)e; -} - -UcxList *ucx_list_remove(UcxList *l, UcxList *e) { - return ucx_list_remove_a(ucx_default_allocator(), l, e); -} - -UcxList *ucx_list_remove_a(UcxAllocator *alloc, UcxList *l, UcxList *e) { - if (l == e) { - l = e->next; - } - - if (e->next) { - e->next->prev = e->prev; - } - - if (e->prev) { - e->prev->next = e->next; - } - - alfree(alloc, e); - return l; -} - - -static UcxList* ucx_list_setoperation_a(UcxAllocator *allocator, - UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata, - int op) { - - UcxList *res = NULL; - UcxList *cur = NULL; - const UcxList *src = left; - - do { - UCX_FOREACH(node, src) { - void* elem = node->data; - if ( - (op == 0 && !ucx_list_contains(res, elem, cmpfnc, cmpdata)) || - (op == 1 && ucx_list_contains(right, elem, cmpfnc, cmpdata)) || - (op == 2 && !ucx_list_contains(right, elem, cmpfnc, cmpdata))) { - UcxList *nl = almalloc(allocator, sizeof(UcxList)); - nl->prev = cur; - nl->next = NULL; - if (cpfnc) { - nl->data = cpfnc(elem, cpdata); - } else { - nl->data = elem; - } - if (cur != NULL) - cur->next = nl; - cur = nl; - if (res == NULL) - res = cur; - } - } - if (op == 0 && src == left) - src = right; - else - src = NULL; - } while (src != NULL); - - return res; -} - -UcxList* ucx_list_union(UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - return ucx_list_union_a(ucx_default_allocator(), - left, right, cmpfnc, cmpdata, cpfnc, cpdata); -} - -UcxList* ucx_list_union_a(UcxAllocator *allocator, - UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - - return ucx_list_setoperation_a(allocator, left, right, - cmpfnc, cmpdata, cpfnc, cpdata, 0); -} - -UcxList* ucx_list_intersection(UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - return ucx_list_intersection_a(ucx_default_allocator(), left, right, - cmpfnc, cmpdata, cpfnc, cpdata); -} - -UcxList* ucx_list_intersection_a(UcxAllocator *allocator, - UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - - return ucx_list_setoperation_a(allocator, left, right, - cmpfnc, cmpdata, cpfnc, cpdata, 1); -} - -UcxList* ucx_list_difference(UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - return ucx_list_difference_a(ucx_default_allocator(), left, right, - cmpfnc, cmpdata, cpfnc, cpdata); -} - -UcxList* ucx_list_difference_a(UcxAllocator *allocator, - UcxList const *left, UcxList const *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata) { - - return ucx_list_setoperation_a(allocator, left, right, - cmpfnc, cmpdata, cpfnc, cpdata, 2); -} +#include "cx/list.h" diff -r 92e482410453 -r d345541018fa src/logging.c --- a/src/logging.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,117 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/logging.h" - -#include -#include -#include -#include - -UcxLogger *ucx_logger_new(void *stream, unsigned int level, unsigned int mask) { - UcxLogger *logger = (UcxLogger*) malloc(sizeof(UcxLogger)); - if (logger != NULL) { - logger->stream = stream; - logger->writer = (write_func)fwrite; - logger->dateformat = (char*) "%F %T %z "; - logger->level = level; - logger->mask = mask; - logger->levels = ucx_map_new(8); - - unsigned int l; - l = UCX_LOGGER_ERROR; - ucx_map_int_put(logger->levels, l, (void*) "[ERROR]"); - l = UCX_LOGGER_WARN; - ucx_map_int_put(logger->levels, l, (void*) "[WARNING]"); - l = UCX_LOGGER_INFO; - ucx_map_int_put(logger->levels, l, (void*) "[INFO]"); - l = UCX_LOGGER_DEBUG; - ucx_map_int_put(logger->levels, l, (void*) "[DEBUG]"); - l = UCX_LOGGER_TRACE; - ucx_map_int_put(logger->levels, l, (void*) "[TRACE]"); - } - - return logger; -} - -void ucx_logger_free(UcxLogger *logger) { - ucx_map_free(logger->levels); - free(logger); -} - -// estimated max. message length (documented) -#define UCX_LOGGER_MSGMAX 4096 - -void ucx_logger_logf(UcxLogger *logger, unsigned int level, const char* file, - const unsigned int line, const char *format, ...) { - if (level <= logger->level) { - char msg[UCX_LOGGER_MSGMAX]; - const char *text; - size_t k = 0; - size_t n; - - if ((logger->mask & UCX_LOGGER_LEVEL) > 0) { - text = (const char*) ucx_map_int_get(logger->levels, level); - if (!text) { - text = "[UNKNOWN]"; - } - n = strlen(text); - n = n > 256 ? 256 : n; - memcpy(msg+k, text, n); - k += n; - msg[k++] = ' '; - } - if ((logger->mask & UCX_LOGGER_TIMESTAMP) > 0) { - time_t now = time(NULL); - k += strftime(msg+k, 128, logger->dateformat, localtime(&now)); - } - if ((logger->mask & UCX_LOGGER_SOURCE) > 0) { - char *fpart = strrchr(file, '/'); - if (fpart) file = fpart+1; - fpart = strrchr(file, '\\'); - if (fpart) file = fpart+1; - n = strlen(file); - memcpy(msg+k, file, n); - k += n; - k += sprintf(msg+k, ":%u ", line); - } - - if (k > 0) { - msg[k++] = '-'; msg[k++] = ' '; - } - - va_list args; - va_start (args, format); - k += vsnprintf(msg+k, UCX_LOGGER_MSGMAX-k-1, format, args); - va_end (args); - - msg[k++] = '\n'; - - logger->writer(msg, 1, k, logger->stream); - } -} diff -r 92e482410453 -r d345541018fa src/map.c --- a/src/map.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,402 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/map.h" - -#include -#include - -UcxMap *ucx_map_new(size_t size) { - return ucx_map_new_a(NULL, size); -} - -UcxMap *ucx_map_new_a(UcxAllocator *allocator, size_t size) { - if(size == 0) { - size = 16; - } - - if(!allocator) { - allocator = ucx_default_allocator(); - } - - UcxMap *map = (UcxMap*)almalloc(allocator, sizeof(UcxMap)); - if (!map) { - return NULL; - } - - map->allocator = allocator; - map->map = (UcxMapElement**)alcalloc( - allocator, size, sizeof(UcxMapElement*)); - if(map->map == NULL) { - alfree(allocator, map); - return NULL; - } - map->size = size; - map->count = 0; - - return map; -} - -static void ucx_map_free_elmlist_contents(UcxMap *map) { - for (size_t n = 0 ; n < map->size ; n++) { - UcxMapElement *elem = map->map[n]; - if (elem != NULL) { - do { - UcxMapElement *next = elem->next; - alfree(map->allocator, elem->key.data); - alfree(map->allocator, elem); - elem = next; - } while (elem != NULL); - } - } -} - -void ucx_map_free(UcxMap *map) { - ucx_map_free_elmlist_contents(map); - alfree(map->allocator, map->map); - alfree(map->allocator, map); -} - -void ucx_map_free_content(UcxMap *map, ucx_destructor destr) { - UcxMapIterator iter = ucx_map_iterator(map); - void *val; - UCX_MAP_FOREACH(key, val, iter) { - if (destr) { - destr(val); - } else { - alfree(map->allocator, val); - } - } -} - -void ucx_map_clear(UcxMap *map) { - if (map->count == 0) { - return; // nothing to do - } - ucx_map_free_elmlist_contents(map); - memset(map->map, 0, map->size*sizeof(UcxMapElement*)); - map->count = 0; -} - -int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data) { - UcxMapIterator i = ucx_map_iterator(from); - void *value; - UCX_MAP_FOREACH(key, value, i) { - if (ucx_map_put(to, key, fnc ? fnc(value, data) : value)) { - return 1; - } - } - return 0; -} - -UcxMap *ucx_map_clone(UcxMap const *map, copy_func fnc, void *data) { - return ucx_map_clone_a(ucx_default_allocator(), map, fnc, data); -} - -UcxMap *ucx_map_clone_a(UcxAllocator *allocator, - UcxMap const *map, copy_func fnc, void *data) { - size_t bs = (map->count * 5) >> 1; - UcxMap *newmap = ucx_map_new_a(allocator, bs > map->size ? bs : map->size); - if (!newmap) { - return NULL; - } - ucx_map_copy(map, newmap, fnc, data); - return newmap; -} - -int ucx_map_rehash(UcxMap *map) { - size_t load = (map->size * 3) >> 2; - if (map->count > load) { - UcxMap oldmap; - oldmap.map = map->map; - oldmap.size = map->size; - oldmap.count = map->count; - oldmap.allocator = map->allocator; - - map->size = (map->count * 5) >> 1; - map->map = (UcxMapElement**)alcalloc( - map->allocator, map->size, sizeof(UcxMapElement*)); - if (!map->map) { - *map = oldmap; - return 1; - } - map->count = 0; - ucx_map_copy(&oldmap, map, NULL, NULL); - - /* free the UcxMapElement list of oldmap */ - ucx_map_free_elmlist_contents(&oldmap); - alfree(map->allocator, oldmap.map); - } - return 0; -} - -int ucx_map_put(UcxMap *map, UcxKey key, void *data) { - UcxAllocator *allocator = map->allocator; - - if (key.hash == 0) { - key.hash = ucx_hash((const char*)key.data, key.len); - } - - struct UcxMapKey mapkey; - mapkey.hash = key.hash; - - size_t slot = mapkey.hash%map->size; - UcxMapElement *elm = map->map[slot]; - UcxMapElement *prev = NULL; - - while (elm && elm->key.hash < mapkey.hash) { - prev = elm; - elm = elm->next; - } - - if (!elm || elm->key.hash != mapkey.hash) { - UcxMapElement *e = (UcxMapElement*)almalloc( - allocator, sizeof(UcxMapElement)); - if (!e) { - return -1; - } - e->key.data = NULL; - if (prev) { - prev->next = e; - } else { - map->map[slot] = e; - } - e->next = elm; - elm = e; - } - - if (!elm->key.data) { - void *kd = almalloc(allocator, key.len); - if (!kd) { - return -1; - } - memcpy(kd, key.data, key.len); - mapkey.data = kd; - mapkey.len = key.len; - elm->key = mapkey; - map->count++; - } - elm->data = data; - - return 0; -} - -static void* ucx_map_get_and_remove(UcxMap *map, UcxKey key, int remove) { - if(key.hash == 0) { - key.hash = ucx_hash((const char*)key.data, key.len); - } - - size_t slot = key.hash%map->size; - UcxMapElement *elm = map->map[slot]; - UcxMapElement *pelm = NULL; - while (elm && elm->key.hash <= key.hash) { - if(elm->key.hash == key.hash) { - int n = (key.len > elm->key.len) ? elm->key.len : key.len; - if (memcmp(elm->key.data, key.data, n) == 0) { - void *data = elm->data; - if (remove) { - if (pelm) { - pelm->next = elm->next; - } else { - map->map[slot] = elm->next; - } - alfree(map->allocator, elm->key.data); - alfree(map->allocator, elm); - map->count--; - } - - return data; - } - } - pelm = elm; - elm = pelm->next; - } - - return NULL; -} - -void *ucx_map_get(UcxMap const *map, UcxKey key) { - return ucx_map_get_and_remove((UcxMap *)map, key, 0); -} - -void *ucx_map_remove(UcxMap *map, UcxKey key) { - return ucx_map_get_and_remove(map, key, 1); -} - -UcxKey ucx_key(const void *data, size_t len) { - UcxKey key; - key.data = data; - key.len = len; - key.hash = ucx_hash((const char*)data, len); - return key; -} - - -int ucx_hash(const char *data, size_t len) { - /* murmur hash 2 */ - - int m = 0x5bd1e995; - int r = 24; - - int h = 25 ^ len; - - int i = 0; - while (len >= 4) { - int k = data[i + 0] & 0xFF; - k |= (data[i + 1] & 0xFF) << 8; - k |= (data[i + 2] & 0xFF) << 16; - k |= (data[i + 3] & 0xFF) << 24; - - k *= m; - k ^= k >> r; - k *= m; - - h *= m; - h ^= k; - - i += 4; - len -= 4; - } - - switch (len) { - case 3: h ^= (data[i + 2] & 0xFF) << 16; - /* no break */ - case 2: h ^= (data[i + 1] & 0xFF) << 8; - /* no break */ - case 1: h ^= (data[i + 0] & 0xFF); h *= m; - /* no break */ - } - - h ^= h >> 13; - h *= m; - h ^= h >> 15; - - return h; -} - -UcxMapIterator ucx_map_iterator(UcxMap const *map) { - UcxMapIterator i; - i.map = map; - i.cur = NULL; - i.index = 0; - return i; -} - -int ucx_map_iter_next(UcxMapIterator *i, UcxKey *key, void **elm) { - UcxMapElement *e = i->cur; - - if (e) { - e = e->next; - } else { - e = i->map->map[0]; - } - - while (i->index < i->map->size) { - if (e) { - if (e->data) { - i->cur = e; - *elm = e->data; - key->data = e->key.data; - key->hash = e->key.hash; - key->len = e->key.len; - return 1; - } - - e = e->next; - } else { - i->index++; - - if (i->index < i->map->size) { - e = i->map->map[i->index]; - } - } - } - - return 0; -} - -UcxMap* ucx_map_union(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - return ucx_map_union_a(ucx_default_allocator(), - first, second, cpfnc, cpdata); -} - -UcxMap* ucx_map_union_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - UcxMap* result = ucx_map_clone_a(allocator, first, cpfnc, cpdata); - ucx_map_copy(second, result, cpfnc, cpdata); - return result; -} - -UcxMap* ucx_map_intersection(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - return ucx_map_intersection_a(ucx_default_allocator(), - first, second, cpfnc, cpdata); -} - -UcxMap* ucx_map_intersection_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - UcxMap *result = ucx_map_new_a(allocator, first->size < second->size ? - first->size : second->size); - - UcxMapIterator iter = ucx_map_iterator(first); - void* value; - UCX_MAP_FOREACH(key, value, iter) { - if (ucx_map_get(second, key)) { - ucx_map_put(result, key, cpfnc ? cpfnc(value, cpdata) : value); - } - } - - return result; -} - -UcxMap* ucx_map_difference(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - return ucx_map_difference_a(ucx_default_allocator(), - first, second, cpfnc, cpdata); -} - -UcxMap* ucx_map_difference_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata) { - - UcxMap *result = ucx_map_new_a(allocator, first->size - second->count); - - UcxMapIterator iter = ucx_map_iterator(first); - void* value; - UCX_MAP_FOREACH(key, value, iter) { - if (!ucx_map_get(second, key)) { - ucx_map_put(result, key, cpfnc ? cpfnc(value, cpdata) : value); - } - } - - ucx_map_rehash(result); - return result; -} \ No newline at end of file diff -r 92e482410453 -r d345541018fa src/mempool.c --- a/src/mempool.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,237 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/mempool.h" - -#include -#include -#include -#ifdef __cplusplus -#define __STDC_FORMAT_MACROS -#endif -#include - -/** Capsule for destructible memory chunks. */ -typedef struct { - /** The destructor for the memory chunk. */ - ucx_destructor destructor; - /** - * First byte of the memory chunk. - * Note, that the address &c is also the address - * of the whole memory chunk. - */ - char c; -} ucx_memchunk; - -/** Capsule for data and its destructor. */ -typedef struct { - /** The destructor for the data. */ - ucx_destructor destructor; - /** A pointer to the data. */ - void *ptr; -} ucx_regdestr; - -#ifdef __cplusplus -extern "C" -#endif -void ucx_mempool_shared_destr(void* ptr) { - ucx_regdestr *rd = (ucx_regdestr*)ptr; - rd->destructor(rd->ptr); -} - -UcxMempool *ucx_mempool_new(size_t n) { - size_t poolsz; - if(ucx_szmul(n, sizeof(void*), &poolsz)) { - return NULL; - } - - UcxMempool *pool = (UcxMempool*)malloc(sizeof(UcxMempool)); - if (!pool) { - return NULL; - } - - pool->data = (void**) malloc(poolsz); - if (pool->data == NULL) { - free(pool); - return NULL; - } - - pool->ndata = 0; - pool->size = n; - - UcxAllocator *allocator = (UcxAllocator*)malloc(sizeof(UcxAllocator)); - if(!allocator) { - free(pool->data); - free(pool); - return NULL; - } - allocator->malloc = (ucx_allocator_malloc)ucx_mempool_malloc; - allocator->calloc = (ucx_allocator_calloc)ucx_mempool_calloc; - allocator->realloc = (ucx_allocator_realloc)ucx_mempool_realloc; - allocator->free = (ucx_allocator_free)ucx_mempool_free; - allocator->pool = pool; - pool->allocator = allocator; - - return pool; -} - -int ucx_mempool_chcap(UcxMempool *pool, size_t newcap) { - if (newcap < pool->ndata) { - return 1; - } - - size_t newcapsz; - if(ucx_szmul(newcap, sizeof(void*), &newcapsz)) { - return 1; - } - - void **data = (void**) realloc(pool->data, newcapsz); - if (data) { - pool->data = data; - pool->size = newcap; - return 0; - } else { - return 1; - } -} - -void *ucx_mempool_malloc(UcxMempool *pool, size_t n) { - if(((size_t)-1) - sizeof(ucx_destructor) < n) { - return NULL; - } - - if (pool->ndata >= pool->size) { - size_t newcap = pool->size*2; - if (newcap < pool->size || ucx_mempool_chcap(pool, newcap)) { - return NULL; - } - } - - void *p = malloc(sizeof(ucx_destructor) + n); - ucx_memchunk *mem = (ucx_memchunk*)p; - if (!mem) { - return NULL; - } - - mem->destructor = NULL; - pool->data[pool->ndata] = mem; - pool->ndata++; - - return &(mem->c); -} - -void *ucx_mempool_calloc(UcxMempool *pool, size_t nelem, size_t elsize) { - size_t msz; - if(ucx_szmul(nelem, elsize, &msz)) { - return NULL; - } - - void *ptr = ucx_mempool_malloc(pool, msz); - if (!ptr) { - return NULL; - } - memset(ptr, 0, nelem * elsize); - return ptr; -} - -void *ucx_mempool_realloc(UcxMempool *pool, void *ptr, size_t n) { - if(((size_t)-1) - sizeof(ucx_destructor) < n) { - return NULL; - } - - char *mem = ((char*)ptr) - sizeof(ucx_destructor); - char *newm = (char*) realloc(mem, n + sizeof(ucx_destructor)); - if (!newm) { - return NULL; - } - if (mem != newm) { - for(size_t i=0 ; i < pool->ndata ; i++) { - if(pool->data[i] == mem) { - pool->data[i] = newm; - return newm + sizeof(ucx_destructor); - } - } - fprintf(stderr, "FATAL: 0x%08" PRIxPTR" not in mpool 0x%08" PRIxPTR"\n", - (intptr_t)ptr, (intptr_t)pool); - abort(); - } else { - return newm + sizeof(ucx_destructor); - } -} - -void ucx_mempool_free(UcxMempool *pool, void *ptr) { - ucx_memchunk *chunk = (ucx_memchunk*)((char*)ptr-sizeof(ucx_destructor)); - for(size_t i=0 ; indata ; i++) { - if(chunk == pool->data[i]) { - if(chunk->destructor != NULL) { - chunk->destructor(&(chunk->c)); - } - free(chunk); - size_t last_index = pool->ndata - 1; - if(i != last_index) { - pool->data[i] = pool->data[last_index]; - pool->data[last_index] = NULL; - } - pool->ndata--; - return; - } - } - fprintf(stderr, "FATAL: 0x%08" PRIxPTR" not in mpool 0x%08" PRIxPTR"\n", - (intptr_t)ptr, (intptr_t)pool); - abort(); -} - -void ucx_mempool_destroy(UcxMempool *pool) { - ucx_memchunk *chunk; - for(size_t i=0 ; indata ; i++) { - chunk = (ucx_memchunk*) pool->data[i]; - if(chunk) { - if(chunk->destructor) { - chunk->destructor(&(chunk->c)); - } - free(chunk); - } - } - free(pool->data); - free(pool->allocator); - free(pool); -} - -void ucx_mempool_set_destr(void *ptr, ucx_destructor func) { - *(ucx_destructor*)((char*)ptr-sizeof(ucx_destructor)) = func; -} - -void ucx_mempool_reg_destr(UcxMempool *pool, void *ptr, ucx_destructor destr) { - ucx_regdestr *rd = (ucx_regdestr*)ucx_mempool_malloc( - pool, - sizeof(ucx_regdestr)); - rd->destructor = destr; - rd->ptr = ptr; - ucx_mempool_set_destr(rd, ucx_mempool_shared_destr); -} - diff -r 92e482410453 -r d345541018fa src/properties.c --- a/src/properties.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,264 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/properties.h" - -#include -#include -#include - -UcxProperties *ucx_properties_new() { - UcxProperties *parser = (UcxProperties*)malloc( - sizeof(UcxProperties)); - if(!parser) { - return NULL; - } - - parser->buffer = NULL; - parser->buflen = 0; - parser->pos = 0; - parser->tmp = NULL; - parser->tmplen = 0; - parser->tmpcap = 0; - parser->error = 0; - parser->delimiter = '='; - parser->comment1 = '#'; - parser->comment2 = 0; - parser->comment3 = 0; - - return parser; -} - -void ucx_properties_free(UcxProperties *parser) { - if(parser->tmp) { - free(parser->tmp); - } - free(parser); -} - -void ucx_properties_fill(UcxProperties *parser, char *buf, size_t len) { - parser->buffer = buf; - parser->buflen = len; - parser->pos = 0; -} - -static void parser_tmp_append(UcxProperties *parser, char *buf, size_t len) { - if(parser->tmpcap - parser->tmplen < len) { - size_t newcap = parser->tmpcap + len + 64; - parser->tmp = (char*)realloc(parser->tmp, newcap); - parser->tmpcap = newcap; - } - memcpy(parser->tmp + parser->tmplen, buf, len); - parser->tmplen += len; -} - -int ucx_properties_next(UcxProperties *parser, sstr_t *name, sstr_t *value) { - if(parser->tmplen > 0) { - char *buf = parser->buffer + parser->pos; - size_t len = parser->buflen - parser->pos; - sstr_t str = sstrn(buf, len); - sstr_t nl = sstrchr(str, '\n'); - if(nl.ptr) { - size_t newlen = (size_t)(nl.ptr - buf) + 1; - parser_tmp_append(parser, buf, newlen); - // the tmp buffer contains exactly one line now - - char *orig_buf = parser->buffer; - size_t orig_len = parser->buflen; - - parser->buffer = parser->tmp; - parser->buflen = parser->tmplen; - parser->pos = 0; - parser->tmp = NULL; - parser->tmpcap = 0; - parser->tmplen = 0; - // run ucx_properties_next with the tmp buffer as main buffer - int ret = ucx_properties_next(parser, name, value); - - // restore original buffer - parser->tmp = parser->buffer; - parser->buffer = orig_buf; - parser->buflen = orig_len; - parser->pos = newlen; - - /* - * if ret == 0 the tmp buffer contained just space or a comment - * we parse again with the original buffer to get a name/value - * or a new tmp buffer - */ - return ret ? ret : ucx_properties_next(parser, name, value); - } else { - parser_tmp_append(parser, buf, len); - return 0; - } - } else if(parser->tmp) { - free(parser->tmp); - parser->tmp = NULL; - } - - char comment1 = parser->comment1; - char comment2 = parser->comment2; - char comment3 = parser->comment3; - char delimiter = parser->delimiter; - - // get one line and parse it - while(parser->pos < parser->buflen) { - char *buf = parser->buffer + parser->pos; - size_t len = parser->buflen - parser->pos; - - /* - * First we check if we have at least one line. We also get indices of - * delimiter and comment chars - */ - size_t delimiter_index = 0; - size_t comment_index = 0; - int has_comment = 0; - - size_t i = 0; - char c = 0; - for(;itmpcap = len + 128; - parser->tmp = (char*)malloc(parser->tmpcap); - parser->tmplen = len; - memcpy(parser->tmp, buf, len); - return 0; - } - - sstr_t line = has_comment ? sstrn(buf, comment_index) : sstrn(buf, i); - // check line - if(delimiter_index == 0) { - line = sstrtrim(line); - if(line.length != 0) { - parser->error = 1; - } - } else { - sstr_t n = sstrn(buf, delimiter_index); - sstr_t v = sstrn( - buf + delimiter_index + 1, - line.length - delimiter_index - 1); - n = sstrtrim(n); - v = sstrtrim(v); - if(n.length != 0 || v.length != 0) { - *name = n; - *value = v; - parser->pos += i + 1; - return 1; - } else { - parser->error = 1; - } - } - - parser->pos += i + 1; - } - - return 0; -} - -int ucx_properties2map(UcxProperties *parser, UcxMap *map) { - sstr_t name; - sstr_t value; - while(ucx_properties_next(parser, &name, &value)) { - value = sstrdup_a(map->allocator, value); - if(!value.ptr) { - return 1; - } - if(ucx_map_sstr_put(map, name, value.ptr)) { - alfree(map->allocator, value.ptr); - return 1; - } - } - if (parser->error) { - return parser->error; - } else { - return 0; - } -} - -// buffer size is documented - change doc, when you change bufsize! -#define UCX_PROPLOAD_BUFSIZE 1024 -int ucx_properties_load(UcxMap *map, FILE *file) { - UcxProperties *parser = ucx_properties_new(); - if(!(parser && map && file)) { - return 1; - } - - int error = 0; - size_t r; - char buf[UCX_PROPLOAD_BUFSIZE]; - while((r = fread(buf, 1, UCX_PROPLOAD_BUFSIZE, file)) != 0) { - ucx_properties_fill(parser, buf, r); - error = ucx_properties2map(parser, map); - if (error) { - break; - } - } - ucx_properties_free(parser); - return error; -} - -int ucx_properties_store(UcxMap *map, FILE *file) { - UcxMapIterator iter = ucx_map_iterator(map); - void *v; - sstr_t value; - size_t written; - - UCX_MAP_FOREACH(k, v, iter) { - value = sstr((char*)v); - - written = 0; - written += fwrite(k.data, 1, k.len, file); - written += fwrite(" = ", 1, 3, file); - written += fwrite(value.ptr, 1, value.length, file); - written += fwrite("\n", 1, 1, file); - - if (written != k.len + value.length + 4) { - return 1; - } - } - - return 0; -} - diff -r 92e482410453 -r d345541018fa src/stack.c --- a/src/stack.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,165 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/stack.h" - -#include - -static size_t ucx_stack_align(size_t n) { - int align = n % sizeof(void*); - if (align) { - n += sizeof(void*) - align; - } - return n; -} - -void ucx_stack_init(UcxStack *stack, char* space, size_t size) { - stack->size = size - size % sizeof(void*); - stack->space = space; - stack->top = NULL; - - stack->allocator.pool = stack; - stack->allocator.malloc = (ucx_allocator_malloc) ucx_stack_malloc; - stack->allocator.calloc = (ucx_allocator_calloc) ucx_stack_calloc; - stack->allocator.realloc = (ucx_allocator_realloc) ucx_stack_realloc; - stack->allocator.free = (ucx_allocator_free) ucx_stack_free; -} - -void *ucx_stack_malloc(UcxStack *stack, size_t n) { - - if (ucx_stack_avail(stack) < ucx_stack_align(n)) { - return NULL; - } else { - char *prev = stack->top; - if (stack->top) { - stack->top += ucx_stack_align(ucx_stack_topsize(stack)); - } else { - stack->top = stack->space; - } - - ((struct ucx_stack_metadata*)stack->top)->prev = prev; - ((struct ucx_stack_metadata*)stack->top)->size = n; - stack->top += sizeof(struct ucx_stack_metadata); - - return stack->top; - } -} - -void *ucx_stack_calloc(UcxStack *stack, size_t nelem, size_t elsize) { - void *mem = ucx_stack_malloc(stack, nelem*elsize); - memset(mem, 0, nelem*elsize); - return mem; -} - -void *ucx_stack_realloc(UcxStack *stack, void *ptr, size_t n) { - if (ptr == stack->top) { - if (stack->size - (stack->top - stack->space) < ucx_stack_align(n)) { - return NULL; - } else { - ((struct ucx_stack_metadata*)stack->top - 1)->size = n; - return ptr; - } - } else { - if (ucx_stack_align(((struct ucx_stack_metadata*)ptr - 1)->size) < - ucx_stack_align(n)) { - void *nptr = ucx_stack_malloc(stack, n); - if (nptr) { - memcpy(nptr, ptr, n); - ucx_stack_free(stack, ptr); - - return nptr; - } else { - return NULL; - } - } else { - ((struct ucx_stack_metadata*)ptr - 1)->size = n; - return ptr; - } - } -} - -void ucx_stack_free(UcxStack *stack, void *ptr) { - if (ptr == stack->top) { - stack->top = ((struct ucx_stack_metadata*) stack->top - 1)->prev; - } else { - struct ucx_stack_metadata *next = (struct ucx_stack_metadata*)( - (char*)ptr + - ucx_stack_align(((struct ucx_stack_metadata*) ptr - 1)->size) - ); - next->prev = ((struct ucx_stack_metadata*) ptr - 1)->prev; - } -} - -void ucx_stack_popn(UcxStack *stack, void *dest, size_t n) { - if (ucx_stack_empty(stack)) { - return; - } - - if (dest) { - size_t len = ucx_stack_topsize(stack); - if (len > n) { - len = n; - } - - memcpy(dest, stack->top, len); - } - - ucx_stack_free(stack, stack->top); -} - -size_t ucx_stack_avail(UcxStack *stack) { - size_t avail = ((stack->top ? (stack->size - - (stack->top - stack->space) - - ucx_stack_align(ucx_stack_topsize(stack))) - : stack->size)); - - if (avail > sizeof(struct ucx_stack_metadata)) { - return avail - sizeof(struct ucx_stack_metadata); - } else { - return 0; - } -} - -void *ucx_stack_push(UcxStack *stack, size_t n, const void *data) { - void *space = ucx_stack_malloc(stack, n); - if (space) { - memcpy(space, data, n); - } - return space; -} - -void *ucx_stack_pusharr(UcxStack *stack, - size_t nelem, size_t elsize, const void *data) { - - // skip the memset by using malloc - void *space = ucx_stack_malloc(stack, nelem*elsize); - if (space) { - memcpy(space, data, nelem*elsize); - } - return space; -} diff -r 92e482410453 -r d345541018fa src/string.c --- a/src/string.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,807 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/string.h" - -#include "ucx/allocator.h" - -#include -#include -#include -#include -#include - -#ifndef _WIN32 -#include /* for strncasecmp() */ -#endif /* _WIN32 */ - -sstr_t sstr(char *cstring) { - sstr_t string; - string.ptr = cstring; - string.length = strlen(cstring); - return string; -} - -sstr_t sstrn(char *cstring, size_t length) { - sstr_t string; - string.ptr = cstring; - string.length = length; - return string; -} - -scstr_t scstr(const char *cstring) { - scstr_t string; - string.ptr = cstring; - string.length = strlen(cstring); - return string; -} - -scstr_t scstrn(const char *cstring, size_t length) { - scstr_t string; - string.ptr = cstring; - string.length = length; - return string; -} - - -size_t scstrnlen(size_t n, ...) { - if (n == 0) return 0; - - va_list ap; - va_start(ap, n); - - size_t size = 0; - - for (size_t i = 0 ; i < n ; i++) { - scstr_t str = va_arg(ap, scstr_t); - if(SIZE_MAX - str.length < size) { - size = SIZE_MAX; - break; - } - size += str.length; - } - va_end(ap); - - return size; -} - -static sstr_t sstrvcat_a( - UcxAllocator *a, - size_t count, - scstr_t s1, - va_list ap) { - sstr_t str; - str.ptr = NULL; - str.length = 0; - if(count < 2) { - return str; - } - - scstr_t s2 = va_arg (ap, scstr_t); - - if(((size_t)-1) - s1.length < s2.length) { - return str; - } - - scstr_t *strings = (scstr_t*) calloc(count, sizeof(scstr_t)); - if(!strings) { - return str; - } - - // get all args and overall length - strings[0] = s1; - strings[1] = s2; - size_t slen = s1.length + s2.length; - int error = 0; - for (size_t i=2;i str_length) { - return 0; - } - - if(length > str_length - start) { - length = str_length - start; - } - *newlen = length; - *newpos = start; - return 1; -} - -sstr_t sstrsubs(sstr_t s, size_t start) { - return sstrsubsl (s, start, s.length-start); -} - -sstr_t sstrsubsl(sstr_t s, size_t start, size_t length) { - size_t pos; - sstr_t ret = { NULL, 0 }; - if(ucx_substring(s.length, start, length, &ret.length, &pos)) { - ret.ptr = s.ptr + pos; - } - return ret; -} - -scstr_t scstrsubs(scstr_t string, size_t start) { - return scstrsubsl(string, start, string.length-start); -} - -scstr_t scstrsubsl(scstr_t s, size_t start, size_t length) { - size_t pos; - scstr_t ret = { NULL, 0 }; - if(ucx_substring(s.length, start, length, &ret.length, &pos)) { - ret.ptr = s.ptr + pos; - } - return ret; -} - - -static int ucx_strchr(const char *str, size_t length, int chr, size_t *pos) { - for(size_t i=0;i 0) { - for(size_t i=length ; i>0 ; i--) { - if(str[i-1] == chr) { - *pos = i-1; - return 1; - } - } - } - return 0; -} - -sstr_t sstrchr(sstr_t s, int c) { - size_t pos = 0; - if(ucx_strchr(s.ptr, s.length, c, &pos)) { - return sstrsubs(s, pos); - } - return sstrn(NULL, 0); -} - -sstr_t sstrrchr(sstr_t s, int c) { - size_t pos = 0; - if(ucx_strrchr(s.ptr, s.length, c, &pos)) { - return sstrsubs(s, pos); - } - return sstrn(NULL, 0); -} - -scstr_t scstrchr(scstr_t s, int c) { - size_t pos = 0; - if(ucx_strchr(s.ptr, s.length, c, &pos)) { - return scstrsubs(s, pos); - } - return scstrn(NULL, 0); -} - -scstr_t scstrrchr(scstr_t s, int c) { - size_t pos = 0; - if(ucx_strrchr(s.ptr, s.length, c, &pos)) { - return scstrsubs(s, pos); - } - return scstrn(NULL, 0); -} - -#define ptable_r(dest, useheap, ptable, index) (dest = useheap ? \ - ((size_t*)ptable)[index] : (size_t) ((uint8_t*)ptable)[index]) - -#define ptable_w(useheap, ptable, index, src) do {\ - if (!useheap) ((uint8_t*)ptable)[index] = (uint8_t) src;\ - else ((size_t*)ptable)[index] = src;\ - } while (0); - - -static const char* ucx_strstr( - const char *str, - size_t length, - const char *match, - size_t matchlen, - size_t *newlen) -{ - *newlen = length; - if (matchlen == 0) { - return str; - } - - const char *result = NULL; - size_t resultlen = 0; - - /* - * IMPORTANT: - * our prefix table contains the prefix length PLUS ONE - * this is our decision, because we want to use the full range of size_t - * the original algorithm needs a (-1) at one single place - * and we want to avoid that - */ - - /* static prefix table */ - static uint8_t s_prefix_table[256]; - - /* check pattern length and use appropriate prefix table */ - /* if the pattern exceeds static prefix table, allocate on the heap */ - register int useheap = matchlen > 255; - register void* ptable = useheap ? - calloc(matchlen+1, sizeof(size_t)): s_prefix_table; - - /* keep counter in registers */ - register size_t i, j; - - /* fill prefix table */ - i = 0; j = 0; - ptable_w(useheap, ptable, i, j); - while (i < matchlen) { - while (j >= 1 && match[j-1] != match[i]) { - ptable_r(j, useheap, ptable, j-1); - } - i++; j++; - ptable_w(useheap, ptable, i, j); - } - - /* search */ - i = 0; j = 1; - while (i < length) { - while (j >= 1 && str[i] != match[j-1]) { - ptable_r(j, useheap, ptable, j-1); - } - i++; j++; - if (j-1 == matchlen) { - size_t start = i - matchlen; - result = str + start; - resultlen = length - start; - break; - } - } - - /* if prefix table was allocated on the heap, free it */ - if (ptable != s_prefix_table) { - free(ptable); - } - - *newlen = resultlen; - return result; -} - -sstr_t scstrsstr(sstr_t string, scstr_t match) { - sstr_t result; - - size_t reslen; - const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen); - if(!resstr) { - result.ptr = NULL; - result.length = 0; - return result; - } - - size_t pos = resstr - string.ptr; - result.ptr = string.ptr + pos; - result.length = reslen; - - return result; -} - -scstr_t scstrscstr(scstr_t string, scstr_t match) { - scstr_t result; - - size_t reslen; - const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen); - if(!resstr) { - result.ptr = NULL; - result.length = 0; - return result; - } - - size_t pos = resstr - string.ptr; - result.ptr = string.ptr + pos; - result.length = reslen; - - return result; -} - -#undef ptable_r -#undef ptable_w - -sstr_t* scstrsplit(scstr_t s, scstr_t d, ssize_t *n) { - return scstrsplit_a(ucx_default_allocator(), s, d, n); -} - -sstr_t* scstrsplit_a(UcxAllocator *allocator, scstr_t s, scstr_t d, ssize_t *n) { - if (s.length == 0 || d.length == 0) { - *n = -1; - return NULL; - } - - /* special cases: delimiter is at least as large as the string */ - if (d.length >= s.length) { - /* exact match */ - if (sstrcmp(s, d) == 0) { - *n = 0; - return NULL; - } else /* no match possible */ { - *n = 1; - sstr_t *result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)); - if(result) { - *result = sstrdup_a(allocator, s); - } else { - *n = -2; - } - return result; - } - } - - ssize_t nmax = *n; - size_t arrlen = 16; - sstr_t* result = (sstr_t*) alcalloc(allocator, arrlen, sizeof(sstr_t)); - - if (result) { - scstr_t curpos = s; - ssize_t j = 1; - while (1) { - scstr_t match; - /* optimize for one byte delimiters */ - if (d.length == 1) { - match = curpos; - for (size_t i = 0 ; i < curpos.length ; i++) { - if (curpos.ptr[i] == *(d.ptr)) { - match.ptr = curpos.ptr + i; - break; - } - match.length--; - } - } else { - match = scstrscstr(curpos, d); - } - if (match.length > 0) { - /* is this our last try? */ - if (nmax == 0 || j < nmax) { - /* copy the current string to the array */ - scstr_t item = scstrn(curpos.ptr, match.ptr - curpos.ptr); - result[j-1] = sstrdup_a(allocator, item); - size_t processed = item.length + d.length; - curpos.ptr += processed; - curpos.length -= processed; - - /* allocate memory for the next string */ - j++; - if (j > arrlen) { - arrlen *= 2; - size_t reallocsz; - sstr_t* reallocated = NULL; - if(!ucx_szmul(arrlen, sizeof(sstr_t), &reallocsz)) { - reallocated = (sstr_t*) alrealloc( - allocator, result, reallocsz); - } - if (reallocated) { - result = reallocated; - } else { - for (ssize_t i = 0 ; i < j-1 ; i++) { - alfree(allocator, result[i].ptr); - } - alfree(allocator, result); - *n = -2; - return NULL; - } - } - } else { - /* nmax reached, copy the _full_ remaining string */ - result[j-1] = sstrdup_a(allocator, curpos); - break; - } - } else { - /* no more matches, copy last string */ - result[j-1] = sstrdup_a(allocator, curpos); - break; - } - } - *n = j; - } else { - *n = -2; - } - - return result; -} - -int scstrcmp(scstr_t s1, scstr_t s2) { - if (s1.length == s2.length) { - return memcmp(s1.ptr, s2.ptr, s1.length); - } else if (s1.length > s2.length) { - return 1; - } else { - return -1; - } -} - -int scstrcasecmp(scstr_t s1, scstr_t s2) { - if (s1.length == s2.length) { -#ifdef _WIN32 - return _strnicmp(s1.ptr, s2.ptr, s1.length); -#else - return strncasecmp(s1.ptr, s2.ptr, s1.length); -#endif - } else if (s1.length > s2.length) { - return 1; - } else { - return -1; - } -} - -sstr_t scstrdup(scstr_t s) { - return sstrdup_a(ucx_default_allocator(), s); -} - -sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t s) { - sstr_t newstring; - newstring.ptr = (char*)almalloc(allocator, s.length + 1); - if (newstring.ptr) { - newstring.length = s.length; - newstring.ptr[newstring.length] = 0; - - memcpy(newstring.ptr, s.ptr, s.length); - } else { - newstring.length = 0; - } - - return newstring; -} - - -static size_t ucx_strtrim(const char *s, size_t len, size_t *newlen) { - const char *newptr = s; - size_t length = len; - - while(length > 0 && isspace(*newptr)) { - newptr++; - length--; - } - while(length > 0 && isspace(newptr[length-1])) { - length--; - } - - *newlen = length; - return newptr - s; -} - -sstr_t sstrtrim(sstr_t string) { - sstr_t newstr; - newstr.ptr = string.ptr - + ucx_strtrim(string.ptr, string.length, &newstr.length); - return newstr; -} - -scstr_t scstrtrim(scstr_t string) { - scstr_t newstr; - newstr.ptr = string.ptr - + ucx_strtrim(string.ptr, string.length, &newstr.length); - return newstr; -} - -int scstrprefix(scstr_t string, scstr_t prefix) { - if (string.length == 0) { - return prefix.length == 0; - } - if (prefix.length == 0) { - return 1; - } - - if (prefix.length > string.length) { - return 0; - } else { - return memcmp(string.ptr, prefix.ptr, prefix.length) == 0; - } -} - -int scstrsuffix(scstr_t string, scstr_t suffix) { - if (string.length == 0) { - return suffix.length == 0; - } - if (suffix.length == 0) { - return 1; - } - - if (suffix.length > string.length) { - return 0; - } else { - return memcmp(string.ptr+string.length-suffix.length, - suffix.ptr, suffix.length) == 0; - } -} - -int scstrcaseprefix(scstr_t string, scstr_t prefix) { - if (string.length == 0) { - return prefix.length == 0; - } - if (prefix.length == 0) { - return 1; - } - - if (prefix.length > string.length) { - return 0; - } else { - scstr_t subs = scstrsubsl(string, 0, prefix.length); - return scstrcasecmp(subs, prefix) == 0; - } -} - -int scstrcasesuffix(scstr_t string, scstr_t suffix) { - if (string.length == 0) { - return suffix.length == 0; - } - if (suffix.length == 0) { - return 1; - } - - if (suffix.length > string.length) { - return 0; - } else { - scstr_t subs = scstrsubs(string, string.length-suffix.length); - return scstrcasecmp(subs, suffix) == 0; - } -} - -sstr_t scstrlower(scstr_t string) { - sstr_t ret = sstrdup(string); - for (size_t i = 0; i < ret.length ; i++) { - ret.ptr[i] = tolower(ret.ptr[i]); - } - return ret; -} - -sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string) { - sstr_t ret = sstrdup_a(allocator, string); - for (size_t i = 0; i < ret.length ; i++) { - ret.ptr[i] = tolower(ret.ptr[i]); - } - return ret; -} - -sstr_t scstrupper(scstr_t string) { - sstr_t ret = sstrdup(string); - for (size_t i = 0; i < ret.length ; i++) { - ret.ptr[i] = toupper(ret.ptr[i]); - } - return ret; -} - -sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string) { - sstr_t ret = sstrdup_a(allocator, string); - for (size_t i = 0; i < ret.length ; i++) { - ret.ptr[i] = toupper(ret.ptr[i]); - } - return ret; -} - -#define REPLACE_INDEX_BUFFER_MAX 100 - -struct scstrreplace_ibuf { - size_t* buf; - unsigned int len; /* small indices */ - struct scstrreplace_ibuf* next; -}; - -static void scstrrepl_free_ibuf(struct scstrreplace_ibuf *buf) { - while (buf) { - struct scstrreplace_ibuf *next = buf->next; - free(buf->buf); - free(buf); - buf = next; - } -} - -sstr_t scstrreplacen_a(UcxAllocator *allocator, scstr_t str, - scstr_t pattern, scstr_t replacement, size_t replmax) { - - if (pattern.length == 0 || pattern.length > str.length || replmax == 0) - return sstrdup(str); - - /* Compute expected buffer length */ - size_t ibufmax = str.length / pattern.length; - size_t ibuflen = replmax < ibufmax ? replmax : ibufmax; - if (ibuflen > REPLACE_INDEX_BUFFER_MAX) { - ibuflen = REPLACE_INDEX_BUFFER_MAX; - } - - /* Allocate first index buffer */ - struct scstrreplace_ibuf *firstbuf, *curbuf; - firstbuf = curbuf = calloc(1, sizeof(struct scstrreplace_ibuf)); - if (!firstbuf) return sstrn(NULL, 0); - firstbuf->buf = calloc(ibuflen, sizeof(size_t)); - if (!firstbuf->buf) { - free(firstbuf); - return sstrn(NULL, 0); - } - - /* Search occurrences */ - scstr_t searchstr = str; - size_t found = 0; - do { - scstr_t match = scstrscstr(searchstr, pattern); - if (match.length > 0) { - /* Allocate next buffer in chain, if required */ - if (curbuf->len == ibuflen) { - struct scstrreplace_ibuf *nextbuf = - calloc(1, sizeof(struct scstrreplace_ibuf)); - if (!nextbuf) { - scstrrepl_free_ibuf(firstbuf); - return sstrn(NULL, 0); - } - nextbuf->buf = calloc(ibuflen, sizeof(size_t)); - if (!nextbuf->buf) { - free(nextbuf); - scstrrepl_free_ibuf(firstbuf); - return sstrn(NULL, 0); - } - curbuf->next = nextbuf; - curbuf = nextbuf; - } - - /* Record match index */ - found++; - size_t idx = match.ptr - str.ptr; - curbuf->buf[curbuf->len++] = idx; - searchstr.ptr = match.ptr + pattern.length; - searchstr.length = str.length - idx - pattern.length; - } else { - break; - } - } while (searchstr.length > 0 && found < replmax); - - /* Allocate result string */ - sstr_t result; - { - ssize_t adjlen = (ssize_t) replacement.length - (ssize_t) pattern.length; - size_t rcount = 0; - curbuf = firstbuf; - do { - rcount += curbuf->len; - curbuf = curbuf->next; - } while (curbuf); - result.length = str.length + rcount * adjlen; - result.ptr = almalloc(allocator, result.length); - if (!result.ptr) { - scstrrepl_free_ibuf(firstbuf); - return sstrn(NULL, 0); - } - } - - /* Build result string */ - curbuf = firstbuf; - size_t srcidx = 0; - char* destptr = result.ptr; - do { - for (size_t i = 0; i < curbuf->len; i++) { - /* Copy source part up to next match*/ - size_t idx = curbuf->buf[i]; - size_t srclen = idx - srcidx; - if (srclen > 0) { - memcpy(destptr, str.ptr+srcidx, srclen); - destptr += srclen; - srcidx += srclen; - } - - /* Copy the replacement and skip the source pattern */ - srcidx += pattern.length; - memcpy(destptr, replacement.ptr, replacement.length); - destptr += replacement.length; - } - curbuf = curbuf->next; - } while (curbuf); - memcpy(destptr, str.ptr+srcidx, str.length-srcidx); - - /* Free index buffer */ - scstrrepl_free_ibuf(firstbuf); - - return result; -} - -sstr_t scstrreplacen(scstr_t str, scstr_t pattern, - scstr_t replacement, size_t replmax) { - return scstrreplacen_a(ucx_default_allocator(), - str, pattern, replacement, replmax); -} - - -// type adjustment functions -scstr_t ucx_sc2sc(scstr_t str) { - return str; -} -scstr_t ucx_ss2sc(sstr_t str) { - scstr_t cs; - cs.ptr = str.ptr; - cs.length = str.length; - return cs; -} -scstr_t ucx_ss2c_s(scstr_t c) { - return c; -} diff -r 92e482410453 -r d345541018fa src/test.c --- a/src/test.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,91 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/test.h" - -UcxTestSuite* ucx_test_suite_new() { - UcxTestSuite* suite = (UcxTestSuite*) malloc(sizeof(UcxTestSuite)); - if (suite != NULL) { - suite->success = 0; - suite->failure = 0; - suite->tests = NULL; - } - - return suite; -} - -void ucx_test_suite_free(UcxTestSuite* suite) { - UcxTestList *l = suite->tests; - while (l != NULL) { - UcxTestList *e = l; - l = l->next; - free(e); - } - free(suite); -} - -int ucx_test_register(UcxTestSuite* suite, UcxTest test) { - if (suite->tests) { - UcxTestList *newelem = (UcxTestList*) malloc(sizeof(UcxTestList)); - if (newelem) { - newelem->test = test; - newelem->next = NULL; - - UcxTestList *last = suite->tests; - while (last->next) { - last = last->next; - } - last->next = newelem; - - return EXIT_SUCCESS; - } else { - return EXIT_FAILURE; - } - } else { - suite->tests = (UcxTestList*) malloc(sizeof(UcxTestList)); - if (suite->tests) { - suite->tests->test = test; - suite->tests->next = NULL; - - return EXIT_SUCCESS; - } else { - return EXIT_FAILURE; - } - } -} - -void ucx_test_run(UcxTestSuite* suite, FILE* output) { - suite->success = 0; - suite->failure = 0; - for (UcxTestList* elem = suite->tests ; elem ; elem = elem->next) { - elem->test(suite, output); - } - fwrite("\nAll test completed.\n", 1, 21, output); - fprintf(output, " Total: %u\n Success: %u\n Failure: %u\n", - suite->success+suite->failure, suite->success, suite->failure); -} diff -r 92e482410453 -r d345541018fa src/ucx.c --- a/src/ucx.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -/** - * @mainpage UAP Common Extensions - * Library with common and useful functions, macros and data structures. - *

    - * Latest available source:
    - * - * https://sourceforge.net/projects/ucx/files/ - *

    - * - *

    - * Repositories:
    - * - * https://sourceforge.net/p/ucx/code - * - or - - * - * https://develop.uap-core.de/hg/ucx - *

    - * - *

    LICENCE

    - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/ucx.h" - -int ucx_szmul_impl(size_t a, size_t b, size_t *result) { - if(a == 0 || b == 0) { - *result = 0; - return 0; - } - size_t r = a * b; - if(r / b == a) { - *result = r; - return 0; - } else { - *result = 0; - return 1; - } -} - diff -r 92e482410453 -r d345541018fa src/ucx/allocator.h --- a/src/ucx/allocator.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,206 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Allocator for custom memory management. - * - * A UCX allocator consists of a pointer to the memory area / pool and four - * function pointers to memory management functions operating on this memory - * area / pool. These functions shall behave equivalent to the standard libc - * functions malloc(), calloc(), realloc() and free(). - * - * The signature of the memory management functions is based on the signature - * of the respective libc function but each of them takes the pointer to the - * memory area / pool as first argument. - * - * As the pointer to the memory area / pool can be arbitrarily chosen, any data - * can be provided to the memory management functions. A UcxMempool is just - * one example. - * - * @see mempool.h - * @see UcxMap - * - * @file allocator.h - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_ALLOCATOR_H -#define UCX_ALLOCATOR_H - -#include "ucx.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * A function pointer to the allocators malloc() function. - * @see UcxAllocator - */ -typedef void*(*ucx_allocator_malloc)(void *pool, size_t n); - -/** - * A function pointer to the allocators calloc() function. - * @see UcxAllocator - */ -typedef void*(*ucx_allocator_calloc)(void *pool, size_t n, size_t size); - -/** - * A function pointer to the allocators realloc() function. - * @see UcxAllocator - */ -typedef void*(*ucx_allocator_realloc)(void *pool, void *data, size_t n); - -/** - * A function pointer to the allocators free() function. - * @see UcxAllocator - */ -typedef void(*ucx_allocator_free)(void *pool, void *data); - -/** - * UCX allocator data structure containing memory management functions. - */ -typedef struct { - /** Pointer to an area of memory or a complex memory pool. - * This pointer will be passed to any memory management function as first - * argument. - */ - void *pool; - /** - * The malloc() function for this allocator. - */ - ucx_allocator_malloc malloc; - /** - * The calloc() function for this allocator. - */ - ucx_allocator_calloc calloc; - /** - * The realloc() function for this allocator. - */ - ucx_allocator_realloc realloc; - /** - * The free() function for this allocator. - */ - ucx_allocator_free free; -} UcxAllocator; - -/** - * Returns a pointer to the default allocator. - * - * The default allocator contains wrappers to the standard libc memory - * management functions. Use this function to get a pointer to a globally - * available allocator. You may also define an own UcxAllocator by assigning - * #UCX_ALLOCATOR_DEFAULT to a variable and pass the address of this variable - * to any function that takes a UcxAllocator as argument. Note that using - * this function is the recommended way of passing a default allocator, thus - * it never runs out of scope. - * - * @return a pointer to the default allocator - * - * @see UCX_ALLOCATOR_DEFAULT - */ -UcxAllocator *ucx_default_allocator(); - -/** - * A wrapper for the standard libc malloc() function. - * @param ignore ignored (may be used by allocators for pooled memory) - * @param n argument passed to malloc() - * @return return value of malloc() - */ -void *ucx_default_malloc(void *ignore, size_t n); -/** - * A wrapper for the standard libc calloc() function. - * @param ignore ignored (may be used by allocators for pooled memory) - * @param n argument passed to calloc() - * @param size argument passed to calloc() - * @return return value of calloc() - */ -void *ucx_default_calloc(void *ignore, size_t n, size_t size); -/** - * A wrapper for the standard libc realloc() function. - * @param ignore ignored (may be used by allocators for pooled memory) - * @param data argumend passed to realloc() - * @param n argument passed to realloc() - * @return return value of realloc() - */ -void *ucx_default_realloc(void *ignore, void *data, size_t n); -/** - * A wrapper for the standard libc free() function. - * @param ignore ignored (may be used by allocators for pooled memory) - * @param data argument passed to free() - */ -void ucx_default_free(void *ignore, void *data); - -/** - * Shorthand for calling an allocators malloc function. - * @param allocator the allocator to use - * @param n size of space to allocate - * @return a pointer to the allocated memory area - */ -#define almalloc(allocator, n) ((allocator)->malloc((allocator)->pool, n)) - -/** - * Shorthand for calling an allocators calloc function. - * @param allocator the allocator to use - * @param n the count of elements the space should be allocated for - * @param size the size of each element - * @return a pointer to the allocated memory area - */ -#define alcalloc(allocator, n, size) \ - ((allocator)->calloc((allocator)->pool, n, size)) - -/** - * Shorthand for calling an allocators realloc function. - * @param allocator the allocator to use - * @param ptr the pointer to the memory area that shall be reallocated - * @param n the new size of the allocated memory area - * @return a pointer to the reallocated memory area - */ -#define alrealloc(allocator, ptr, n) \ - ((allocator)->realloc((allocator)->pool, ptr, n)) - -/** - * Shorthand for calling an allocators free function. - * @param allocator the allocator to use - * @param ptr the pointer to the memory area that shall be freed - */ -#define alfree(allocator, ptr) ((allocator)->free((allocator)->pool, ptr)) - -/** - * Convenient macro for a default allocator struct definition. - */ -#define UCX_ALLOCATOR_DEFAULT {NULL, \ - ucx_default_malloc, ucx_default_calloc, ucx_default_realloc, \ - ucx_default_free } - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_ALLOCATOR_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/array.h --- a/src/ucx/array.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,460 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Dynamically allocated array implementation. - * - * @file array.h - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_ARRAY_H -#define UCX_ARRAY_H - -#include "ucx.h" -#include "allocator.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * UCX array type. - */ -typedef struct { - /** - * The current capacity of the array. - */ - size_t capacity; - /** - * The actual number of elements in the array. - */ - size_t size; - /** - * The size of an individual element in bytes. - */ - size_t elemsize; - /** - * A pointer to the data. - */ - void* data; - /** - * The allocator used for the data. - */ - UcxAllocator* allocator; -} UcxArray; - -/** - * Sets an element in an arbitrary user defined array. - * The data is copied from the specified data location. - * - * If the capacity is insufficient, the array is automatically reallocated and - * the possibly new pointer is stored in the array argument. - * - * On reallocation the capacity of the array is doubled until it is sufficient. - * The new capacity is stored back to capacity. - * - * @param array a pointer to location of the array pointer - * @param capacity a pointer to the capacity - * @param elmsize the size of each element - * @param idx the index of the element to set - * @param data a pointer to the element data - * @return zero on success or non-zero on error (errno will be set) - */ -#define ucx_array_util_set(array, capacity, elmsize, idx, data) \ - ucx_array_util_set_a(ucx_default_allocator(), (void**)(array), capacity, \ - elmsize, idx, data) - -/** - * Sets an element in an arbitrary user defined array. - * The data is copied from the specified data location. - * - * If the capacity is insufficient, the array is automatically reallocated - * using the specified allocator and the possibly new pointer is stored in - * the array argument. - * - * On reallocation the capacity of the array is doubled until it is sufficient. - * The new capacity is stored back to capacity. - * - * @param alloc the allocator that shall be used to reallocate the array - * @param array a pointer to location of the array pointer - * @param capacity a pointer to the capacity - * @param elmsize the size of each element - * @param idx the index of the element to set - * @param data a pointer to the element data - * @return zero on success or non-zero on error (errno will be set) - */ -int ucx_array_util_set_a(UcxAllocator* alloc, void** array, size_t* capacity, - size_t elmsize, size_t idx, void* data); - -/** - * Stores a pointer in an arbitrary user defined array. - * The element size of the array must be sizeof(void*). - * - * If the capacity is insufficient, the array is automatically reallocated and - * the possibly new pointer is stored in the array argument. - * - * On reallocation the capacity of the array is doubled until it is sufficient. - * The new capacity is stored back to capacity. - * - * @param array a pointer to location of the array pointer - * @param capacity a pointer to the capacity - * @param idx the index of the element to set - * @param ptr the pointer to store - * @return zero on success or non-zero on error (errno will be set) - */ -#define ucx_array_util_setptr(array, capacity, idx, ptr) \ - ucx_array_util_setptr_a(ucx_default_allocator(), (void**)(array), \ - capacity, idx, ptr) - -/** - * Stores a pointer in an arbitrary user defined array. - * The element size of the array must be sizeof(void*). - * - * If the capacity is insufficient, the array is automatically reallocated - * using the specified allocator and the possibly new pointer is stored in - * the array argument. - * - * On reallocation the capacity of the array is doubled until it is sufficient. - * The new capacity is stored back to capacity. - * - * @param alloc the allocator that shall be used to reallocate the array - * @param array a pointer to location of the array pointer - * @param capacity a pointer to the capacity - * @param idx the index of the element to set - * @param ptr the pointer to store - * @return zero on success or non-zero on error (errno will be set) - */ -int ucx_array_util_setptr_a(UcxAllocator* alloc, void** array, size_t* capacity, - size_t idx, void* ptr); - - -/** - * Creates a new UCX array with the given capacity and element size. - * @param capacity the initial capacity - * @param elemsize the element size - * @return a pointer to a new UCX array structure - */ -UcxArray* ucx_array_new(size_t capacity, size_t elemsize); - -/** - * Creates a new UCX array using the specified allocator. - * - * @param capacity the initial capacity - * @param elemsize the element size - * @param allocator the allocator to use - * @return a pointer to new UCX array structure - */ -UcxArray* ucx_array_new_a(size_t capacity, size_t elemsize, - UcxAllocator* allocator); - -/** - * Initializes a UCX array structure with the given capacity and element size. - * The structure must be uninitialized as the data pointer will be overwritten. - * - * @param array the structure to initialize - * @param capacity the initial capacity - * @param elemsize the element size - */ -void ucx_array_init(UcxArray* array, size_t capacity, size_t elemsize); - -/** - * Initializes a UCX array structure using the specified allocator. - * The structure must be uninitialized as the data pointer will be overwritten. - * - * @param array the structure to initialize - * @param capacity the initial capacity - * @param elemsize the element size - * @param allocator the allocator to use - */ -void ucx_array_init_a(UcxArray* array, size_t capacity, size_t elemsize, - UcxAllocator* allocator); - -/** - * Creates an shallow copy of an array. - * - * This function clones the specified array by using memcpy(). - * If the destination capacity is insufficient, an automatic reallocation is - * attempted. - * - * Note: if the destination array is uninitialized, the behavior is undefined. - * - * @param dest the array to copy to - * @param src the array to copy from - * @return zero on success, non-zero on reallocation failure. - */ -int ucx_array_clone(UcxArray* dest, UcxArray const* src); - - -/** - * Compares two UCX arrays element-wise by using a compare function. - * - * Elements of the two specified arrays are compared by using the specified - * compare function and the additional data. The type and content of this - * additional data depends on the cmp_func() used. - * - * This function always returns zero, if the element sizes of the arrays do - * not match and performs no comparisons in this case. - * - * @param array1 the first array - * @param array2 the second array - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return 1, if and only if the two arrays equal element-wise, 0 otherwise - */ -int ucx_array_equals(UcxArray const *array1, UcxArray const *array2, - cmp_func cmpfnc, void* data); - -/** - * Destroys the array. - * - * The data is freed and both capacity and count are reset to zero. - * If the array structure itself has been dynamically allocated, it has to be - * freed separately. - * - * @param array the array to destroy - */ -void ucx_array_destroy(UcxArray *array); - -/** - * Destroys and frees the array. - * - * @param array the array to free - */ -void ucx_array_free(UcxArray *array); - -/** - * Inserts elements at the end of the array. - * - * This is an O(1) operation. - * The array will automatically grow, if the capacity is exceeded. - * If a pointer to data is provided, the data is copied into the array with - * memcpy(). Otherwise the new elements are completely zeroed. - * - * @param array a pointer the array where to append the data - * @param data a pointer to the data to insert (may be NULL) - * @param count number of elements to copy from data (if data is - * NULL, zeroed elements are appended) - * @return zero on success, non-zero if a reallocation was necessary but failed - * @see ucx_array_set_from() - * @see ucx_array_append() - */ -int ucx_array_append_from(UcxArray *array, void *data, size_t count); - - -/** - * Inserts elements at the beginning of the array. - * - * This is an expensive operation, because the contents must be moved. - * If there is no particular reason to prepend data, you should use - * ucx_array_append_from() instead. - * - * @param array a pointer the array where to prepend the data - * @param data a pointer to the data to insert (may be NULL) - * @param count number of elements to copy from data (if data is - * NULL, zeroed elements are inserted) - * @return zero on success, non-zero if a reallocation was necessary but failed - * @see ucx_array_append_from() - * @see ucx_array_set_from() - * @see ucx_array_prepend() - */ -int ucx_array_prepend_from(UcxArray *array, void *data, size_t count); - - -/** - * Sets elements starting at the specified index. - * - * If the any index is out of bounds, the array automatically grows. - * The pointer to the data may be NULL, in which case the elements are zeroed. - * - * @param array a pointer the array where to set the data - * @param index the index of the element to set - * @param data a pointer to the data to insert (may be NULL) - * @param count number of elements to copy from data (if data is - * NULL, the memory in the array is zeroed) - * @return zero on success, non-zero if a reallocation was necessary but failed - * @see ucx_array_append_from() - * @see ucx_array_set() - */ -int ucx_array_set_from(UcxArray *array, size_t index, void *data, size_t count); - -/** - * Concatenates two arrays. - * - * The contents of the second array are appended to the first array in one - * single operation. The second array is otherwise left untouched. - * - * The first array may grow automatically. If this fails, both arrays remain - * unmodified. - * - * @param array1 first array - * @param array2 second array - * @return zero on success, non-zero if reallocation was necessary but failed - * or the element size does not match - */ -int ucx_array_concat(UcxArray *array1, const UcxArray *array2); - -/** - * Returns a pointer to the array element at the specified index. - * - * @param array the array to retrieve the element from - * @param index index of the element to return - * @return a pointer to the element at the specified index or NULL, - * if the index is greater than the array size - */ -void *ucx_array_at(UcxArray const* array, size_t index); - -/** - * Returns the index of an element containing the specified data. - * - * This function uses a cmp_func() to compare the data of each list element - * with the specified data. If no cmp_func is provided, memcmp() is used. - * - * If the array contains the data more than once, the index of the first - * occurrence is returned. - * If the array does not contain the data, the size of array is returned. - * - * @param array the array where to search for the data - * @param elem the element data - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return the index of the element containing the specified data or the size of - * the array, if the data is not found in this array - */ -size_t ucx_array_find(UcxArray const *array, void *elem, - cmp_func cmpfnc, void *data); - -/** - * Checks, if an array contains a specific element. - * - * An element is found, if ucx_array_find() returns a value less than the size. - * - * @param array the array where to search for the data - * @param elem the element data - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return 1, if and only if the array contains the specified element data - * @see ucx_array_find() - */ -int ucx_array_contains(UcxArray const *array, void *elem, - cmp_func cmpfnc, void *data); - -/** - * Sorts a UcxArray with the best available sort algorithm. - * - * The qsort_r() function is used, if available (glibc, FreeBSD or MacOS). - * The order of arguments is automatically adjusted for the FreeBSD and MacOS - * version of qsort_r(). - * - * If qsort_r() is not available, a merge sort algorithm is used, which is - * guaranteed to use no more additional memory than for exactly one element. - * - * @param array the array to sort - * @param cmpfnc the function that shall be used to compare the element data - * @param data additional data for the cmp_func() or NULL - */ -void ucx_array_sort(UcxArray* array, cmp_func cmpfnc, void *data); - -/** - * Removes an element from the array. - * - * This is in general an expensive operation, because several elements may - * be moved. If the order of the elements is not relevant, use - * ucx_array_remove_fast() instead. - * - * @param array pointer to the array from which the element shall be removed - * @param index the index of the element to remove - */ -void ucx_array_remove(UcxArray *array, size_t index); - -/** - * Removes an element from the array. - * - * This is an O(1) operation, but does not maintain the order of the elements. - * The last element in the array is moved to the location of the removed - * element. - * - * @param array pointer to the array from which the element shall be removed - * @param index the index of the element to remove - */ -void ucx_array_remove_fast(UcxArray *array, size_t index); - -/** - * Shrinks the memory to exactly fit the contents. - * - * After this operation, the capacity equals the size. - * - * @param array a pointer to the array - * @return zero on success, non-zero if reallocation failed - */ -int ucx_array_shrink(UcxArray* array); - -/** - * Sets the capacity of the array. - * - * If the new capacity is smaller than the size of the array, the elements - * are removed and the size is adjusted accordingly. - * - * @param array a pointer to the array - * @param capacity the new capacity - * @return zero on success, non-zero if reallocation failed - */ -int ucx_array_resize(UcxArray* array, size_t capacity); - -/** - * Resizes the array only, if the capacity is insufficient. - * - * If the requested capacity is smaller than the current capacity, this - * function does nothing. - * - * @param array a pointer to the array - * @param capacity the guaranteed capacity - * @return zero on success, non-zero if reallocation failed - */ -int ucx_array_reserve(UcxArray* array, size_t capacity); - -/** - * Resizes the capacity, if the specified number of elements would not fit. - * - * A call to ucx_array_grow(array, count) is effectively the same as - * ucx_array_reserve(array, array->size+count). - * - * @param array a pointer to the array - * @param count the number of elements that should additionally fit - * into the array - * @return zero on success, non-zero if reallocation failed - */ -int ucx_array_grow(UcxArray* array, size_t count); - - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_ARRAY_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/avl.h --- a/src/ucx/avl.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,353 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - -/** - * @file avl.h - * - * AVL tree implementation. - * - * This binary search tree implementation allows average O(1) insertion and - * removal of elements (excluding binary search time). - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_AVL_H -#define UCX_AVL_H - -#include "ucx.h" -#include "allocator.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * UCX AVL Node type. - * - * @see UcxAVLNode - */ -typedef struct UcxAVLNode UcxAVLNode; - -/** - * UCX AVL Node. - */ -struct UcxAVLNode { - /** - * The key for this node. - */ - intptr_t key; - /** - * Data contained by this node. - */ - void *value; - /** - * The height of this (sub)-tree. - */ - size_t height; - /** - * Parent node. - */ - UcxAVLNode *parent; - /** - * Root node of left subtree. - */ - UcxAVLNode *left; - /** - * Root node of right subtree. - */ - UcxAVLNode *right; -}; - -/** - * UCX AVL Tree. - */ -typedef struct { - /** - * The UcxAllocator that shall be used to manage the memory for node data. - */ - UcxAllocator *allocator; - /** - * Root node of the tree. - */ - UcxAVLNode *root; - /** - * Compare function that shall be used to compare the UcxAVLNode keys. - * @see UcxAVLNode.key - */ - cmp_func cmpfunc; - /** - * Custom user data. - * This data will also be provided to the cmpfunc. - */ - void *userdata; -} UcxAVLTree; - -/** - * Initializes a new UcxAVLTree with a default allocator. - * - * @param cmpfunc the compare function that shall be used - * @return a new UcxAVLTree object - * @see ucx_avl_new_a() - */ -UcxAVLTree *ucx_avl_new(cmp_func cmpfunc); - -/** - * Initializes a new UcxAVLTree with the specified allocator. - * - * The cmpfunc should be capable of comparing two keys within this AVL tree. - * So if you want to use null terminated strings as keys, you could use the - * ucx_cmp_str() function here. - * - * @param cmpfunc the compare function that shall be used - * @param allocator the UcxAllocator that shall be used - * @return a new UcxAVLTree object - */ -UcxAVLTree *ucx_avl_new_a(cmp_func cmpfunc, UcxAllocator *allocator); - -/** - * Destroys a UcxAVLTree. - * - * Note, that the contents are not automatically freed. - * Use may use #ucx_avl_free_content() before calling this function. - * - * @param tree the tree to destroy - * @see ucx_avl_free_content() - */ -void ucx_avl_free(UcxAVLTree *tree); - -/** - * Frees the contents of a UcxAVLTree. - * - * This is a convenience function that iterates over the tree and passes all - * values to the specified destructor function. - * - * If no destructor is specified (NULL), the free() function of - * the tree's own allocator is used. - * - * You must ensure, that it is valid to pass each value in the map to the same - * destructor function. - * - * You should free the entire tree afterwards, as the contents will be invalid. - * - * @param tree for which the contents shall be freed - * @param destr optional pointer to a destructor function - * @see ucx_avl_free() - */ -void ucx_avl_free_content(UcxAVLTree *tree, ucx_destructor destr); - -/** - * Macro for initializing a new UcxAVLTree with the default allocator and a - * ucx_cmp_ptr() compare function. - * - * @return a new default UcxAVLTree object - */ -#define ucx_avl_default_new() \ - ucx_avl_new_a(ucx_cmp_ptr, ucx_default_allocator()) - -/** - * Gets the node from the tree, that is associated with the specified key. - * @param tree the UcxAVLTree - * @param key the key - * @return the node (or NULL, if the key is not present) - */ -UcxAVLNode *ucx_avl_get_node(UcxAVLTree *tree, intptr_t key); - -/** - * Gets the value from the tree, that is associated with the specified key. - * @param tree the UcxAVLTree - * @param key the key - * @return the value (or NULL, if the key is not present) - */ -void *ucx_avl_get(UcxAVLTree *tree, intptr_t key); - -/** - * A mode for #ucx_avl_find_node() with the same behavior as - * #ucx_avl_get_node(). - */ -#define UCX_AVL_FIND_EXACT 0 -/** - * A mode for #ucx_avl_find_node() finding the node whose key is at least - * as large as the specified key. - */ -#define UCX_AVL_FIND_LOWER_BOUNDED 1 -/** - * A mode for #ucx_avl_find_node() finding the node whose key is at most - * as large as the specified key. - */ -#define UCX_AVL_FIND_UPPER_BOUNDED 2 -/** - * A mode for #ucx_avl_find_node() finding the node with a key that is as close - * to the specified key as possible. If the key is present, the behavior is - * like #ucx_avl_get_node(). This mode only returns NULL on - * empty trees. - */ -#define UCX_AVL_FIND_CLOSEST 3 - -/** - * Finds a node within the tree. The following modes are supported: - *
      - *
    • #UCX_AVL_FIND_EXACT: the same behavior as #ucx_avl_get_node()
      • - *
    • #UCX_AVL_FIND_LOWER_BOUNDED: finds the node whose key is at least - * as large as the specified key
      • - *
    • #UCX_AVL_FIND_UPPER_BOUNDED: finds the node whose key is at most - * as large as the specified key
      • - *
    • #UCX_AVL_FIND_CLOSEST: finds the node with a key that is as close to - * the specified key as possible. If the key is present, the behavior is - * like #ucx_avl_get_node(). This mode only returns NULL on - * empty trees.
      • - *
    - * - * The distance function provided MUST agree with the compare function of - * the AVL tree. - * - * @param tree the UcxAVLTree - * @param key the key - * @param dfnc the distance function - * @param mode the find mode - * @return the node (or NULL, if no node can be found) - */ -UcxAVLNode *ucx_avl_find_node(UcxAVLTree *tree, intptr_t key, - distance_func dfnc, int mode); - -/** - * Finds a value within the tree. - * See #ucx_avl_find_node() for details. - * - * @param tree the UcxAVLTree - * @param key the key - * @param dfnc the distance function - * @param mode the find mode - * @return the value (or NULL, if no value can be found) - */ -void *ucx_avl_find(UcxAVLTree *tree, intptr_t key, - distance_func dfnc, int mode); - -/** - * Puts a key/value pair into the tree. - * - * Attention: use this function only, if a possible old value does not need - * to be preserved. - * - * @param tree the UcxAVLTree - * @param key the key - * @param value the new value - * @return zero, if and only if the operation succeeded - */ -int ucx_avl_put(UcxAVLTree *tree, intptr_t key, void *value); - -/** - * Puts a key/value pair into the tree. - * - * This is a secure function which saves the old value to the variable pointed - * at by oldvalue. - * - * @param tree the UcxAVLTree - * @param key the key - * @param value the new value - * @param oldvalue optional: a pointer to the location where a possible old - * value shall be stored - * @return zero, if and only if the operation succeeded - */ -int ucx_avl_put_s(UcxAVLTree *tree, intptr_t key, void *value, void **oldvalue); - -/** - * Removes a node from the AVL tree. - * - * Note: the specified node is logically removed. The tree implementation - * decides which memory area is freed. In most cases the here provided node - * is freed, so its further use is generally undefined. - * - * @param tree the UcxAVLTree - * @param node the node to remove - * @return zero, if and only if an element has been removed - */ -int ucx_avl_remove_node(UcxAVLTree *tree, UcxAVLNode *node); - -/** - * Removes an element from the AVL tree. - * - * @param tree the UcxAVLTree - * @param key the key - * @return zero, if and only if an element has been removed - */ -int ucx_avl_remove(UcxAVLTree *tree, intptr_t key); - -/** - * Removes an element from the AVL tree. - * - * This is a secure function which saves the old key and value data from node - * to the variables at the location of oldkey and oldvalue (if specified), so - * they can be freed afterwards (if necessary). - * - * Note: the returned key in oldkey is possibly not the same as the provided - * key for the lookup (in terms of memory location). - * - * @param tree the UcxAVLTree - * @param key the key of the element to remove - * @param oldkey optional: a pointer to the location where the old key shall be - * stored - * @param oldvalue optional: a pointer to the location where the old value - * shall be stored - * @return zero, if and only if an element has been removed - */ -int ucx_avl_remove_s(UcxAVLTree *tree, intptr_t key, - intptr_t *oldkey, void **oldvalue); - -/** - * Counts the nodes in the specified UcxAVLTree. - * @param tree the AVL tree - * @return the node count - */ -size_t ucx_avl_count(UcxAVLTree *tree); - -/** - * Finds the in-order predecessor of the given node. - * @param node an AVL node - * @return the in-order predecessor of the given node, or NULL if - * the given node is the in-order minimum - */ -UcxAVLNode* ucx_avl_pred(UcxAVLNode* node); - -/** - * Finds the in-order successor of the given node. - * @param node an AVL node - * @return the in-order successor of the given node, or NULL if - * the given node is the in-order maximum - */ -UcxAVLNode* ucx_avl_succ(UcxAVLNode* node); - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_AVL_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/buffer.h --- a/src/ucx/buffer.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,339 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file buffer.h - * - * Advanced buffer implementation. - * - * Instances of UcxBuffer can be used to read from or to write to like one - * would do with a stream. This allows the use of ucx_stream_copy() to copy - * contents from one buffer to another. - * - * Some features for convenient use of the buffer - * can be enabled. See the documentation of the macro constants for more - * information. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_BUFFER_H -#define UCX_BUFFER_H - -#include "ucx.h" -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * No buffer features enabled (all flags cleared). - */ -#define UCX_BUFFER_DEFAULT 0x00 - -/** - * If this flag is enabled, the buffer will automatically free its contents. - */ -#define UCX_BUFFER_AUTOFREE 0x01 - -/** - * If this flag is enabled, the buffer will automatically extends its capacity. - */ -#define UCX_BUFFER_AUTOEXTEND 0x02 - -/** UCX Buffer. */ -typedef struct { - /** A pointer to the buffer contents. */ - char *space; - /** Current position of the buffer. */ - size_t pos; - /** Current capacity (i.e. maximum size) of the buffer. */ - size_t capacity; - /** Current size of the buffer content. */ - size_t size; - /** - * Flag register for buffer features. - * @see #UCX_BUFFER_DEFAULT - * @see #UCX_BUFFER_AUTOFREE - * @see #UCX_BUFFER_AUTOEXTEND - */ - int flags; -} UcxBuffer; - -/** - * Creates a new buffer. - * - * Note: you may provide NULL as argument for - * space. Then this function will allocate the space and enforce - * the #UCX_BUFFER_AUTOFREE flag. - * - * @param space pointer to the memory area, or NULL to allocate - * new memory - * @param capacity the capacity of the buffer - * @param flags buffer features (see UcxBuffer.flags) - * @return the new buffer - */ -UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags); - -/** - * Destroys a buffer. - * - * If the #UCX_BUFFER_AUTOFREE feature is enabled, the contents of the buffer - * are also freed. - * - * @param buffer the buffer to destroy - */ -void ucx_buffer_free(UcxBuffer* buffer); - -/** - * Creates a new buffer and fills it with extracted content from another buffer. - * - * Note: the #UCX_BUFFER_AUTOFREE feature is enforced for the new buffer. - * - * @param src the source buffer - * @param start the start position of extraction - * @param length the count of bytes to extract (must not be zero) - * @param flags feature mask for the new buffer - * @return a new buffer containing the extraction - */ -UcxBuffer* ucx_buffer_extract(UcxBuffer *src, - size_t start, size_t length, int flags); - -/** - * A shorthand macro for the full extraction of the buffer. - * - * @param src the source buffer - * @param flags feature mask for the new buffer - * @return a new buffer with the extracted content - */ -#define ucx_buffer_clone(src,flags) \ - ucx_buffer_extract(src, 0, (src)->capacity, flags) - - -/** - * Shifts the contents of the buffer by the given offset. - * - * If the offset is positive, the contents are shifted to the right. - * If auto extension is enabled, the buffer grows, if necessary. - * In case the auto extension fails, this function returns a non-zero value and - * no contents are changed. - * If auto extension is disabled, the contents that do not fit into the buffer - * are discarded. - * - * If the offset is negative, the contents are shifted to the left where the - * first shift bytes are discarded. - * The new size of the buffer is the old size minus - * the absolute shift value. - * If this value is larger than the buffer size, the buffer is emptied (but - * not cleared, see the security note below). - * - * The buffer position gets shifted alongside with the content but is kept - * within the boundaries of the buffer. - * - * Security note: the shifting operation does not erase the - * previously occupied memory cells. You can easily do that manually, e.g. by - * calling memset(buffer->space, 0, shift) for a right shift or - * memset(buffer->size, 0, buffer->capacity-buffer->size) - * for a left shift. - * - * @param buffer the buffer - * @param shift the shift offset (negative means left shift) - * @return 0 on success, non-zero if a required auto-extension fails - */ -int ucx_buffer_shift(UcxBuffer* buffer, off_t shift); - -/** - * Shifts the buffer to the right. - * See ucx_buffer_shift() for details. - * - * @param buffer the buffer - * @param shift the shift offset - * @return 0 on success, non-zero if a required auto-extension fails - * @see ucx_buffer_shift() - */ -int ucx_buffer_shift_right(UcxBuffer* buffer, size_t shift); - -/** - * Shifts the buffer to the left. - * - * See ucx_buffer_shift() for details. Note, however, that this method expects - * a positive shift offset. - * - * Since a left shift cannot fail due to memory allocation problems, this - * function always returns zero. - * - * @param buffer the buffer - * @param shift the shift offset - * @return always zero - * @see ucx_buffer_shift() - */ -int ucx_buffer_shift_left(UcxBuffer* buffer, size_t shift); - - -/** - * Moves the position of the buffer. - * - * The new position is relative to the whence argument. - * - * SEEK_SET marks the start of the buffer. - * SEEK_CUR marks the current position. - * SEEK_END marks the end of the buffer. - * - * With an offset of zero, this function sets the buffer position to zero - * (SEEK_SET), the buffer size (SEEK_END) or leaves the buffer position - * unchanged (SEEK_CUR). - * - * @param buffer - * @param offset position offset relative to whence - * @param whence one of SEEK_SET, SEEK_CUR or SEEK_END - * @return 0 on success, non-zero if the position is invalid - * - */ -int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence); - -/** - * Clears the buffer by resetting the position and deleting the data. - * - * The data is deleted by a zeroing it with call to memset(). - * - * @param buffer the buffer to be cleared - */ -#define ucx_buffer_clear(buffer) memset((buffer)->space, 0, (buffer)->size); \ - (buffer)->size = 0; (buffer)->pos = 0; - -/** - * Tests, if the buffer position has exceeded the buffer capacity. - * - * @param buffer the buffer to test - * @return non-zero, if the current buffer position has exceeded the last - * available byte of the buffer. - */ -int ucx_buffer_eof(UcxBuffer *buffer); - - -/** - * Extends the capacity of the buffer. - * - * Note: The buffer capacity increased by a power of two. I.e. - * the buffer capacity is doubled, as long as it would not hold the current - * content plus the additional required bytes. - * - * Attention: the argument provided is the number of additional - * bytes the buffer shall hold. It is NOT the total number of bytes the - * buffer shall hold. - * - * @param buffer the buffer to extend - * @param additional_bytes the number of additional bytes the buffer shall - * at least hold - * @return 0 on success or a non-zero value on failure - */ -int ucx_buffer_extend(UcxBuffer *buffer, size_t additional_bytes); - -/** - * Writes data to a UcxBuffer. - * - * The position of the buffer is increased by the number of bytes written. - * - * @param ptr a pointer to the memory area containing the bytes to be written - * @param size the length of one element - * @param nitems the element count - * @param buffer the UcxBuffer to write to - * @return the total count of bytes written - */ -size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems, - UcxBuffer *buffer); - -/** - * Reads data from a UcxBuffer. - * - * The position of the buffer is increased by the number of bytes read. - * - * @param ptr a pointer to the memory area where to store the read data - * @param size the length of one element - * @param nitems the element count - * @param buffer the UcxBuffer to read from - * @return the total number of elements read - */ -size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems, - UcxBuffer *buffer); - -/** - * Writes a character to a buffer. - * - * The least significant byte of the argument is written to the buffer. If the - * end of the buffer is reached and #UCX_BUFFER_AUTOEXTEND feature is enabled, - * the buffer capacity is extended by ucx_buffer_extend(). If the feature is - * disabled or buffer extension fails, EOF is returned. - * - * On successful write the position of the buffer is increased. - * - * @param buffer the buffer to write to - * @param c the character to write as int value - * @return the byte that has bean written as int value or - * EOF when the end of the stream is reached and automatic - * extension is not enabled or not possible - */ -int ucx_buffer_putc(UcxBuffer *buffer, int c); - -/** - * Gets a character from a buffer. - * - * The current position of the buffer is increased after a successful read. - * - * @param buffer the buffer to read from - * @return the character as int value or EOF, if the - * end of the buffer is reached - */ -int ucx_buffer_getc(UcxBuffer *buffer); - -/** - * Writes a string to a buffer. - * - * @param buffer the buffer - * @param str the string - * @return the number of bytes written - */ -size_t ucx_buffer_puts(UcxBuffer *buffer, const char *str); - -/** - * Returns the complete buffer content as sstr_t. - * @param buffer the buffer - * @return the result of sstrn() with the buffer space and size - * as arguments - */ -#define ucx_buffer_to_sstr(buffer) sstrn((buffer)->space, (buffer)->size) - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_BUFFER_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/list.h --- a/src/ucx/list.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,512 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Doubly linked list implementation. - * - * @file list.h - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_LIST_H -#define UCX_LIST_H - -#include "ucx.h" -#include "allocator.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Loop statement for UCX lists. - * - * The first argument is the name of the iteration variable. The scope of - * this variable is limited to the UCX_FOREACH statement. - * - * The second argument is a pointer to the list. In most cases this will be the - * pointer to the first element of the list, but it may also be an arbitrary - * element of the list. The iteration will then start with that element. - * - * @param list The first element of the list - * @param elem The variable name of the element - */ -#define UCX_FOREACH(elem,list) \ - for (UcxList* elem = (UcxList*) list ; elem != NULL ; elem = elem->next) - -/** - * UCX list type. - * @see UcxList - */ -typedef struct UcxList UcxList; - -/** - * UCX list structure. - */ -struct UcxList { - /** - * List element payload. - */ - void *data; - /** - * Pointer to the next list element or NULL, if this is the - * last element. - */ - UcxList *next; - /** - * Pointer to the previous list element or NULL, if this is - * the first element. - */ - UcxList *prev; -}; - -/** - * Creates an element-wise copy of a list. - * - * This function clones the specified list by creating new list elements and - * copying the data with the specified copy_func(). If no copy_func() is - * specified, a shallow copy is created and the new list will reference the - * same data as the source list. - * - * @param list the list to copy - * @param cpyfnc a pointer to the function that shall copy an element (may be - * NULL) - * @param data additional data for the copy_func() - * @return a pointer to the copy - */ -UcxList *ucx_list_clone(const UcxList *list, copy_func cpyfnc, void* data); - -/** - * Creates an element-wise copy of a list using a UcxAllocator. - * - * See ucx_list_clone() for details. - * - * You might want to pass the allocator via the data parameter, - * to access it within the copy function for making deep copies. - * - * @param allocator the allocator to use - * @param list the list to copy - * @param cpyfnc a pointer to the function that shall copy an element (may be - * NULL) - * @param data additional data for the copy_func() - * @return a pointer to the copy - * @see ucx_list_clone() - */ -UcxList *ucx_list_clone_a(UcxAllocator *allocator, const UcxList *list, - copy_func cpyfnc, void* data); - -/** - * Compares two UCX lists element-wise by using a compare function. - * - * Each element of the two specified lists are compared by using the specified - * compare function and the additional data. The type and content of this - * additional data depends on the cmp_func() used. - * - * If the list pointers denote elements within a list, the lists are compared - * starting with the denoted elements. Thus any previous elements are not taken - * into account. This might be useful to check, if certain list tails match - * each other. - * - * @param list1 the first list - * @param list2 the second list - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return 1, if and only if the two lists equal element-wise, 0 otherwise - */ -int ucx_list_equals(const UcxList *list1, const UcxList *list2, - cmp_func cmpfnc, void* data); - -/** - * Destroys the entire list. - * - * The members of the list are not automatically freed, so ensure they are - * otherwise referenced or destroyed by ucx_list_free_contents(). - * Otherwise, a memory leak is likely to occur. - * - * Caution: the argument MUST denote an entire list (i.e. a call - * to ucx_list_first() on the argument must return the argument itself) - * - * @param list the list to free - * @see ucx_list_free_contents() - */ -void ucx_list_free(UcxList *list); - -/** - * Destroys the entire list using a UcxAllocator. - * - * See ucx_list_free() for details. - * - * @param allocator the allocator to use - * @param list the list to free - * @see ucx_list_free() - */ -void ucx_list_free_a(UcxAllocator *allocator, UcxList *list); - -/** - * Destroys the contents of the specified list by calling the specified - * destructor on each of them. - * - * Note, that the contents are not usable afterwards and the list should be - * destroyed with ucx_list_free(). - * - * If no destructor is specified (NULL), stdlib's free() is used. - * - * @param list the list for which the contents shall be freed - * @param destr optional destructor function - * @see ucx_list_free() - */ -void ucx_list_free_content(UcxList* list, ucx_destructor destr); - - -/** - * Inserts an element at the end of the list. - * - * This is generally an O(n) operation, as the end of the list is retrieved with - * ucx_list_last(). - * - * @param list the list where to append the data, or NULL to - * create a new list - * @param data the data to insert - * @return list, if it is not NULL or a pointer to - * the newly created list otherwise - */ -UcxList *ucx_list_append(UcxList *list, void *data); - -/** - * Inserts an element at the end of the list using a UcxAllocator. - * - * See ucx_list_append() for details. - * - * @param allocator the allocator to use - * @param list the list where to append the data, or NULL to - * create a new list - * @param data the data to insert - * @return list, if it is not NULL or a pointer to - * the newly created list otherwise - * @see ucx_list_append() - */ -UcxList *ucx_list_append_a(UcxAllocator *allocator, UcxList *list, void *data); - - -/** - * Inserts an element at the beginning of the list. - * - * You should overwrite the old list pointer by calling - * mylist = ucx_list_prepend(mylist, mydata);. However, you may - * also perform successive calls of ucx_list_prepend() on the same list pointer, - * as this function always searchs for the head of the list with - * ucx_list_first(). - * - * @param list the list where to insert the data or NULL to create - * a new list - * @param data the data to insert - * @return a pointer to the new list head - */ -UcxList *ucx_list_prepend(UcxList *list, void *data); - -/** - * Inserts an element at the beginning of the list using a UcxAllocator. - * - * See ucx_list_prepend() for details. - * - * @param allocator the allocator to use - * @param list the list where to insert the data or NULL to create - * a new list - * @param data the data to insert - * @return a pointer to the new list head - * @see ucx_list_prepend() - */ -UcxList *ucx_list_prepend_a(UcxAllocator *allocator, UcxList *list, void *data); - -/** - * Concatenates two lists. - * - * Either of the two arguments may be NULL. - * - * This function modifies the references to the next/previous element of - * the last/first element of list1/ - * list2. - * - * @param list1 first list - * @param list2 second list - * @return if list1 is NULL, list2 is - * returned, otherwise list1 is returned - */ -UcxList *ucx_list_concat(UcxList *list1, UcxList *list2); - -/** - * Returns the first element of a list. - * - * If the argument is the list pointer, it is directly returned. Otherwise - * this function traverses to the first element of the list and returns the - * list pointer. - * - * @param elem one element of the list - * @return the first element of the list, the specified element is a member of - */ -UcxList *ucx_list_first(const UcxList *elem); - -/** - * Returns the last element of a list. - * - * If the argument has no successor, it is the last element and therefore - * directly returned. Otherwise this function traverses to the last element of - * the list and returns it. - * - * @param elem one element of the list - * @return the last element of the list, the specified element is a member of - */ -UcxList *ucx_list_last(const UcxList *elem); - -/** - * Returns the list element at the specified index. - * - * @param list the list to retrieve the element from - * @param index index of the element to return - * @return the element at the specified index or NULL, if the - * index is greater than the list size - */ -UcxList *ucx_list_get(const UcxList *list, size_t index); - -/** - * Returns the index of an element. - * - * @param list the list where to search for the element - * @param elem the element to find - * @return the index of the element or -1 if the list does not contain the - * element - */ -ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem); - -/** - * Returns the element count of the list. - * - * @param list the list whose elements are counted - * @return the element count - */ -size_t ucx_list_size(const UcxList *list); - -/** - * Returns the index of an element containing the specified data. - * - * This function uses a cmp_func() to compare the data of each list element - * with the specified data. If no cmp_func is provided, the pointers are - * compared. - * - * If the list contains the data more than once, the index of the first - * occurrence is returned. - * - * @param list the list where to search for the data - * @param elem the element data - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return the index of the element containing the specified data or -1 if the - * data is not found in this list - */ -ssize_t ucx_list_find(const UcxList *list, void *elem, - cmp_func cmpfnc, void *data); - -/** - * Checks, if a list contains a specific element. - * - * An element is found, if ucx_list_find() returns a value greater than -1. - * - * @param list the list where to search for the data - * @param elem the element data - * @param cmpfnc the compare function - * @param data additional data for the compare function - * @return 1, if and only if the list contains the specified element data - * @see ucx_list_find() - */ -int ucx_list_contains(const UcxList *list, void *elem, - cmp_func cmpfnc, void *data); - -/** - * Sorts a UcxList with natural merge sort. - * - * This function uses O(n) additional temporary memory for merge operations - * that is automatically freed after each merge. - * - * As the head of the list might change, you MUST call this function - * as follows: mylist = ucx_list_sort(mylist, mycmpfnc, mydata);. - * - * @param list the list to sort - * @param cmpfnc the function that shall be used to compare the element data - * @param data additional data for the cmp_func() - * @return the sorted list - */ -UcxList *ucx_list_sort(UcxList *list, cmp_func cmpfnc, void *data); - -/** - * Removes an element from the list. - * - * If the first element is removed, the list pointer changes. So it is - * highly recommended to always update the pointer by calling - * mylist = ucx_list_remove(mylist, myelem);. - * - * @param list the list from which the element shall be removed - * @param element the element to remove - * @return returns the updated list pointer or NULL, if the list - * is now empty - */ -UcxList *ucx_list_remove(UcxList *list, UcxList *element); - -/** - * Removes an element from the list using a UcxAllocator. - * - * See ucx_list_remove() for details. - * - * @param allocator the allocator to use - * @param list the list from which the element shall be removed - * @param element the element to remove - * @return returns the updated list pointer or NULL, if the list - * @see ucx_list_remove() - */ -UcxList *ucx_list_remove_a(UcxAllocator *allocator, UcxList *list, - UcxList *element); - -/** - * Returns the union of two lists. - * - * The union is a list of unique elements regarding cmpfnc obtained from - * both source lists. - * - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the union - */ -UcxList* ucx_list_union(const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -/** - * Returns the union of two lists. - * - * The union is a list of unique elements regarding cmpfnc obtained from - * both source lists. - * - * @param allocator allocates the new list elements - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the union - */ -UcxList* ucx_list_union_a(UcxAllocator *allocator, - const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -/** - * Returns the intersection of two lists. - * - * The intersection contains all elements of the left list - * (including duplicates) that can be found in the right list. - * - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the intersection - */ -UcxList* ucx_list_intersection(const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -/** - * Returns the intersection of two lists. - * - * The intersection contains all elements of the left list - * (including duplicates) that can be found in the right list. - * - * @param allocator allocates the new list elements - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the intersection - */ -UcxList* ucx_list_intersection_a(UcxAllocator *allocator, - const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -/** - * Returns the difference of two lists. - * - * The difference contains all elements of the left list - * (including duplicates) that are not equal to any element of the right list. - * - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the difference - */ -UcxList* ucx_list_difference(const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -/** - * Returns the difference of two lists. - * - * The difference contains all elements of the left list - * (including duplicates) that are not equal to any element of the right list. - * - * @param allocator allocates the new list elements - * @param left the left source list - * @param right the right source list - * @param cmpfnc a function to compare elements - * @param cmpdata additional data for the compare function - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the difference - */ -UcxList* ucx_list_difference_a(UcxAllocator *allocator, - const UcxList *left, const UcxList *right, - cmp_func cmpfnc, void* cmpdata, - copy_func cpfnc, void* cpdata); - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_LIST_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/logging.h --- a/src/ucx/logging.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,253 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Logging API. - * - * @file logging.h - * @author Mike Becker, Olaf Wintermann - */ -#ifndef UCX_LOGGING_H -#define UCX_LOGGING_H - -#include "ucx.h" -#include "map.h" -#include "string.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* leave enough space for custom log levels */ - -/** Log level for error messages. */ -#define UCX_LOGGER_ERROR 0x00 - -/** Log level for warning messages. */ -#define UCX_LOGGER_WARN 0x10 - -/** Log level for information messages. */ -#define UCX_LOGGER_INFO 0x20 - -/** Log level for debug messages. */ -#define UCX_LOGGER_DEBUG 0x30 - -/** Log level for trace messages. */ -#define UCX_LOGGER_TRACE 0x40 - -/** - * Output flag for the log level. - * If this flag is set, the log message will contain the log level. - * @see UcxLogger.mask - */ -#define UCX_LOGGER_LEVEL 0x01 - -/** - * Output flag for the timestmap. - * If this flag is set, the log message will contain the timestmap. - * @see UcxLogger.mask - */ -#define UCX_LOGGER_TIMESTAMP 0x02 - -/** - * Output flag for the source. - * If this flag is set, the log message will contain the source file and line - * number. - * @see UcxLogger.mask - */ -#define UCX_LOGGER_SOURCE 0x04 - -/** - * The UCX Logger object. - */ -typedef struct { - /** The stream this logger writes its messages to.*/ - void *stream; - - /** - * The write function that shall be used. - * For standard file or stdout loggers this might be standard fwrite - * (default). - */ - write_func writer; - - /** - * The date format for timestamp outputs including the delimiter - * (default: "%F %T %z "). - * @see UCX_LOGGER_TIMESTAMP - */ - char *dateformat; - - /** - * The level, this logger operates on. - * If a log command is issued, the message will only be logged, if the log - * level of the message is less or equal than the log level of the logger. - */ - unsigned int level; - - /** - * A configuration mask for automatic output. - * For each flag that is set, the logger automatically outputs some extra - * information like the timestamp or the source file and line number. - * See the documentation for the flags for details. - */ - unsigned int mask; - - /** - * A map of valid log levels for this logger. - * - * The keys represent all valid log levels and the values provide string - * representations, that are used, if the UCX_LOGGER_LEVEL flag is set. - * - * The exact data types are unsigned int for the key and - * const char* for the value. - * - * @see UCX_LOGGER_LEVEL - */ - UcxMap* levels; -} UcxLogger; - -/** - * Creates a new logger. - * @param stream the stream, which the logger shall write to - * @param level the level on which the logger shall operate - * @param mask configuration mask (cf. UcxLogger.mask) - * @return a new logger object - */ -UcxLogger *ucx_logger_new(void *stream, unsigned int level, unsigned int mask); - -/** - * Destroys the logger. - * - * The map containing the valid log levels is also automatically destroyed. - * - * @param logger the logger to destroy - */ -void ucx_logger_free(UcxLogger* logger); - -/** - * Internal log function - use macros instead. - * - * This function uses the format and variadic arguments for a - * printf()-style output of the log message. - * - * Dependent on the UcxLogger.mask some information is prepended. The complete - * format is: - * - * [LEVEL] [TIMESTAMP] [SOURCEFILE]:[LINENO] message - * - * The source file name is reduced to the actual file name. This is necessary to - * get consistent behavior over different definitions of the __FILE__ macro. - * - * Attention: the message (including automatically generated information) - * is limited to 4096 characters. The level description is limited to - * 256 characters and the timestamp string is limited to 128 characters. - * - * @param logger the logger to use - * @param level the level to log on - * @param file information about the source file - * @param line information about the source line number - * @param format format string - * @param ... arguments - * @see ucx_logger_log() - */ -void ucx_logger_logf(UcxLogger *logger, unsigned int level, const char* file, - const unsigned int line, const char* format, ...); - -/** - * Registers a custom log level. - * @param logger the logger - * @param level the log level as unsigned integer - * @param name a string literal describing the level - */ -#define ucx_logger_register_level(logger, level, name) {\ - unsigned int l; \ - l = level; \ - ucx_map_int_put(logger->levels, l, (void*) "[" name "]"); \ - } while (0); - -/** - * Logs a message at the specified level. - * @param logger the logger to use - * @param level the level to log the message on - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_log(logger, level, ...) \ - ucx_logger_logf(logger, level, __FILE__, __LINE__, __VA_ARGS__) - -/** - * Shortcut for logging an error message. - * @param logger the logger to use - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_error(logger, ...) \ - ucx_logger_log(logger, UCX_LOGGER_ERROR, __VA_ARGS__) - -/** - * Shortcut for logging an information message. - * @param logger the logger to use - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_info(logger, ...) \ - ucx_logger_log(logger, UCX_LOGGER_INFO, __VA_ARGS__) - -/** - * Shortcut for logging a warning message. - * @param logger the logger to use - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_warn(logger, ...) \ - ucx_logger_log(logger, UCX_LOGGER_WARN, __VA_ARGS__) - -/** - * Shortcut for logging a debug message. - * @param logger the logger to use - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_debug(logger, ...) \ - ucx_logger_log(logger, UCX_LOGGER_DEBUG, __VA_ARGS__) - -/** - * Shortcut for logging a trace message. - * @param logger the logger to use - * @param ... format string and arguments - * @see ucx_logger_logf() - */ -#define ucx_logger_trace(logger, ...) \ - ucx_logger_log(logger, UCX_LOGGER_TRACE, __VA_ARGS__) - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_LOGGING_H */ diff -r 92e482410453 -r d345541018fa src/ucx/map.h --- a/src/ucx/map.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,549 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file map.h - * - * Hash map implementation. - * - * This implementation uses murmur hash 2 and separate chaining with linked - * lists. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_MAP_H -#define UCX_MAP_H - -#include "ucx.h" -#include "string.h" -#include "allocator.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Loop statement for UCX maps. - * - * The key variable is implicitly defined, but the - * value variable must be already declared as type information - * cannot be inferred. - * - * @param key the variable name for the key - * @param value the variable name for the value - * @param iter a UcxMapIterator - * @see ucx_map_iterator() - */ -#define UCX_MAP_FOREACH(key,value,iter) \ - for(UcxKey key;ucx_map_iter_next(&iter,&key, (void**)&value);) - -/** Type for the UCX map. @see UcxMap */ -typedef struct UcxMap UcxMap; - -/** Type for a key of a UcxMap. @see UcxKey */ -typedef struct UcxKey UcxKey; - -/** Type for an element of a UcxMap. @see UcxMapElement */ -typedef struct UcxMapElement UcxMapElement; - -/** Type for an iterator over a UcxMap. @see UcxMapIterator */ -typedef struct UcxMapIterator UcxMapIterator; - -/** Structure for the UCX map. */ -struct UcxMap { - /** An allocator that is used for the map elements. */ - UcxAllocator *allocator; - /** The array of map element lists. */ - UcxMapElement **map; - /** The size of the map is the length of the element list array. */ - size_t size; - /** The count of elements currently stored in this map. */ - size_t count; -}; - -/** Structure to publicly denote a key of a UcxMap. */ -struct UcxKey { - /** The key data. */ - const void *data; - /** The length of the key data. */ - size_t len; - /** A cache for the hash value of the key data. */ - int hash; -}; - -/** Internal structure for a key of a UcxMap. */ -struct UcxMapKey { - /** The key data. */ - void *data; - /** The length of the key data. */ - size_t len; - /** The hash value of the key data. */ - int hash; -}; - -/** Structure for an element of a UcxMap. */ -struct UcxMapElement { - /** The value data. */ - void *data; - - /** A pointer to the next element in the current list. */ - UcxMapElement *next; - - /** The corresponding key. */ - struct UcxMapKey key; -}; - -/** Structure for an iterator over a UcxMap. */ -struct UcxMapIterator { - /** The map to iterate over. */ - UcxMap const *map; - - /** The current map element. */ - UcxMapElement *cur; - - /** - * The current index of the element list array. - * Attention: this is NOT the element index! Do NOT - * manually iterate over the map by increasing this index. Use - * ucx_map_iter_next(). - * @see UcxMap.map*/ - size_t index; -}; - -/** - * Creates a new hash map with the specified size. - * @param size the size of the hash map - * @return a pointer to the new hash map - */ -UcxMap *ucx_map_new(size_t size); - -/** - * Creates a new hash map with the specified size using a UcxAllocator. - * @param allocator the allocator to use - * @param size the size of the hash map - * @return a pointer to the new hash map - */ -UcxMap *ucx_map_new_a(UcxAllocator *allocator, size_t size); - -/** - * Frees a hash map. - * - * Note: the contents are not freed, use ucx_map_free_content() - * before calling this function to achieve that. - * - * @param map the map to be freed - * @see ucx_map_free_content() - */ -void ucx_map_free(UcxMap *map); - -/** - * Frees the contents of a hash map. - * - * This is a convenience function that iterates over the map and passes all - * values to the specified destructor function. - * - * If no destructor is specified (NULL), the free() function of - * the map's own allocator is used. - * - * You must ensure, that it is valid to pass each value in the map to the same - * destructor function. - * - * You should free or clear the map afterwards, as the contents will be invalid. - * - * @param map for which the contents shall be freed - * @param destr optional pointer to a destructor function - * @see ucx_map_free() - * @see ucx_map_clear() - */ -void ucx_map_free_content(UcxMap *map, ucx_destructor destr); - -/** - * Clears a hash map. - * - * Note: the contents are not freed, use ucx_map_free_content() - * before calling this function to achieve that. - * - * @param map the map to be cleared - * @see ucx_map_free_content() - */ -void ucx_map_clear(UcxMap *map); - - -/** - * Copies contents from a map to another map using a copy function. - * - * Note: The destination map does not need to be empty. However, if it - * contains data with keys that are also present in the source map, the contents - * are overwritten. - * - * @param from the source map - * @param to the destination map - * @param fnc the copy function or NULL if the pointer address - * shall be copied - * @param data additional data for the copy function - * @return 0 on success or a non-zero value on memory allocation errors - */ -int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data); - -/** - * Clones the map and rehashes if necessary. - * - * Note: In contrast to ucx_map_rehash() the load factor is irrelevant. - * This function always ensures a new UcxMap.size of at least - * 2.5*UcxMap.count. - * - * @param map the map to clone - * @param fnc the copy function to use or NULL if the new and - * the old map shall share the data pointers - * @param data additional data for the copy function - * @return the cloned map - * @see ucx_map_copy() - */ -UcxMap *ucx_map_clone(UcxMap const *map, copy_func fnc, void *data); - -/** - * Clones the map and rehashes if necessary. - * - * Note: In contrast to ucx_map_rehash() the load factor is irrelevant. - * This function always ensures a new UcxMap.size of at least - * 2.5*UcxMap.count. - * - * @param allocator the allocator to use for the cloned map - * @param map the map to clone - * @param fnc the copy function to use or NULL if the new and - * the old map shall share the data pointers - * @param data additional data for the copy function - * @return the cloned map - * @see ucx_map_copy() - */ -UcxMap *ucx_map_clone_a(UcxAllocator *allocator, - UcxMap const *map, copy_func fnc, void *data); - -/** - * Increases size of the hash map, if necessary. - * - * The load value is 0.75*UcxMap.size. If the element count exceeds the load - * value, the map needs to be rehashed. Otherwise no action is performed and - * this function simply returns 0. - * - * The rehashing process ensures, that the UcxMap.size is at least - * 2.5*UcxMap.count. So there is enough room for additional elements without - * the need of another soon rehashing. - * - * You can use this function to dramatically increase access performance. - * - * @param map the map to rehash - * @return 1, if a memory allocation error occurred, 0 otherwise - */ -int ucx_map_rehash(UcxMap *map); - -/** - * Puts a key/value-pair into the map. - * - * @param map the map - * @param key the key - * @param value the value - * @return 0 on success, non-zero value on failure - */ -int ucx_map_put(UcxMap *map, UcxKey key, void *value); - -/** - * Retrieves a value by using a key. - * - * @param map the map - * @param key the key - * @return the value - */ -void* ucx_map_get(UcxMap const *map, UcxKey key); - -/** - * Removes a key/value-pair from the map by using the key. - * - * @param map the map - * @param key the key - * @return the removed value - */ -void* ucx_map_remove(UcxMap *map, UcxKey key); - -/** - * Shorthand for putting data with a sstr_t key into the map. - * @param map the map - * @param key the key - * @param value the value - * @return 0 on success, non-zero value on failure - * @see ucx_map_put() - */ -#define ucx_map_sstr_put(map, key, value) \ - ucx_map_put(map, ucx_key(key.ptr, key.length), (void*)value) - -/** - * Shorthand for putting data with a C string key into the map. - * @param map the map - * @param key the key - * @param value the value - * @return 0 on success, non-zero value on failure - * @see ucx_map_put() - */ -#define ucx_map_cstr_put(map, key, value) \ - ucx_map_put(map, ucx_key(key, strlen(key)), (void*)value) - -/** - * Shorthand for putting data with an integer key into the map. - * @param map the map - * @param key the key - * @param value the value - * @return 0 on success, non-zero value on failure - * @see ucx_map_put() - */ -#define ucx_map_int_put(map, key, value) \ - ucx_map_put(map, ucx_key(&key, sizeof(key)), (void*)value) - -/** - * Shorthand for getting data from the map with a sstr_t key. - * @param map the map - * @param key the key - * @return the value - * @see ucx_map_get() - */ -#define ucx_map_sstr_get(map, key) \ - ucx_map_get(map, ucx_key(key.ptr, key.length)) - -/** - * Shorthand for getting data from the map with a C string key. - * @param map the map - * @param key the key - * @return the value - * @see ucx_map_get() - */ -#define ucx_map_cstr_get(map, key) \ - ucx_map_get(map, ucx_key(key, strlen(key))) - -/** - * Shorthand for getting data from the map with an integer key. - * @param map the map - * @param key the key - * @return the value - * @see ucx_map_get() - */ -#define ucx_map_int_get(map, key) \ - ucx_map_get(map, ucx_key(&key, sizeof(int))) - -/** - * Shorthand for removing data from the map with a sstr_t key. - * @param map the map - * @param key the key - * @return the removed value - * @see ucx_map_remove() - */ -#define ucx_map_sstr_remove(map, key) \ - ucx_map_remove(map, ucx_key(key.ptr, key.length)) - -/** - * Shorthand for removing data from the map with a C string key. - * @param map the map - * @param key the key - * @return the removed value - * @see ucx_map_remove() - */ -#define ucx_map_cstr_remove(map, key) \ - ucx_map_remove(map, ucx_key(key, strlen(key))) - -/** - * Shorthand for removing data from the map with an integer key. - * @param map the map - * @param key the key - * @return the removed value - * @see ucx_map_remove() - */ -#define ucx_map_int_remove(map, key) \ - ucx_map_remove(map, ucx_key(&key, sizeof(key))) - -/** - * Creates a UcxKey based on the given data. - * - * This function implicitly computes the hash. - * - * @param data the data for the key - * @param len the length of the data - * @return a UcxKey with implicitly computed hash - * @see ucx_hash() - */ -UcxKey ucx_key(const void *data, size_t len); - -/** - * Computes a murmur hash-2. - * - * @param data the data to hash - * @param len the length of the data - * @return the murmur hash-2 of the data - */ -int ucx_hash(const char *data, size_t len); - -/** - * Creates an iterator for a map. - * - * Note: A UcxMapIterator iterates over all elements in all element - * lists successively. Therefore the order highly depends on the key hashes and - * may vary under different map sizes. So generally you may NOT rely on - * the iteration order. - * - * Note: The iterator is NOT initialized. You need to call - * ucx_map_iter_next() at least once before accessing any information. However, - * it is not recommended to access the fields of a UcxMapIterator directly. - * - * @param map the map to create the iterator for - * @return an iterator initialized on the first element of the - * first element list - * @see ucx_map_iter_next() - */ -UcxMapIterator ucx_map_iterator(UcxMap const *map); - -/** - * Proceeds to the next element of the map (if any). - * - * Subsequent calls on the same iterator proceed to the next element and - * store the key/value-pair into the memory specified as arguments of this - * function. - * - * If no further elements are found, this function returns zero and leaves the - * last found key/value-pair in memory. - * - * @param iterator the iterator to use - * @param key a pointer to the memory where to store the key - * @param value a pointer to the memory where to store the value - * @return 1, if another element was found, 0 if all elements has been processed - * @see ucx_map_iterator() - */ -int ucx_map_iter_next(UcxMapIterator *iterator, UcxKey *key, void **value); - -/** - * Returns the union of two maps. - * - * The union is a fresh map which is filled by two successive calls of - * ucx_map_copy() on the two input maps. - * - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new map containing the union - */ -UcxMap* ucx_map_union(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - -/** - * Returns the union of two maps. - * - * The union is a fresh map which is filled by two successive calls of - * ucx_map_copy() on the two input maps. - * - * @param allocator the allocator that shall be used by the new map - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new map containing the union - */ -UcxMap* ucx_map_union_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - -/** - * Returns the intersection of two maps. - * - * The intersection is defined as a copy of the first map with every element - * removed that has no valid key in the second map. - * - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new map containing the intersection - */ -UcxMap* ucx_map_intersection(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - -/** - * Returns the intersection of two maps. - * - * The intersection is defined as a copy of the first map with every element - * removed that has no valid key in the second map. - * - * @param allocator the allocator that shall be used by the new map - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new map containing the intersection - */ -UcxMap* ucx_map_intersection_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - -/** - * Returns the difference of two maps. - * - * The difference contains a copy of all elements of the first map - * for which the corresponding keys cannot be found in the second map. - * - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the difference - */ -UcxMap* ucx_map_difference(const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - -/** - * Returns the difference of two maps. - * - * The difference contains a copy of all elements of the first map - * for which the corresponding keys cannot be found in the second map. - * - * @param allocator the allocator that shall be used by the new map - * @param first the first source map - * @param second the second source map - * @param cpfnc a function to copy the elements - * @param cpdata additional data for the copy function - * @return a new list containing the difference - */ -UcxMap* ucx_map_difference_a(UcxAllocator *allocator, - const UcxMap *first, const UcxMap *second, - copy_func cpfnc, void* cpdata); - - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_MAP_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/mempool.h --- a/src/ucx/mempool.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,209 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file mempool.h - * - * Memory pool implementation. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_MEMPOOL_H -#define UCX_MEMPOOL_H - -#include "ucx.h" -#include "allocator.h" -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * UCX mempool structure. - */ -typedef struct { - /** UcxAllocator based on this pool */ - UcxAllocator *allocator; - - /** List of pointers to pooled memory. */ - void **data; - - /** Count of pooled memory items. */ - size_t ndata; - - /** Memory pool size. */ - size_t size; -} UcxMempool; - -/** Shorthand for a new default memory pool with a capacity of 16 elements. */ -#define ucx_mempool_new_default() ucx_mempool_new(16) - - -/** - * Creates a memory pool with the specified initial size. - * - * As the created memory pool automatically grows in size by factor two when - * trying to allocate memory on a full pool, it is recommended that you use - * a power of two for the initial size. - * - * @param n initial pool size (should be a power of two, e.g. 16) - * @return a pointer to the new memory pool - * @see ucx_mempool_new_default() - */ -UcxMempool *ucx_mempool_new(size_t n); - -/** - * Resizes a memory pool. - * - * This function will fail if the new capacity is not sufficient for the - * present data. - * - * @param pool the pool to resize - * @param newcap the new capacity - * @return zero on success or non-zero on failure - */ -int ucx_mempool_chcap(UcxMempool *pool, size_t newcap); - -/** - * Allocates pooled memory. - * - * @param pool the memory pool - * @param n amount of memory to allocate - * @return a pointer to the allocated memory - * @see ucx_allocator_malloc() - */ -void *ucx_mempool_malloc(UcxMempool *pool, size_t n); -/** - * Allocates a pooled memory array. - * - * The content of the allocated memory is set to zero. - * - * @param pool the memory pool - * @param nelem amount of elements to allocate - * @param elsize amount of memory per element - * @return a pointer to the allocated memory - * @see ucx_allocator_calloc() - */ -void *ucx_mempool_calloc(UcxMempool *pool, size_t nelem, size_t elsize); - -/** - * Reallocates pooled memory. - * - * If the memory to be reallocated is not contained by the specified pool, the - * behavior is undefined. - * - * @param pool the memory pool - * @param ptr a pointer to the memory that shall be reallocated - * @param n the new size of the memory - * @return a pointer to the new location of the memory - * @see ucx_allocator_realloc() - */ -void *ucx_mempool_realloc(UcxMempool *pool, void *ptr, size_t n); - -/** - * Frees pooled memory. - * - * Before freeing the memory, the specified destructor function (if any) - * is called. - * - * If you specify memory, that is not pooled by the specified memory pool, the - * program will terminate with a call to abort(). - * - * @param pool the memory pool - * @param ptr a pointer to the memory that shall be freed - * @see ucx_mempool_set_destr() - */ -void ucx_mempool_free(UcxMempool *pool, void *ptr); - -/** - * Destroys a memory pool. - * - * For each element the destructor function (if any) is called and the element - * is freed. - * - * Each of the registered destructor function that has no corresponding element - * within the pool (namely those registered by ucx_mempool_reg_destr) is - * called interleaving with the element destruction, but with guarantee to the - * order in which they were registered (FIFO order). - * - * - * @param pool the mempool to destroy - */ -void ucx_mempool_destroy(UcxMempool *pool); - -/** - * Sets a destructor function for the specified memory. - * - * The destructor is automatically called when the memory is freed or the - * pool is destroyed. - * A destructor for pooled memory MUST NOT free the memory itself, - * as this is done by the pool. Use a destructor to free any resources - * managed by the pooled object. - * - * The only requirement for the specified memory is, that it MUST be - * pooled memory by a UcxMempool or an element-compatible mempool. The pointer - * to the destructor function is saved in a reserved area before the actual - * memory. - * - * @param ptr pooled memory - * @param func a pointer to the destructor function - * @see ucx_mempool_free() - * @see ucx_mempool_destroy() - */ -void ucx_mempool_set_destr(void *ptr, ucx_destructor func); - -/** - * Registers a destructor function for the specified (non-pooled) memory. - * - * This is useful, if you have memory that has not been allocated by a mempool, - * but shall be managed by a mempool. - * - * This function creates an entry in the specified mempool and the memory will - * therefore (logically) convert to pooled memory. - * However, this does not cause the memory to be freed automatically!. - * If you want to use this function, make the memory pool free non-pooled - * memory, the specified destructor function must call free() - * by itself. But keep in mind, that you then MUST NOT use this destructor - * function with pooled memory (e.g. in ucx_mempool_set_destr()), as it - * would cause a double-free. - * - * @param pool the memory pool - * @param ptr data the destructor is registered for - * @param destr a pointer to the destructor function - */ -void ucx_mempool_reg_destr(UcxMempool *pool, void *ptr, ucx_destructor destr); - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_MEMPOOL_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/properties.h --- a/src/ucx/properties.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,221 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * @file properties.h - * - * Load / store utilities for properties files. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_PROPERTIES_H -#define UCX_PROPERTIES_H - -#include "ucx.h" -#include "map.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * UcxProperties object for parsing properties data. - * Most of the fields are for internal use only. You may configure the - * properties parser, e.g. by changing the used delimiter or specifying - * up to three different characters that shall introduce comments. - */ -typedef struct { - /** - * Input buffer (don't set manually). - * Automatically set by calls to ucx_properties_fill(). - */ - char *buffer; - - /** - * Length of the input buffer (don't set manually). - * Automatically set by calls to ucx_properties_fill(). - */ - size_t buflen; - - /** - * Current buffer position (don't set manually). - * Used by ucx_properties_next(). - */ - size_t pos; - - /** - * Internal temporary buffer (don't set manually). - * Used by ucx_properties_next(). - */ - char *tmp; - - /** - * Internal temporary buffer length (don't set manually). - * Used by ucx_properties_next(). - */ - size_t tmplen; - - /** - * Internal temporary buffer capacity (don't set manually). - * Used by ucx_properties_next(). - */ - size_t tmpcap; - - /** - * Parser error code. - * This is always 0 on success and a nonzero value on syntax errors. - * The value is set by ucx_properties_next(). - */ - int error; - - /** - * The delimiter that shall be used. - * This is '=' by default. - */ - char delimiter; - - /** - * The first comment character. - * This is '#' by default. - */ - char comment1; - - /** - * The second comment character. - * This is not set by default. - */ - char comment2; - - /** - * The third comment character. - * This is not set by default. - */ - char comment3; -} UcxProperties; - - -/** - * Constructs a new UcxProperties object. - * @return a pointer to the new UcxProperties object - */ -UcxProperties *ucx_properties_new(); - -/** - * Destroys a UcxProperties object. - * @param prop the UcxProperties object to destroy - */ -void ucx_properties_free(UcxProperties *prop); - -/** - * Sets the input buffer for the properties parser. - * - * After calling this function, you may parse the data by calling - * ucx_properties_next() until it returns 0. The function ucx_properties2map() - * is a convenience function that reads as much data as possible by using this - * function. - * - * - * @param prop the UcxProperties object - * @param buf a pointer to the new buffer - * @param len the payload length of the buffer - * @see ucx_properties_next() - * @see ucx_properties2map() - */ -void ucx_properties_fill(UcxProperties *prop, char *buf, size_t len); - -/** - * Retrieves the next key/value-pair. - * - * This function returns a nonzero value as long as there are key/value-pairs - * found. If no more key/value-pairs are found, you may refill the input buffer - * with ucx_properties_fill(). - * - * Attention: the sstr_t.ptr pointers of the output parameters point to - * memory within the input buffer of the parser and will get invalid some time. - * If you want long term copies of the key/value-pairs, use sstrdup() after - * calling this function. - * - * @param prop the UcxProperties object - * @param name a pointer to the sstr_t that shall contain the property name - * @param value a pointer to the sstr_t that shall contain the property value - * @return Nonzero, if a key/value-pair was successfully retrieved - * @see ucx_properties_fill() - */ -int ucx_properties_next(UcxProperties *prop, sstr_t *name, sstr_t *value); - -/** - * Retrieves all available key/value-pairs and puts them into a UcxMap. - * - * This is done by successive calls to ucx_properties_next() until no more - * key/value-pairs can be retrieved. - * - * The memory for the map values is allocated by the map's own allocator. - * - * @param prop the UcxProperties object - * @param map the target map - * @return The UcxProperties.error code (i.e. 0 on success). - * @see ucx_properties_fill() - * @see UcxMap.allocator - */ -int ucx_properties2map(UcxProperties *prop, UcxMap *map); - -/** - * Loads a properties file to a UcxMap. - * - * This is a convenience function that reads data from an input - * stream until the end of the stream is reached. - * - * @param map the map object to write the key/value-pairs to - * @param file the FILE* stream to read from - * @return 0 on success, or a non-zero value on error - * - * @see ucx_properties_fill() - * @see ucx_properties2map() - */ -int ucx_properties_load(UcxMap *map, FILE *file); - -/** - * Stores a UcxMap to a file. - * - * The key/value-pairs are written by using the following format: - * - * [key] = [value]\\n - * - * @param map the map to store - * @param file the FILE* stream to write to - * @return 0 on success, or a non-zero value on error - */ -int ucx_properties_store(UcxMap *map, FILE *file); - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_PROPERTIES_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/stack.h --- a/src/ucx/stack.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,240 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file stack.h - * - * Default stack memory allocation implementation. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_STACK_H -#define UCX_STACK_H - -#include "ucx.h" -#include "allocator.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * UCX stack structure. - */ -typedef struct { - /** UcxAllocator based on this stack */ - UcxAllocator allocator; - - /** Stack size. */ - size_t size; - - /** Pointer to the bottom of the stack */ - char *space; - - /** Pointer to the top of the stack */ - char *top; -} UcxStack; - -/** - * Metadata for each UCX stack element. - */ -struct ucx_stack_metadata { - /** - * Location of the previous element (NULL if this is the first) - */ - char *prev; - - /** Size of this element */ - size_t size; -}; - -/** - * Initializes UcxStack structure with memory. - * - * @param stack a pointer to an uninitialized stack structure - * @param space the memory area that shall be managed - * @param size size of the memory area - * @return a new UcxStack structure - */ -void ucx_stack_init(UcxStack *stack, char* space, size_t size); - -/** - * Allocates stack memory. - * - * @param stack a pointer to the stack - * @param n amount of memory to allocate - * @return a pointer to the allocated memory or NULL on stack - * overflow - * @see ucx_allocator_malloc() - */ -void *ucx_stack_malloc(UcxStack *stack, size_t n); - -/** - * Allocates memory with #ucx_stack_malloc() and copies the specified data if - * the allocation was successful. - * - * @param stack a pointer to the stack - * @param n amount of memory to allocate - * @param data a pointer to the data to copy - * @return a pointer to the allocated memory - * @see ucx_stack_malloc - */ -void *ucx_stack_push(UcxStack *stack, size_t n, const void *data); - -/** - * Allocates an array of stack memory - * - * The content of the allocated memory is set to zero. - * - * @param stack a pointer to the stack - * @param nelem amount of elements to allocate - * @param elsize amount of memory per element - * @return a pointer to the allocated memory - * @see ucx_allocator_calloc() - */ -void *ucx_stack_calloc(UcxStack *stack, size_t nelem, size_t elsize); - -/** - * Allocates memory with #ucx_stack_calloc() and copies the specified data if - * the allocation was successful. - * - * @param stack a pointer to the stack - * @param nelem amount of elements to allocate - * @param elsize amount of memory per element - * @param data a pointer to the data - * @return a pointer to the allocated memory - * @see ucx_stack_calloc - */ -void *ucx_stack_pusharr(UcxStack *stack, - size_t nelem, size_t elsize, const void *data); - -/** - * Reallocates memory on the stack. - * - * Shrinking memory is always safe. Extending memory can be very expensive. - * - * @param stack the stack - * @param ptr a pointer to the memory that shall be reallocated - * @param n the new size of the memory - * @return a pointer to the new location of the memory - * @see ucx_allocator_realloc() - */ -void *ucx_stack_realloc(UcxStack *stack, void *ptr, size_t n); - -/** - * Frees memory on the stack. - * - * Freeing stack memory behaves in a special way. - * - * If the element, that should be freed, is the top most element of the stack, - * it is removed from the stack. Otherwise it is marked as freed. Marked - * elements are removed, when they become the top most elements of the stack. - * - * @param stack a pointer to the stack - * @param ptr a pointer to the memory that shall be freed - */ -void ucx_stack_free(UcxStack *stack, void *ptr); - - -/** - * Returns the size of the top most element. - * @param stack a pointer to the stack - * @return the size of the top most element - */ -#define ucx_stack_topsize(stack) ((stack)->top ? ((struct ucx_stack_metadata*)\ - (stack)->top - 1)->size : 0) - -/** - * Removes the top most element from the stack and copies the content to - * dest, if specified. - * - * Use #ucx_stack_topsize()# to get the amount of memory that must be available - * at the location of dest. - * - * @param stack a pointer to the stack - * @param dest the location where the contents shall be written to, or - * NULL, if the element shall only be removed. - * @see ucx_stack_free - * @see ucx_stack_popn - */ -#define ucx_stack_pop(stack, dest) ucx_stack_popn(stack, dest, (size_t)-1) - -/** - * Removes the top most element from the stack and copies the content to - * dest. - * - * This function copies at most n bytes to the destination, but - * the element is always freed as a whole. - * If the element was larger than n, the remaining data is lost. - * - * @param stack a pointer to the stack - * @param dest the location where the contents shall be written to - * @param n copies at most n bytes to dest - * @see ucx_stack_pop - */ -void ucx_stack_popn(UcxStack *stack, void *dest, size_t n); - -/** - * Returns the remaining available memory on the specified stack. - * - * @param stack a pointer to the stack - * @return the remaining available memory - */ -size_t ucx_stack_avail(UcxStack *stack); - -/** - * Checks, if the stack is empty. - * - * @param stack a pointer to the stack - * @return nonzero, if the stack is empty, zero otherwise - */ -#define ucx_stack_empty(stack) (!(stack)->top) - -/** - * Computes a recommended size for the stack memory area. Note, that - * reallocations have not been taken into account, so you might need to reserve - * twice as much memory to allow many reallocations. - * - * @param size the approximate payload - * @param elems the approximate count of element allocations - * @return a recommended size for the stack space based on the information - * provided - */ -#define ucx_stack_dim(size, elems) (size+sizeof(struct ucx_stack_metadata) * \ - (elems + 1)) - - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_STACK_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/string.h --- a/src/ucx/string.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1201 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Bounded string implementation. - * - * The UCX strings (sstr_t) provide an alternative to C strings. - * The main difference to C strings is, that sstr_t does not - * need to be NULL-terminated. Instead the length is stored - * within the structure. - * - * When using sstr_t, developers must be full aware of what type - * of string (NULL-terminated) or not) they are using, when - * accessing the char* ptr directly. - * - * The UCX string module provides some common string functions, known from - * standard libc, working with sstr_t. - * - * @file string.h - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_STRING_H -#define UCX_STRING_H - -#include "ucx.h" -#include "allocator.h" -#include - -/* - * Use this macro to disable the shortcuts if you experience macro collision. - */ -#ifndef UCX_NO_SSTR_SHORTCUTS -/** - * Shortcut for a sstr_t struct - * or scstr_t struct literal. - */ -#define ST(s) { s, sizeof(s)-1 } - -/** Shortcut for the conversion of a C string to a sstr_t. */ -#define S(s) sstrn(s, sizeof(s)-1) - -/** Shortcut for the conversion of a C string to a scstr_t. */ -#define SC(s) scstrn(s, sizeof(s)-1) -#endif /* UCX_NO_SSTR_SHORTCUTS */ - -/* - * Use this macro to disable the format macros. - */ -#ifndef UCX_NO_SSTR_FORMAT_MACROS -/** Expands a sstr_t or scstr_t to printf arguments. */ -#define SFMT(s) (int) (s).length, (s).ptr - -/** Format specifier for a sstr_t or scstr_t. */ -#define PRIsstr ".*s" -#endif /* UCX_NO_SSTR_FORMAT_MACROS */ - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * The UCX string structure. - */ -typedef struct { - /** A pointer to the string - * (not necessarily NULL-terminated) */ - char *ptr; - /** The length of the string */ - size_t length; -} sstr_t; - -/** - * The UCX string structure for immutable (constant) strings. - */ -typedef struct { - /** A constant pointer to the immutable string - * (not necessarily NULL-terminated) */ - const char *ptr; - /** The length of the string */ - size_t length; -} scstr_t; - -#ifdef __cplusplus -} -#endif - - -#ifdef __cplusplus -/** - * One of two type adjustment functions that return an scstr_t. - * - * Used internally to convert a UCX string to an immutable UCX string. - * - * Do not use this function manually. - * - * @param str some sstr_t - * @return an immutable (scstr_t) version of the provided string. - */ -inline scstr_t s2scstr(sstr_t s) { - scstr_t c; - c.ptr = s.ptr; - c.length = s.length; - return c; -} - -/** - * One of two type adjustment functions that return an scstr_t. - * - * Used internally to convert a UCX string to an immutable UCX string. - * This variant is used, when the string is already immutable and no operation - * needs to be performed. - * - * Do not use this function manually. - * - * @param str some scstr_t - * @return the argument itself - */ -inline scstr_t s2scstr(scstr_t str) { - return str; -} - -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * @param str some UCX string - * @return an immutable version of the provided string - */ -#define SCSTR(s) s2scstr(s) -#else - -/** - * One of two type adjustment functions that return an scstr_t. - * - * Used internally to convert a UCX string to an immutable UCX string. - * This variant is used, when the string is already immutable and no operation - * needs to be performed. - * - * Do not use this function manually. - * - * @param str some scstr_t - * @return the argument itself - */ -scstr_t ucx_sc2sc(scstr_t str); - -/** - * One of two type adjustment functions that return an scstr_t. - * - * Used internally to convert a UCX string to an immutable UCX string. - * - * Do not use this function manually. - * - * @param str some sstr_t - * @return an immutable (scstr_t) version of the provided string. - */ -scstr_t ucx_ss2sc(sstr_t str); - -#if __STDC_VERSION__ >= 201112L -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * @param str some UCX string - * @return an immutable version of the provided string - */ -#define SCSTR(str) _Generic(str, sstr_t: ucx_ss2sc, scstr_t: ucx_sc2sc)(str) - -#elif defined(__GNUC__) || defined(__clang__) - -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * @param str some UCX string - * @return an immutable version of the provided string - */ -#define SCSTR(str) __builtin_choose_expr( \ - __builtin_types_compatible_p(typeof(str), sstr_t), \ - ucx_ss2sc, \ - ucx_sc2sc)(str) - -#elif defined(__sun) - -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * @param str some UCX string - * @return the an immutable version of the provided string - */ -#define SCSTR(str) ({typeof(str) ucx_tmp_var_str = str; \ - scstr_t ucx_tmp_var_c; \ - ucx_tmp_var_c.ptr = ucx_tmp_var_str.ptr;\ - ucx_tmp_var_c.length = ucx_tmp_var_str.length;\ - ucx_tmp_var_c; }) -#else /* no generics and no builtins */ - -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * - * This internal function (ab)uses the C standard an expects one single - * argument which is then implicitly converted to scstr_t without a warning. - * - * Do not use this function manually. - * - * @return the an immutable version of the provided string - */ -scstr_t ucx_ss2c_s(); - -/** - * Converts a UCX string to an immutable UCX string (scstr_t). - * @param str some UCX string - * @return the an immutable version of the provided string - */ -#define SCSTR(str) ucx_ss2c_s(str) -#endif /* C11 feature test */ - -#endif /* C++ */ - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * Creates a new sstr_t based on a C string. - * - * The length is implicitly inferred by using a call to strlen(). - * - * Note: the sstr_t will share the specified pointer to the C string. - * If you do want a copy, use sstrdup() on the return value of this function. - * - * If you need to wrap a constant string, use scstr(). - * - * @param cstring the C string to wrap - * @return a new sstr_t containing the C string - * - * @see sstrn() - */ -sstr_t sstr(char *cstring); - -/** - * Creates a new sstr_t of the specified length based on a C string. - * - * Note: the sstr_t will share the specified pointer to the C string. - * If you do want a copy, use sstrdup() on the return value of this function. - * - * If you need to wrap a constant string, use scstrn(). - * - * @param cstring the C string to wrap - * @param length the length of the string - * @return a new sstr_t containing the C string - * - * @see sstr() - * @see S() - */ -sstr_t sstrn(char *cstring, size_t length); - -/** - * Creates a new scstr_t based on a constant C string. - * - * The length is implicitly inferred by using a call to strlen(). - * - * Note: the scstr_t will share the specified pointer to the C string. - * If you do want a copy, use scstrdup() on the return value of this function. - * - * @param cstring the C string to wrap - * @return a new scstr_t containing the C string - * - * @see scstrn() - */ -scstr_t scstr(const char *cstring); - - -/** - * Creates a new scstr_t of the specified length based on a constant C string. - * - * Note: the scstr_t will share the specified pointer to the C string. - * If you do want a copy, use scstrdup() on the return value of this function. * - * - * @param cstring the C string to wrap - * @param length the length of the string - * @return a new scstr_t containing the C string - * - * @see scstr() - */ -scstr_t scstrn(const char *cstring, size_t length); - -/** - * Returns the accumulated length of all specified strings. - * - * Attention: if the count argument is larger than the count of the - * specified strings, the behavior is undefined. - * - * @param count the total number of specified strings - * @param ... all strings - * @return the accumulated length of all strings - */ -size_t scstrnlen(size_t count, ...); - -/** - * Returns the accumulated length of all specified strings. - * - * Attention: if the count argument is larger than the count of the - * specified strings, the behavior is undefined. - * - * @param count the total number of specified strings - * @param ... all strings - * @return the cumulated length of all strings - */ -#define sstrnlen(count, ...) scstrnlen(count, __VA_ARGS__) - -/** - * Concatenates two or more strings. - * - * The resulting string will be allocated by standard malloc(). - * So developers MUST pass the sstr_t.ptr to free(). - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated. - * - * @param count the total number of strings to concatenate - * @param s1 first string - * @param ... all remaining strings - * @return the concatenated string - */ -sstr_t scstrcat(size_t count, scstr_t s1, ...); - -/** - * Concatenates two or more strings. - * - * The resulting string will be allocated by standard malloc(). - * So developers MUST pass the sstr_t.ptr to free(). - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated. - * - * @param count the total number of strings to concatenate - * @param s1 first string - * @param ... all remaining strings - * @return the concatenated string - */ -#define sstrcat(count, s1, ...) scstrcat(count, SCSTR(s1), __VA_ARGS__) - -/** - * Concatenates two or more strings using a UcxAllocator. - * - * The resulting string must be freed by the allocators free() - * implementation. - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated. - * - * @param alloc the allocator to use - * @param count the total number of strings to concatenate - * @param s1 first string - * @param ... all remaining strings - * @return the concatenated string - * - * @see scstrcat() - */ -sstr_t scstrcat_a(UcxAllocator *alloc, size_t count, scstr_t s1, ...); - -/** - * Concatenates two or more strings using a UcxAllocator. - * - * The resulting string must be freed by the allocators free() - * implementation. - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated. - * - * @param alloc the allocator to use - * @param count the total number of strings to concatenate - * @param s1 first string - * @param ... all remaining strings - * @return the concatenated string - * - * @see sstrcat() - */ -#define sstrcat_a(alloc, count, s1, ...) \ - scstrcat_a(alloc, count, SCSTR(s1), __VA_ARGS__) - -/** - * Returns a substring starting at the specified location. - * - * Attention: the new string references the same memory area as the - * input string and is NOT required to be NULL-terminated. - * Use sstrdup() to get a copy. - * - * @param string input string - * @param start start location of the substring - * @return a substring of string starting at start - * - * @see sstrsubsl() - * @see sstrchr() - */ -sstr_t sstrsubs(sstr_t string, size_t start); - -/** - * Returns a substring with the given length starting at the specified location. - * - * Attention: the new string references the same memory area as the - * input string and is NOT required to be NULL-terminated. - * Use sstrdup() to get a copy. - * - * @param string input string - * @param start start location of the substring - * @param length the maximum length of the substring - * @return a substring of string starting at start - * with a maximum length of length - * - * @see sstrsubs() - * @see sstrchr() - */ -sstr_t sstrsubsl(sstr_t string, size_t start, size_t length); - -/** - * Returns a substring of an immutable string starting at the specified - * location. - * - * Attention: the new string references the same memory area as the -* input string and is NOT required to be NULL-terminated. - * Use scstrdup() to get a copy. - * - * @param string input string - * @param start start location of the substring - * @return a substring of string starting at start - * - * @see scstrsubsl() - * @see scstrchr() - */ -scstr_t scstrsubs(scstr_t string, size_t start); - -/** - * Returns a substring of an immutable string with a maximum length starting - * at the specified location. - * - * Attention: the new string references the same memory area as the - * input string and is NOT required to be NULL-terminated. - * Use scstrdup() to get a copy. - * - * @param string input string - * @param start start location of the substring - * @param length the maximum length of the substring - * @return a substring of string starting at start - * with a maximum length of length - * - * @see scstrsubs() - * @see scstrchr() - */ -scstr_t scstrsubsl(scstr_t string, size_t start, size_t length); - -/** - * Returns a substring starting at the location of the first occurrence of the - * specified character. - * - * If the string does not contain the character, an empty string is returned. - * - * @param string the string where to locate the character - * @param chr the character to locate - * @return a substring starting at the first location of chr - * - * @see sstrsubs() - */ -sstr_t sstrchr(sstr_t string, int chr); - -/** - * Returns a substring starting at the location of the last occurrence of the - * specified character. - * - * If the string does not contain the character, an empty string is returned. - * - * @param string the string where to locate the character - * @param chr the character to locate - * @return a substring starting at the last location of chr - * - * @see sstrsubs() - */ -sstr_t sstrrchr(sstr_t string, int chr); - -/** - * Returns an immutable substring starting at the location of the first - * occurrence of the specified character. - * - * If the string does not contain the character, an empty string is returned. - * - * @param string the string where to locate the character - * @param chr the character to locate - * @return a substring starting at the first location of chr - * - * @see scstrsubs() - */ -scstr_t scstrchr(scstr_t string, int chr); - -/** - * Returns an immutable substring starting at the location of the last - * occurrence of the specified character. - * - * If the string does not contain the character, an empty string is returned. - * - * @param string the string where to locate the character - * @param chr the character to locate - * @return a substring starting at the last location of chr - * - * @see scstrsubs() - */ -scstr_t scstrrchr(scstr_t string, int chr); - -/** - * Returns a substring starting at the location of the first occurrence of the - * specified string. - * - * If the string does not contain the other string, an empty string is returned. - * - * If match is an empty string, the complete string is - * returned. - * - * @param string the string to be scanned - * @param match string containing the sequence of characters to match - * @return a substring starting at the first occurrence of - * match, or an empty string, if the sequence is not - * present in string - */ -sstr_t scstrsstr(sstr_t string, scstr_t match); - -/** - * Returns a substring starting at the location of the first occurrence of the - * specified string. - * - * If the string does not contain the other string, an empty string is returned. - * - * If match is an empty string, the complete string is - * returned. - * - * @param string the string to be scanned - * @param match string containing the sequence of characters to match - * @return a substring starting at the first occurrence of - * match, or an empty string, if the sequence is not - * present in string - */ -#define sstrstr(string, match) scstrsstr(string, SCSTR(match)) - -/** - * Returns an immutable substring starting at the location of the - * first occurrence of the specified immutable string. - * - * If the string does not contain the other string, an empty string is returned. - * - * If match is an empty string, the complete string is - * returned. - * - * @param string the string to be scanned - * @param match string containing the sequence of characters to match - * @return a substring starting at the first occurrence of - * match, or an empty string, if the sequence is not - * present in string - */ -scstr_t scstrscstr(scstr_t string, scstr_t match); - -/** - * Returns an immutable substring starting at the location of the - * first occurrence of the specified immutable string. - * - * If the string does not contain the other string, an empty string is returned. - * - * If match is an empty string, the complete string is - * returned. - * - * @param string the string to be scanned - * @param match string containing the sequence of characters to match - * @return a substring starting at the first occurrence of - * match, or an empty string, if the sequence is not - * present in string - */ -#define sstrscstr(string, match) scstrscstr(string, SCSTR(match)) - -/** - * Splits a string into parts by using a delimiter string. - * - * This function will return NULL, if one of the following happens: - *
      - *
    • the string length is zero
      • - *
    • the delimeter length is zero
      • - *
    • the string equals the delimeter
      • - *
    • memory allocation fails
      • - *
    - * - * The integer referenced by count is used as input and determines - * the maximum size of the resulting array, i.e. the maximum count of splits to - * perform + 1. - * - * The integer referenced by count is also used as output and is - * set to - *
      - *
    • -2, on memory allocation errors
      • - *
    • -1, if either the string or the delimiter is an empty string
      • - *
    • 0, if the string equals the delimiter
      • - *
    • 1, if the string does not contain the delimiter
      • - *
    • the count of array items, otherwise
      • - *
    - * - * If the string starts with the delimiter, the first item of the resulting - * array will be an empty string. - * - * If the string ends with the delimiter and the maximum list size is not - * exceeded, the last array item will be an empty string. - * In case the list size would be exceeded, the last array item will be the - * remaining string after the last split, including the terminating - * delimiter. - * - * Attention: The array pointer AND all sstr_t.ptr of the array - * items must be manually passed to free(). Use scstrsplit_a() with - * an allocator to managed memory, to avoid this. - * - * @param string the string to split - * @param delim the delimiter string - * @param count IN: the maximum size of the resulting array (0 = no limit), - * OUT: the actual size of the array - * @return a sstr_t array containing the split strings or - * NULL on error - * - * @see scstrsplit_a() - */ -sstr_t* scstrsplit(scstr_t string, scstr_t delim, ssize_t *count); - -/** - * Splits a string into parts by using a delimiter string. - * - * This function will return NULL, if one of the following happens: - *
      - *
    • the string length is zero
      • - *
    • the delimeter length is zero
      • - *
    • the string equals the delimeter
      • - *
    • memory allocation fails
      • - *
    - * - * The integer referenced by count is used as input and determines - * the maximum size of the resulting array, i.e. the maximum count of splits to - * perform + 1. - * - * The integer referenced by count is also used as output and is - * set to - *
      - *
    • -2, on memory allocation errors
      • - *
    • -1, if either the string or the delimiter is an empty string
      • - *
    • 0, if the string equals the delimiter
      • - *
    • 1, if the string does not contain the delimiter
      • - *
    • the count of array items, otherwise
      • - *
    - * - * If the string starts with the delimiter, the first item of the resulting - * array will be an empty string. - * - * If the string ends with the delimiter and the maximum list size is not - * exceeded, the last array item will be an empty string. - * In case the list size would be exceeded, the last array item will be the - * remaining string after the last split, including the terminating - * delimiter. - * - * Attention: The array pointer AND all sstr_t.ptr of the array - * items must be manually passed to free(). Use sstrsplit_a() with - * an allocator to managed memory, to avoid this. - * - * @param string the string to split - * @param delim the delimiter string - * @param count IN: the maximum size of the resulting array (0 = no limit), - * OUT: the actual size of the array - * @return a sstr_t array containing the split strings or - * NULL on error - * - * @see sstrsplit_a() - */ -#define sstrsplit(string, delim, count) \ - scstrsplit(SCSTR(string), SCSTR(delim), count) - -/** - * Performing scstrsplit() using a UcxAllocator. - * - * Read the description of scstrsplit() for details. - * - * The memory for the sstr_t.ptr pointers of the array items and the memory for - * the sstr_t array itself are allocated by using the UcxAllocator.malloc() - * function. - * - * @param allocator the UcxAllocator used for allocating memory - * @param string the string to split - * @param delim the delimiter string - * @param count IN: the maximum size of the resulting array (0 = no limit), - * OUT: the actual size of the array - * @return a sstr_t array containing the split strings or - * NULL on error - * - * @see scstrsplit() - */ -sstr_t* scstrsplit_a(UcxAllocator *allocator, scstr_t string, scstr_t delim, - ssize_t *count); - -/** - * Performing sstrsplit() using a UcxAllocator. - * - * Read the description of sstrsplit() for details. - * - * The memory for the sstr_t.ptr pointers of the array items and the memory for - * the sstr_t array itself are allocated by using the UcxAllocator.malloc() - * function. - * - * @param allocator the UcxAllocator used for allocating memory - * @param string the string to split - * @param delim the delimiter string - * @param count IN: the maximum size of the resulting array (0 = no limit), - * OUT: the actual size of the array - * @return a sstr_t array containing the split strings or - * NULL on error - * - * @see sstrsplit() - */ -#define sstrsplit_a(allocator, string, delim, count) \ - scstrsplit_a(allocator, SCSTR(string), SCSTR(delim), count) - -/** - * Compares two UCX strings with standard memcmp(). - * - * At first it compares the scstr_t.length attribute of the two strings. The - * memcmp() function is called, if and only if the lengths match. - * - * @param s1 the first string - * @param s2 the second string - * @return -1, if the length of s1 is less than the length of s2 or 1, if the - * length of s1 is greater than the length of s2 or the result of - * memcmp() otherwise (i.e. 0 if the strings match) - */ -int scstrcmp(scstr_t s1, scstr_t s2); - -/** - * Compares two UCX strings with standard memcmp(). - * - * At first it compares the sstr_t.length attribute of the two strings. The - * memcmp() function is called, if and only if the lengths match. - * - * @param s1 the first string - * @param s2 the second string - * @return -1, if the length of s1 is less than the length of s2 or 1, if the - * length of s1 is greater than the length of s2 or the result of - * memcmp() otherwise (i.e. 0 if the strings match) - */ -#define sstrcmp(s1, s2) scstrcmp(SCSTR(s1), SCSTR(s2)) - -/** - * Compares two UCX strings ignoring the case. - * - * At first it compares the scstr_t.length attribute of the two strings. If and - * only if the lengths match, both strings are compared char by char ignoring - * the case. - * - * @param s1 the first string - * @param s2 the second string - * @return -1, if the length of s1 is less than the length of s2 or 1, if the - * length of s1 is greater than the length of s2 or the result of the platform - * specific string comparison function ignoring the case. - */ -int scstrcasecmp(scstr_t s1, scstr_t s2); - -/** - * Compares two UCX strings ignoring the case. - * - * At first it compares the sstr_t.length attribute of the two strings. If and - * only if the lengths match, both strings are compared char by char ignoring - * the case. - * - * @param s1 the first string - * @param s2 the second string - * @return -1, if the length of s1 is less than the length of s2 or 1, if the - * length of s1 is greater than the length of s2 or the result of the platform - * specific string comparison function ignoring the case. - */ -#define sstrcasecmp(s1, s2) scstrcasecmp(SCSTR(s1), SCSTR(s2)) - -/** - * Creates a duplicate of the specified string. - * - * The new sstr_t will contain a copy allocated by standard - * malloc(). So developers MUST pass the sstr_t.ptr to - * free(). - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated and mutable, regardless of the argument. - * - * @param string the string to duplicate - * @return a duplicate of the string - * @see scstrdup_a() - */ -sstr_t scstrdup(scstr_t string); - -/** - * Creates a duplicate of the specified string. - * - * The new sstr_t will contain a copy allocated by standard - * malloc(). So developers MUST pass the sstr_t.ptr to - * free(). - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated, regardless of the argument. - * - * @param string the string to duplicate - * @return a duplicate of the string - * @see sstrdup_a() - */ -#define sstrdup(string) scstrdup(SCSTR(string)) - -/** - * Creates a duplicate of the specified string using a UcxAllocator. - * - * The new sstr_t will contain a copy allocated by the allocators - * UcxAllocator.malloc() function. So it is implementation depended, whether the - * returned sstr_t.ptr pointer must be passed to the allocators - * UcxAllocator.free() function manually. - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated and mutable, regardless of the argument. - * - * @param allocator a valid instance of a UcxAllocator - * @param string the string to duplicate - * @return a duplicate of the string - * @see scstrdup() - */ -sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t string); - -/** - * Creates a duplicate of the specified string using a UcxAllocator. - * - * The new sstr_t will contain a copy allocated by the allocators - * UcxAllocator.malloc() function. So it is implementation depended, whether the - * returned sstr_t.ptr pointer must be passed to the allocators - * UcxAllocator.free() function manually. - * - * The sstr_t.ptr of the return value will always be NULL- - * terminated, regardless of the argument. - * - * @param allocator a valid instance of a UcxAllocator - * @param string the string to duplicate - * @return a duplicate of the string - * @see scstrdup() - */ -#define sstrdup_a(allocator, string) scstrdup_a(allocator, SCSTR(string)) - - -/** - * Omits leading and trailing spaces. - * - * This function returns a new sstr_t containing a trimmed version of the - * specified string. - * - * Note: the new sstr_t references the same memory, thus you - * MUST NOT pass the sstr_t.ptr of the return value to - * free(). It is also highly recommended to avoid assignments like - * mystr = sstrtrim(mystr); as you lose the reference to the - * source string. Assignments of this type are only permitted, if the - * sstr_t.ptr of the source string does not need to be freed or if another - * reference to the source string exists. - * - * @param string the string that shall be trimmed - * @return a new sstr_t containing the trimmed string - */ -sstr_t sstrtrim(sstr_t string); - -/** - * Omits leading and trailing spaces. - * - * This function returns a new scstr_t containing a trimmed version of the - * specified string. - * - * Note: the new scstr_t references the same memory, thus you - * MUST NOT pass the scstr_t.ptr of the return value to - * free(). It is also highly recommended to avoid assignments like - * mystr = scstrtrim(mystr); as you lose the reference to the - * source string. Assignments of this type are only permitted, if the - * scstr_t.ptr of the source string does not need to be freed or if another - * reference to the source string exists. - * - * @param string the string that shall be trimmed - * @return a new scstr_t containing the trimmed string - */ -scstr_t scstrtrim(scstr_t string); - -/** - * Checks, if a string has a specific prefix. - * - * @param string the string to check - * @param prefix the prefix the string should have - * @return 1, if and only if the string has the specified prefix, 0 otherwise - */ -int scstrprefix(scstr_t string, scstr_t prefix); - -/** - * Checks, if a string has a specific prefix. - * - * @param string the string to check - * @param prefix the prefix the string should have - * @return 1, if and only if the string has the specified prefix, 0 otherwise - */ -#define sstrprefix(string, prefix) scstrprefix(SCSTR(string), SCSTR(prefix)) - -/** - * Checks, if a string has a specific suffix. - * - * @param string the string to check - * @param suffix the suffix the string should have - * @return 1, if and only if the string has the specified suffix, 0 otherwise - */ -int scstrsuffix(scstr_t string, scstr_t suffix); - -/** - * Checks, if a string has a specific suffix. - * - * @param string the string to check - * @param suffix the suffix the string should have - * @return 1, if and only if the string has the specified suffix, 0 otherwise - */ -#define sstrsuffix(string, suffix) scstrsuffix(SCSTR(string), SCSTR(suffix)) - -/** - * Checks, if a string has a specific prefix, ignoring the case. - * - * @param string the string to check - * @param prefix the prefix the string should have - * @return 1, if and only if the string has the specified prefix, 0 otherwise - */ -int scstrcaseprefix(scstr_t string, scstr_t prefix); - -/** - * Checks, if a string has a specific prefix, ignoring the case. - * - * @param string the string to check - * @param prefix the prefix the string should have - * @return 1, if and only if the string has the specified prefix, 0 otherwise - */ -#define sstrcaseprefix(string, prefix) \ - scstrcaseprefix(SCSTR(string), SCSTR(prefix)) - -/** - * Checks, if a string has a specific suffix, ignoring the case. - * - * @param string the string to check - * @param suffix the suffix the string should have - * @return 1, if and only if the string has the specified suffix, 0 otherwise - */ -int scstrcasesuffix(scstr_t string, scstr_t suffix); - -/** - * Checks, if a string has a specific suffix, ignoring the case. - * - * @param string the string to check - * @param suffix the suffix the string should have - * @return 1, if and only if the string has the specified suffix, 0 otherwise - */ -#define sstrcasesuffix(string, suffix) \ - scstrcasesuffix(SCSTR(string), SCSTR(suffix)) - -/** - * Returns a lower case version of a string. - * - * This function creates a duplicate of the input string, first - * (see scstrdup()). - * - * @param string the input string - * @return the resulting lower case string - * @see scstrdup() - */ -sstr_t scstrlower(scstr_t string); - -/** - * Returns a lower case version of a string. - * - * This function creates a duplicate of the input string, first - * (see sstrdup()). - * - * @param string the input string - * @return the resulting lower case string - */ -#define sstrlower(string) scstrlower(SCSTR(string)) - -/** - * Returns a lower case version of a string. - * - * This function creates a duplicate of the input string, first - * (see scstrdup_a()). - * - * @param allocator the allocator used for duplicating the string - * @param string the input string - * @return the resulting lower case string - * @see scstrdup_a() - */ -sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string); - - -/** - * Returns a lower case version of a string. - * - * This function creates a duplicate of the input string, first - * (see sstrdup_a()). - * - * @param allocator the allocator used for duplicating the string - * @param string the input string - * @return the resulting lower case string - */ -#define sstrlower_a(allocator, string) scstrlower_a(allocator, SCSTR(string)) - -/** - * Returns a upper case version of a string. - * - * This function creates a duplicate of the input string, first - * (see scstrdup()). - * - * @param string the input string - * @return the resulting upper case string - * @see scstrdup() - */ -sstr_t scstrupper(scstr_t string); - -/** - * Returns a upper case version of a string. - * - * This function creates a duplicate of the input string, first - * (see sstrdup()). - * - * @param string the input string - * @return the resulting upper case string - */ -#define sstrupper(string) scstrupper(SCSTR(string)) - -/** - * Returns a upper case version of a string. - * - * This function creates a duplicate of the input string, first - * (see scstrdup_a()). - * - * @param allocator the allocator used for duplicating the string - * @param string the input string - * @return the resulting upper case string - * @see scstrdup_a() - */ -sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string); - -/** - * Returns a upper case version of a string. - * - * This function creates a duplicate of the input string, first - * (see sstrdup_a()). - * - * @param allocator the allocator used for duplicating the string - * @param string the input string - * @return the resulting upper case string - */ -#define sstrupper_a(allocator, string) scstrupper_a(allocator, string) - - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The resulting string is allocated by the specified allocator. I.e. it - * depends on the used allocator, whether the sstr_t.ptr must be freed - * manually. - * - * If allocation fails, the sstr_t.ptr of the return value is NULL. - * - * @param allocator the allocator to use - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @param replmax maximum number of replacements - * @return the resulting string after applying the replacements - */ -sstr_t scstrreplacen_a(UcxAllocator *allocator, scstr_t str, - scstr_t pattern, scstr_t replacement, size_t replmax); - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The sstr_t.ptr of the resulting string must be freed manually. - * - * If allocation fails, the sstr_t.ptr of the return value is NULL. - * - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @param replmax maximum number of replacements - * @return the resulting string after applying the replacements - */ -sstr_t scstrreplacen(scstr_t str, scstr_t pattern, - scstr_t replacement, size_t replmax); - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The resulting string is allocated by the specified allocator. I.e. it - * depends on the used allocator, whether the sstr_t.ptr must be freed - * manually. - * - * @param allocator the allocator to use - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @param replmax maximum number of replacements - * @return the resulting string after applying the replacements - */ -#define sstrreplacen_a(allocator, str, pattern, replacement, replmax) \ - scstrreplacen_a(allocator, SCSTR(str), SCSTR(pattern), \ - SCSTR(replacement), replmax) - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The sstr_t.ptr of the resulting string must be freed manually. - * - * If allocation fails, the sstr_t.ptr of the return value is NULL. - * - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @param replmax maximum number of replacements - * @return the resulting string after applying the replacements - */ -#define sstrreplacen(str, pattern, replacement, replmax) \ - scstrreplacen(SCSTR(str), SCSTR(pattern), SCSTR(replacement), replmax) - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The resulting string is allocated by the specified allocator. I.e. it - * depends on the used allocator, whether the sstr_t.ptr must be freed - * manually. - * - * If allocation fails, the sstr_t.ptr of the return value is NULL. - * - * @param allocator the allocator to use - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @return the resulting string after applying the replacements - */ -#define sstrreplace_a(allocator, str, pattern, replacement) \ - scstrreplacen_a(allocator, SCSTR(str), SCSTR(pattern), \ - SCSTR(replacement), SIZE_MAX) - -/** - * Replaces a pattern in a string with another string. - * - * The pattern is taken literally and is no regular expression. - * Replaces at most replmax occurrences. - * - * The sstr_t.ptr of the resulting string must be freed manually. - * - * If allocation fails, the sstr_t.ptr of the return value is NULL. - * - * @param str the string where replacements should be applied - * @param pattern the pattern to search for - * @param replacement the replacement string - * @return the resulting string after applying the replacements - */ -#define sstrreplace(str, pattern, replacement) \ - scstrreplacen(SCSTR(str), SCSTR(pattern), SCSTR(replacement), SIZE_MAX) - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_STRING_H */ diff -r 92e482410453 -r d345541018fa src/ucx/test.h --- a/src/ucx/test.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,241 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file: test.h - * - * UCX Test Framework. - * - * Usage of this test framework: - * - * **** IN HEADER FILE: **** - * - * 
    - * UCX_TEST(function_name);
- * UCX_TEST_SUBROUTINE(subroutine_name, paramlist); // optional
- *
    - * - * **** IN SOURCE FILE: **** - * 
    - * UCX_TEST_SUBROUTINE(subroutine_name, paramlist) {
- *   // tests with UCX_TEST_ASSERT()
- * }
- * 
- * UCX_TEST(function_name) {
- *   // memory allocation and other stuff here
- *   #UCX_TEST_BEGIN
- *   // tests with UCX_TEST_ASSERT() and/or
- *   // calls with UCX_TEST_CALL_SUBROUTINE() here
- *   #UCX_TEST_END
- *   // cleanup of memory here
- * }
- *
    - * - * Note: if a test fails, a longjump is performed - * back to the #UCX_TEST_BEGIN macro! - * - * Attention: Do not call own functions within a test, that use - * UCX_TEST_ASSERT() macros and are not defined by using UCX_TEST_SUBROUTINE(). - * - * - * @author Mike Becker - * @author Olaf Wintermann - * - */ - -#ifndef UCX_TEST_H -#define UCX_TEST_H - -#include "ucx.h" -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef __FUNCTION__ - -/** - * Alias for the __func__ preprocessor macro. - * Some compilers use __func__ and others use __FUNCTION__. - * We use __FUNCTION__ so we define it for those compilers which use - * __func__. - */ -#define __FUNCTION__ __func__ -#endif - -/** Type for the UcxTestSuite. */ -typedef struct UcxTestSuite UcxTestSuite; - -/** Pointer to a test function. */ -typedef void(*UcxTest)(UcxTestSuite*,FILE*); - -/** Type for the internal list of test cases. */ -typedef struct UcxTestList UcxTestList; - -/** Structure for the internal list of test cases. */ -struct UcxTestList { - - /** Test case. */ - UcxTest test; - - /** Pointer to the next list element. */ - UcxTestList *next; -}; - -/** - * A test suite containing multiple test cases. - */ -struct UcxTestSuite { - - /** The number of successful tests after the suite has been run. */ - unsigned int success; - - /** The number of failed tests after the suite has been run. */ - unsigned int failure; - - /** - * Internal list of test cases. - * Use ucx_test_register() to add tests to this list. - */ - UcxTestList *tests; -}; - -/** - * Creates a new test suite. - * @return a new test suite - */ -UcxTestSuite* ucx_test_suite_new(); - -/** - * Destroys a test suite. - * @param suite the test suite to destroy - */ -void ucx_test_suite_free(UcxTestSuite* suite); - -/** - * Registers a test function with the specified test suite. - * - * @param suite the suite, the test function shall be added to - * @param test the test function to register - * @return EXIT_SUCCESS on success or - * EXIT_FAILURE on failure - */ -int ucx_test_register(UcxTestSuite* suite, UcxTest test); - -/** - * Runs a test suite and writes the test log to the specified stream. - * @param suite the test suite to run - * @param outstream the stream the log shall be written to - */ -void ucx_test_run(UcxTestSuite* suite, FILE* outstream); - -/** - * Macro for a #UcxTest function header. - * - * Use this macro to declare and/or define a #UcxTest function. - * - * @param name the name of the test function - */ -#define UCX_TEST(name) void name(UcxTestSuite* _suite_,FILE *_output_) - -/** - * Marks the begin of a test. - * Note: Any UCX_TEST_ASSERT() calls must be performed after - * #UCX_TEST_BEGIN. - * - * @see #UCX_TEST_END - */ -#define UCX_TEST_BEGIN fwrite("Running ", 1, 8, _output_);\ - fwrite(__FUNCTION__, 1, strlen(__FUNCTION__), _output_);\ - fwrite("... ", 1, 4, _output_);\ - jmp_buf _env_; \ - if (!setjmp(_env_)) { - -/** - * Checks a test assertion. - * If the assertion is correct, the test carries on. If the assertion is not - * correct, the specified message (terminated by a dot and a line break) is - * written to the test suites output stream. - * @param condition the condition to check - * @param message the message that shall be printed out on failure - */ -#define UCX_TEST_ASSERT(condition,message) if (!(condition)) { \ - fwrite(message".\n", 1, 2+strlen(message), _output_); \ - _suite_->failure++; \ - longjmp(_env_, 1);\ - } - -/** - * Macro for a test subroutine function header. - * - * Use this to declare and/or define a subroutine that can be called by using - * UCX_TEST_CALL_SUBROUTINE(). - * - * @param name the name of the subroutine - * @param ... the parameter list - * - * @see UCX_TEST_CALL_SUBROUTINE() - */ -#define UCX_TEST_SUBROUTINE(name,...) void name(UcxTestSuite* _suite_,\ - FILE *_output_, jmp_buf _env_, __VA_ARGS__) - -/** - * Macro for calling a test subroutine. - * - * Subroutines declared with UCX_TEST_SUBROUTINE() can be called by using this - * macro. - * - * Note: You may only call subroutines within a #UCX_TEST_BEGIN- - * #UCX_TEST_END-block. - * - * @param name the name of the subroutine - * @param ... the argument list - * - * @see UCX_TEST_SUBROUTINE() - */ -#define UCX_TEST_CALL_SUBROUTINE(name,...) \ - name(_suite_,_output_,_env_,__VA_ARGS__); - -/** - * Marks the end of a test. - * Note: Any UCX_TEST_ASSERT() calls must be performed before - * #UCX_TEST_END. - * - * @see #UCX_TEST_BEGIN - */ -#define UCX_TEST_END fwrite("success.\n", 1, 9, _output_); _suite_->success++;} - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_TEST_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/ucx.h --- a/src/ucx/ucx.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,204 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -/** - * Main UCX Header providing most common definitions. - * - * @file ucx.h - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_H -#define UCX_H - -/** Major UCX version as integer constant. */ -#define UCX_VERSION_MAJOR 2 - -/** Minor UCX version as integer constant. */ -#define UCX_VERSION_MINOR 1 - -/** Version constant which ensures to increase monotonically. */ -#define UCX_VERSION (((UCX_VERSION_MAJOR)<<16)|UCX_VERSION_MINOR) - -#include -#include - -#ifdef _WIN32 -#if !(defined __ssize_t_defined || defined _SSIZE_T_) -#include -typedef SSIZE_T ssize_t; -#define __ssize_t_defined -#define _SSIZE_T_ -#endif /* __ssize_t_defined and _SSIZE_T */ -#else /* !_WIN32 */ -#include -#endif /* _WIN32 */ - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * A function pointer to a destructor function. - * @see ucx_mempool_setdestr() - * @see ucx_mempool_regdestr() - */ -typedef void(*ucx_destructor)(void*); - -/** - * Function pointer to a compare function. - * - * The compare function shall take three arguments: the two values that shall be - * compared and optional additional data. - * The function shall then return -1 if the first argument is less than the - * second argument, 1 if the first argument is greater than the second argument - * and 0 if both arguments are equal. If the third argument is - * NULL, it shall be ignored. - */ -typedef int(*cmp_func)(const void*,const void*,void*); - -/** - * Function pointer to a distance function. - * - * The distance function shall take three arguments: the two values for which - * the distance shall be computed and optional additional data. - * The function shall then return the signed distance as integer value. - */ -typedef intmax_t(*distance_func)(const void*,const void*,void*); - -/** - * Function pointer to a copy function. - * - * The copy function shall create a copy of the first argument and may use - * additional data provided by the second argument. If the second argument is - * NULL, it shall be ignored. - - * Attention: if pointers returned by functions of this type may be - * passed to free() depends on the implementation of the - * respective copy_func. - */ -typedef void*(*copy_func)(const void*,void*); - -/** - * Function pointer to a write function. - * - * The signature of the write function shall be compatible to the signature - * of standard fwrite, though it may use arbitrary data types for - * source and destination. - * - * The arguments shall contain (in ascending order): a pointer to the source, - * the length of one element, the element count and a pointer to the - * destination. - */ -typedef size_t(*write_func)(const void*, size_t, size_t, void*); - -/** - * Function pointer to a read function. - * - * The signature of the read function shall be compatible to the signature - * of standard fread, though it may use arbitrary data types for - * source and destination. - * - * The arguments shall contain (in ascending order): a pointer to the - * destination, the length of one element, the element count and a pointer to - * the source. - */ -typedef size_t(*read_func)(void*, size_t, size_t, void*); - - - -#if __GNUC__ >= 5 || defined(__clang__) -#define UCX_MUL_BUILTIN - -#if __WORDSIZE == 32 -/** - * Alias for __builtin_umul_overflow. - * - * Performs a multiplication of size_t values and checks for overflow. - * - * @param a first operand - * @param b second operand - * @param result a pointer to a size_t, where the result should - * be stored - * @return zero, if no overflow occurred and the result is correct, non-zero - * otherwise - */ -#define ucx_szmul(a, b, result) __builtin_umul_overflow(a, b, result) -#else /* __WORDSIZE != 32 */ -/** - * Alias for __builtin_umull_overflow. - * - * Performs a multiplication of size_t values and checks for overflow. - * - * @param a first operand - * @param b second operand - * @param result a pointer to a size_t, where the result should - * be stored - * @return zero, if no overflow occurred and the result is correct, non-zero - * otherwise - */ -#define ucx_szmul(a, b, result) __builtin_umull_overflow(a, b, result) -#endif /* __WORDSIZE */ - -#else /* no GNUC or clang bultin */ - -/** - * Performs a multiplication of size_t values and checks for overflow. - * - * @param a first operand - * @param b second operand - * @param result a pointer to a size_t, where the result should - * be stored - * @return zero, if no overflow occurred and the result is correct, non-zero - * otherwise - */ -#define ucx_szmul(a, b, result) ucx_szmul_impl(a, b, result) - -/** - * Performs a multiplication of size_t values and checks for overflow. - * - * This is a custom implementation in case there is no compiler builtin - * available. - * - * @param a first operand - * @param b second operand - * @param result a pointer to a size_t where the result should be stored - * @return zero, if no overflow occurred and the result is correct, non-zero - * otherwise - */ -int ucx_szmul_impl(size_t a, size_t b, size_t *result); - -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_H */ - diff -r 92e482410453 -r d345541018fa src/ucx/utils.h --- a/src/ucx/utils.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,508 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @file utils.h - * - * Compare, copy and printf functions. - * - * @author Mike Becker - * @author Olaf Wintermann - */ - -#ifndef UCX_UTILS_H -#define UCX_UTILS_H - -#include "ucx.h" -#include "string.h" -#include "allocator.h" -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Default buffer size for ucx_stream_copy() and ucx_stream_ncopy(). - */ -#define UCX_STREAM_COPY_BUFSIZE 4096 - -/** - * Copies a string. - * @param s the string to copy - * @param data omitted - * @return a pointer to a copy of s1 that can be passed to free(void*) - */ -void *ucx_strcpy(const void *s, void *data); - -/** - * Copies a memory area. - * @param m a pointer to the memory area - * @param n a pointer to the size_t containing the size of the memory area - * @return a pointer to a copy of the specified memory area that can - * be passed to free(void*) - */ -void *ucx_memcpy(const void *m, void *n); - - -/** - * Reads data from a stream and writes it to another stream. - * - * @param src the source stream - * @param dest the destination stream - * @param rfnc the read function - * @param wfnc the write function - * @param buf a pointer to the copy buffer or NULL if a buffer - * shall be implicitly created on the heap - * @param bufsize the size of the copy buffer - if NULL was - * provided for buf, this is the size of the buffer that shall be - * implicitly created - * @param n the maximum number of bytes that shall be copied - * @return the total number of bytes copied - */ -size_t ucx_stream_bncopy(void *src, void *dest, read_func rfnc, write_func wfnc, - char* buf, size_t bufsize, size_t n); - -/** - * Shorthand for an unbounded ucx_stream_bncopy call using a default buffer. - * - * @param src the source stream - * @param dest the destination stream - * @param rfnc the read function - * @param wfnc the write function - * @return total number of bytes copied - * - * @see #UCX_STREAM_COPY_BUFSIZE - */ -#define ucx_stream_copy(src,dest,rfnc,wfnc) ucx_stream_bncopy(\ - src, dest, (read_func)rfnc, (write_func)wfnc, \ - NULL, UCX_STREAM_COPY_BUFSIZE, (size_t)-1) - -/** - * Shorthand for ucx_stream_bncopy using a default copy buffer. - * - * @param src the source stream - * @param dest the destination stream - * @param rfnc the read function - * @param wfnc the write function - * @param n maximum number of bytes that shall be copied - * @return total number of bytes copied - */ -#define ucx_stream_ncopy(src,dest,rfnc,wfnc, n) ucx_stream_bncopy(\ - src, dest, (read_func)rfnc, (write_func)wfnc, \ - NULL, UCX_STREAM_COPY_BUFSIZE, n) - -/** - * Shorthand for an unbounded ucx_stream_bncopy call using the specified buffer. - * - * @param src the source stream - * @param dest the destination stream - * @param rfnc the read function - * @param wfnc the write function - * @param buf a pointer to the copy buffer or NULL if a buffer - * shall be implicitly created on the heap - * @param bufsize the size of the copy buffer - if NULL was - * provided for buf, this is the size of the buffer that shall be - * implicitly created - * @return total number of bytes copied - */ -#define ucx_stream_bcopy(src,dest,rfnc,wfnc, buf, bufsize) ucx_stream_bncopy(\ - src, dest, (read_func)rfnc, (write_func)wfnc, \ - buf, bufsize, (size_t)-1) - -/** - * Wraps the strcmp function. - * @param s1 string one - * @param s2 string two - * @param data omitted - * @return the result of strcmp(s1, s2) - */ -int ucx_cmp_str(const void *s1, const void *s2, void *data); - -/** - * Wraps the strncmp function. - * @param s1 string one - * @param s2 string two - * @param n a pointer to the size_t containing the third strncmp parameter - * @return the result of strncmp(s1, s2, *n) - */ -int ucx_cmp_strn(const void *s1, const void *s2, void *n); - -/** - * Wraps the sstrcmp function. - * @param s1 sstr one - * @param s2 sstr two - * @param data ignored - * @return the result of sstrcmp(s1, s2) - */ -int ucx_cmp_sstr(const void *s1, const void *s2, void *data); - -/** - * Compares two integers of type int. - * @param i1 pointer to integer one - * @param i2 pointer to integer two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_int(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type long int. - * @param i1 pointer to long integer one - * @param i2 pointer to long integer two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_longint(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type long long. - * @param i1 pointer to long long one - * @param i2 pointer to long long two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_longlong(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type int16_t. - * @param i1 pointer to int16_t one - * @param i2 pointer to int16_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_int16(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type int32_t. - * @param i1 pointer to int32_t one - * @param i2 pointer to int32_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_int32(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type int64_t. - * @param i1 pointer to int64_t one - * @param i2 pointer to int64_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_int64(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type unsigned int. - * @param i1 pointer to unsigned integer one - * @param i2 pointer to unsigned integer two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_uint(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type unsigned long int. - * @param i1 pointer to unsigned long integer one - * @param i2 pointer to unsigned long integer two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_ulongint(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type unsigned long long. - * @param i1 pointer to unsigned long long one - * @param i2 pointer to unsigned long long two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_ulonglong(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type uint16_t. - * @param i1 pointer to uint16_t one - * @param i2 pointer to uint16_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_uint16(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type uint32_t. - * @param i1 pointer to uint32_t one - * @param i2 pointer to uint32_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_uint32(const void *i1, const void *i2, void *data); - -/** - * Compares two integers of type uint64_t. - * @param i1 pointer to uint64_t one - * @param i2 pointer to uint64_t two - * @param data omitted - * @return -1, if *i1 is less than *i2, 0 if both are equal, - * 1 if *i1 is greater than *i2 - */ -int ucx_cmp_uint64(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type int. - * @param i1 pointer to integer one - * @param i2 pointer to integer two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_int(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type long int. - * @param i1 pointer to long integer one - * @param i2 pointer to long integer two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_longint(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type long long. - * @param i1 pointer to long long one - * @param i2 pointer to long long two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_longlong(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type int16_t. - * @param i1 pointer to int16_t one - * @param i2 pointer to int16_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_int16(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type int32_t. - * @param i1 pointer to int32_t one - * @param i2 pointer to int32_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_int32(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type int64_t. - * @param i1 pointer to int64_t one - * @param i2 pointer to int64_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_int64(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type unsigned int. - * @param i1 pointer to unsigned integer one - * @param i2 pointer to unsigned integer two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_uint(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type unsigned long int. - * @param i1 pointer to unsigned long integer one - * @param i2 pointer to unsigned long integer two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_ulongint(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type unsigned long long. - * @param i1 pointer to unsigned long long one - * @param i2 pointer to unsigned long long two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_ulonglong(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type uint16_t. - * @param i1 pointer to uint16_t one - * @param i2 pointer to uint16_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_uint16(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type uint32_t. - * @param i1 pointer to uint32_t one - * @param i2 pointer to uint32_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_uint32(const void *i1, const void *i2, void *data); - -/** - * Distance function for integers of type uint64_t. - * @param i1 pointer to uint64_t one - * @param i2 pointer to uint64_t two - * @param data omitted - * @return i1 minus i2 - */ -intmax_t ucx_dist_uint64(const void *i1, const void *i2, void *data); - -/** - * Compares two real numbers of type float. - * @param f1 pointer to float one - * @param f2 pointer to float two - * @param data if provided: a pointer to precision (default: 1e-6f) - * @return -1, if *f1 is less than *f2, 0 if both are equal, - * 1 if *f1 is greater than *f2 - */ - -int ucx_cmp_float(const void *f1, const void *f2, void *data); - -/** - * Compares two real numbers of type double. - * @param d1 pointer to double one - * @param d2 pointer to double two - * @param data if provided: a pointer to precision (default: 1e-14) - * @return -1, if *d1 is less than *d2, 0 if both are equal, - * 1 if *d1 is greater than *d2 - */ -int ucx_cmp_double(const void *d1, const void *d2, void *data); - -/** - * Compares two pointers. - * @param ptr1 pointer one - * @param ptr2 pointer two - * @param data omitted - * @return -1 if ptr1 is less than ptr2, 0 if both are equal, - * 1 if ptr1 is greater than ptr2 - */ -int ucx_cmp_ptr(const void *ptr1, const void *ptr2, void *data); - -/** - * Compares two memory areas. - * @param ptr1 pointer one - * @param ptr2 pointer two - * @param n a pointer to the size_t containing the third parameter for memcmp - * @return the result of memcmp(ptr1, ptr2, *n) - */ -int ucx_cmp_mem(const void *ptr1, const void *ptr2, void *n); - -/** - * A printf() like function which writes the output to a stream by - * using a write_func(). - * @param stream the stream the data is written to - * @param wfc the write function - * @param fmt format string - * @param ... additional arguments - * @return the total number of bytes written - */ -int ucx_fprintf(void *stream, write_func wfc, const char *fmt, ...); - -/** - * va_list version of ucx_fprintf(). - * @param stream the stream the data is written to - * @param wfc the write function - * @param fmt format string - * @param ap argument list - * @return the total number of bytes written - * @see ucx_fprintf() - */ -int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap); - -/** - * A printf() like function which allocates space for a sstr_t - * the result is written to. - * - * Attention: The sstr_t data is allocated with the allocators - * ucx_allocator_malloc() function. So it is implementation dependent, if - * the returned sstr_t.ptr pointer must be passed to the allocators - * ucx_allocator_free() function manually. - * - * Note: The sstr_t.ptr of the return value will always be - * NULL-terminated. - * - * @param allocator the UcxAllocator used for allocating the result sstr_t - * @param fmt format string - * @param ... additional arguments - * @return a sstr_t containing the formatted string - */ -sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt, ...); - -/** - * va_list version of ucx_asprintf(). - * - * @param allocator the UcxAllocator used for allocating the result sstr_t - * @param fmt format string - * @param ap argument list - * @return a sstr_t containing the formatted string - * @see ucx_asprintf() - */ -sstr_t ucx_vasprintf(UcxAllocator *allocator, const char *fmt, va_list ap); - -/** Shortcut for ucx_asprintf() with default allocator. */ -#define ucx_sprintf(...) \ - ucx_asprintf(ucx_default_allocator(), __VA_ARGS__) - -/** - * A printf() like function which writes the output to a - * UcxBuffer. - * - * @param buffer the buffer the data is written to - * @param ... format string and additional arguments - * @return the total number of bytes written - * @see ucx_fprintf() - */ -#define ucx_bprintf(buffer, ...) ucx_fprintf((UcxBuffer*)buffer, \ - (write_func)ucx_buffer_write, __VA_ARGS__) - -#ifdef __cplusplus -} -#endif - -#endif /* UCX_UTILS_H */ - diff -r 92e482410453 -r d345541018fa src/utils.c --- a/src/utils.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,448 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "ucx/utils.h" - -#include -#include -#include -#include - -/* COPY FUCNTIONS */ -void* ucx_strcpy(const void* s, void* data) { - const char *str = (const char*) s; - size_t n = 1+strlen(str); - char *cpy = (char*) malloc(n); - memcpy(cpy, str, n); - return cpy; -} - -void* ucx_memcpy(const void* m, void* n) { - size_t k = *((size_t*)n); - void *cpy = malloc(k); - memcpy(cpy, m, k); - return cpy; -} - -size_t ucx_stream_bncopy(void *src, void *dest, read_func readfnc, - write_func writefnc, char* buf, size_t bufsize, size_t n) { - if(n == 0 || bufsize == 0) { - return 0; - } - - char *lbuf; - size_t ncp = 0; - - if(buf) { - lbuf = buf; - } else { - lbuf = (char*)malloc(bufsize); - if(lbuf == NULL) { - return 0; - } - } - - size_t r; - size_t rn = bufsize > n ? n : bufsize; - while((r = readfnc(lbuf, 1, rn, src)) != 0) { - r = writefnc(lbuf, 1, r, dest); - ncp += r; - n -= r; - rn = bufsize > n ? n : bufsize; - if(r == 0 || n == 0) { - break; - } - } - - if (lbuf != buf) { - free(lbuf); - } - - return ncp; -} - -/* COMPARE FUNCTIONS */ - -int ucx_cmp_str(const void *s1, const void *s2, void *data) { - return strcmp((const char*)s1, (const char*)s2); -} - -int ucx_cmp_strn(const void *s1, const void *s2, void *n) { - return strncmp((const char*)s1, (const char*)s2, *((size_t*) n)); -} - -int ucx_cmp_sstr(const void *s1, const void *s2, void *data) { - sstr_t a = *(const sstr_t*) s1; - sstr_t b = *(const sstr_t*) s2; - return sstrcmp(a, b); -} - -int ucx_cmp_int(const void *i1, const void *i2, void *data) { - int a = *((const int*) i1); - int b = *((const int*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_longint(const void *i1, const void *i2, void *data) { - long int a = *((const long int*) i1); - long int b = *((const long int*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_longlong(const void *i1, const void *i2, void *data) { - long long a = *((const long long*) i1); - long long b = *((const long long*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_int16(const void *i1, const void *i2, void *data) { - int16_t a = *((const int16_t*) i1); - int16_t b = *((const int16_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_int32(const void *i1, const void *i2, void *data) { - int32_t a = *((const int32_t*) i1); - int32_t b = *((const int32_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_int64(const void *i1, const void *i2, void *data) { - int64_t a = *((const int64_t*) i1); - int64_t b = *((const int64_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_uint(const void *i1, const void *i2, void *data) { - unsigned int a = *((const unsigned int*) i1); - unsigned int b = *((const unsigned int*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_ulongint(const void *i1, const void *i2, void *data) { - unsigned long int a = *((const unsigned long int*) i1); - unsigned long int b = *((const unsigned long int*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_ulonglong(const void *i1, const void *i2, void *data) { - unsigned long long a = *((const unsigned long long*) i1); - unsigned long long b = *((const unsigned long long*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_uint16(const void *i1, const void *i2, void *data) { - uint16_t a = *((const uint16_t*) i1); - uint16_t b = *((const uint16_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_uint32(const void *i1, const void *i2, void *data) { - uint32_t a = *((const uint32_t*) i1); - uint32_t b = *((const uint32_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_uint64(const void *i1, const void *i2, void *data) { - uint64_t a = *((const uint64_t*) i1); - uint64_t b = *((const uint64_t*) i2); - if (a == b) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -intmax_t ucx_dist_int(const void *i1, const void *i2, void *data) { - intmax_t a = *((const int*) i1); - intmax_t b = *((const int*) i2); - return a - b; -} - -intmax_t ucx_dist_longint(const void *i1, const void *i2, void *data) { - intmax_t a = *((const long int*) i1); - intmax_t b = *((const long int*) i2); - return a - b; -} - -intmax_t ucx_dist_longlong(const void *i1, const void *i2, void *data) { - intmax_t a = *((const long long*) i1); - intmax_t b = *((const long long*) i2); - return a - b; -} - -intmax_t ucx_dist_int16(const void *i1, const void *i2, void *data) { - intmax_t a = *((const int16_t*) i1); - intmax_t b = *((const int16_t*) i2); - return a - b; -} - -intmax_t ucx_dist_int32(const void *i1, const void *i2, void *data) { - intmax_t a = *((const int32_t*) i1); - intmax_t b = *((const int32_t*) i2); - return a - b; -} - -intmax_t ucx_dist_int64(const void *i1, const void *i2, void *data) { - intmax_t a = *((const int64_t*) i1); - intmax_t b = *((const int64_t*) i2); - return a - b; -} - -intmax_t ucx_dist_uint(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const unsigned int*) i1); - uintmax_t b = *((const unsigned int*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -intmax_t ucx_dist_ulongint(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const unsigned long int*) i1); - uintmax_t b = *((const unsigned long int*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -intmax_t ucx_dist_ulonglong(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const unsigned long long*) i1); - uintmax_t b = *((const unsigned long long*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -intmax_t ucx_dist_uint16(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const uint16_t*) i1); - uintmax_t b = *((const uint16_t*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -intmax_t ucx_dist_uint32(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const uint32_t*) i1); - uintmax_t b = *((const uint32_t*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -intmax_t ucx_dist_uint64(const void *i1, const void *i2, void *data) { - uintmax_t a = *((const uint64_t*) i1); - uintmax_t b = *((const uint64_t*) i2); - return a > b ? (intmax_t)(a - b) : -(intmax_t)(b - a); -} - -int ucx_cmp_float(const void *f1, const void *f2, void *epsilon) { - float a = *((const float*) f1); - float b = *((const float*) f2); - float e = !epsilon ? 1e-6f : *((float*)epsilon); - if (fabsf(a - b) < e) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_double(const void *d1, const void *d2, void *epsilon) { - double a = *((const double*) d1); - double b = *((const double*) d2); - double e = !epsilon ? 1e-14 : *((double*)epsilon); - if (fabs(a - b) < e) { - return 0; - } else { - return a < b ? -1 : 1; - } -} - -int ucx_cmp_ptr(const void *ptr1, const void *ptr2, void *data) { - const intptr_t p1 = (const intptr_t) ptr1; - const intptr_t p2 = (const intptr_t) ptr2; - if (p1 == p2) { - return 0; - } else { - return p1 < p2 ? -1 : 1; - } -} - -int ucx_cmp_mem(const void *ptr1, const void *ptr2, void *n) { - return memcmp(ptr1, ptr2, *((size_t*)n)); -} - -/* PRINTF FUNCTIONS */ - -#ifdef va_copy -#define UCX_PRINTF_BUFSIZE 256 -#else -#pragma message("WARNING: C99 va_copy macro not supported by this platform" \ - " - limiting ucx_*printf to 2 KiB") -#define UCX_PRINTF_BUFSIZE 0x800 -#endif - -int ucx_fprintf(void *stream, write_func wfc, const char *fmt, ...) { - int ret; - va_list ap; - va_start(ap, fmt); - ret = ucx_vfprintf(stream, wfc, fmt, ap); - va_end(ap); - return ret; -} - -int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap) { - char buf[UCX_PRINTF_BUFSIZE]; -#ifdef va_copy - va_list ap2; - va_copy(ap2, ap); - int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap); - if (ret < 0) { - return ret; - } else if (ret < UCX_PRINTF_BUFSIZE) { - return (int)wfc(buf, 1, ret, stream); - } else { - if (ret == INT_MAX) { - errno = ENOMEM; - return -1; - } - - int len = ret + 1; - char *newbuf = (char*)malloc(len); - if (!newbuf) { - return -1; - } - - ret = vsnprintf(newbuf, len, fmt, ap2); - if (ret > 0) { - ret = (int)wfc(newbuf, 1, ret, stream); - } - free(newbuf); - } - return ret; -#else - int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap); - if (ret < 0) { - return ret; - } else if (ret < UCX_PRINTF_BUFSIZE) { - return (int)wfc(buf, 1, ret, stream); - } else { - errno = ENOMEM; - return -1; - } -#endif -} - -sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt, ...) { - va_list ap; - sstr_t ret; - va_start(ap, fmt); - ret = ucx_vasprintf(allocator, fmt, ap); - va_end(ap); - return ret; -} - -sstr_t ucx_vasprintf(UcxAllocator *a, const char *fmt, va_list ap) { - sstr_t s; - s.ptr = NULL; - s.length = 0; - char buf[UCX_PRINTF_BUFSIZE]; -#ifdef va_copy - va_list ap2; - va_copy(ap2, ap); - int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap); - if (ret > 0 && ret < UCX_PRINTF_BUFSIZE) { - s.ptr = (char*)almalloc(a, ret + 1); - if (s.ptr) { - s.length = (size_t)ret; - memcpy(s.ptr, buf, ret); - s.ptr[s.length] = '\0'; - } - } else if (ret == INT_MAX) { - errno = ENOMEM; - } else { - int len = ret + 1; - s.ptr = (char*)almalloc(a, len); - if (s.ptr) { - ret = vsnprintf(s.ptr, len, fmt, ap2); - if (ret < 0) { - free(s.ptr); - s.ptr = NULL; - } else { - s.length = (size_t)ret; - } - } - } -#else - int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap); - if (ret > 0 && ret < UCX_PRINTF_BUFSIZE) { - s.ptr = (char*)almalloc(a, ret + 1); - if (s.ptr) { - s.length = (size_t)ret; - memcpy(s.ptr, buf, ret); - s.ptr[s.length] = '\0'; - } - } else { - errno = ENOMEM; - } -#endif - return s; -} diff -r 92e482410453 -r d345541018fa test/CMakeLists.txt --- a/test/CMakeLists.txt Mon Dec 30 09:54:10 2019 +0100 +++ b/test/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 @@ -1,17 +1,6 @@ -add_executable(ucxtest - allocator_tests.c - array_tests.c - avl_tests.c - buffer_tests.c - list_tests.c - logging_tests.c - main.c - map_tests.c - mpool_tests.c - prop_tests.c - stack_tests.c - string_tests.c - utils_tests.c + +add_executable(test_list + test_list.c ) - -target_link_libraries(ucxtest PRIVATE ucx_static) +target_link_libraries(test_list PRIVATE ucx_static) +add_test(NAME list COMMAND test_list WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") diff -r 92e482410453 -r d345541018fa test/Makefile.am --- a/test/Makefile.am Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. -# -# Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# - -TESTS = ucxtest -check_PROGRAMS = ucxtest -ucxtest_CFLAGS = -I$(top_srcdir)/src - -ucxtest_SOURCES = main.c -ucxtest_SOURCES += allocator_tests.c -ucxtest_SOURCES += array_tests.c -ucxtest_SOURCES += list_tests.c -ucxtest_SOURCES += avl_tests.c -ucxtest_SOURCES += mpool_tests.c -ucxtest_SOURCES += stack_tests.c -ucxtest_SOURCES += map_tests.c -ucxtest_SOURCES += prop_tests.c -ucxtest_SOURCES += string_tests.c -ucxtest_SOURCES += logging_tests.c -ucxtest_SOURCES += buffer_tests.c -ucxtest_SOURCES += utils_tests.c - -ucxtest_SOURCES += main.h -ucxtest_SOURCES += allocator_tests.h -ucxtest_SOURCES += array_tests.h -ucxtest_SOURCES += list_tests.h -ucxtest_SOURCES += avl_tests.h -ucxtest_SOURCES += mpool_tests.h -ucxtest_SOURCES += stack_tests.h -ucxtest_SOURCES += map_tests.h -ucxtest_SOURCES += prop_tests.h -ucxtest_SOURCES += string_tests.h -ucxtest_SOURCES += logging_tests.h -ucxtest_SOURCES += buffer_tests.h -ucxtest_SOURCES += utils_tests.h - -ucxtest_LDFLAGS = -static -ucxtest_LDADD = ../src/libucx.la diff -r 92e482410453 -r d345541018fa test/allocator_tests.c --- a/test/allocator_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,41 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "allocator_tests.h" - -UCX_TEST(test_ucx_default_allocator) { - UcxAllocator *alloc = ucx_default_allocator(); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(alloc->pool == NULL, "pool must be NULL"); - UCX_TEST_ASSERT(alloc->malloc == ucx_default_malloc, "wrong malloc"); - UCX_TEST_ASSERT(alloc->calloc == ucx_default_calloc, "wrong calloc"); - UCX_TEST_ASSERT(alloc->realloc == ucx_default_realloc, "wrong realloc"); - UCX_TEST_ASSERT(alloc->free == ucx_default_free, "wrong free"); - UCX_TEST_END -} diff -r 92e482410453 -r d345541018fa test/allocator_tests.h --- a/test/allocator_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,46 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef ALLOCATOR_TEST_H -#define ALLOCATOR_TEST_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_default_allocator); - -#ifdef __cplusplus -} -#endif - -#endif /* ALLOCATOR_TEST_H */ - diff -r 92e482410453 -r d345541018fa test/array_tests.c --- a/test/array_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,642 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "array_tests.h" -#include - -UCX_TEST(test_ucx_array_destroy) { - UcxArray array; - ucx_array_init(&array, 16, sizeof(int)); - - UCX_TEST_BEGIN - ucx_array_destroy(&array); - UCX_TEST_ASSERT(array.data == NULL, "data pointer not NULL after destroy"); - UCX_TEST_ASSERT(array.size == 0, "size not zero after destroy"); - UCX_TEST_ASSERT(array.capacity == 0, "capacity not zero after destroy"); - UCX_TEST_ASSERT(array.allocator == ucx_default_allocator(), - "allocator corrupted during destroy"); - UCX_TEST_END -} - -UCX_TEST(test_ucx_array_new) { - UcxArray* array = ucx_array_new(16, 47); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(array->data, "no memory allocated"); - UCX_TEST_ASSERT(array->size == 0, "size not initially zero"); - UCX_TEST_ASSERT(array->capacity == 16, "capacity not as requested"); - UCX_TEST_ASSERT(array->elemsize == 47, "element size not as requested"); - UCX_TEST_ASSERT(array->allocator == ucx_default_allocator(), - "array not using the default allocator"); - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_append_from) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - int *elements; - - int x = 42; - ucx_array_append_from(array, &x, 1); - UCX_TEST_BEGIN - - elements = array->data; - UCX_TEST_ASSERT(elements[0] == 42, "failed"); - - int y[2] = {13, 37}; - ucx_array_append_from(array, y, 2); - - elements = array->data; - UCX_TEST_ASSERT(array->size == 3, "incorrect size after append"); - UCX_TEST_ASSERT(elements[1] == 13, "failed"); - UCX_TEST_ASSERT(elements[2] == 37, "failed"); - UCX_TEST_ASSERT(elements[0] == 42, - "append corrupted previously inserted data"); - - ucx_array_append_from(array, NULL, 2); - - elements = array->data; - UCX_TEST_ASSERT(array->size == 5, "incorrect size after NULL append"); - UCX_TEST_ASSERT(elements[3] == 0, "element is not zeroed"); - UCX_TEST_ASSERT(elements[4] == 0, "element is not zeroed"); - UCX_TEST_ASSERT(elements[0] == 42, - "NULL append corrupted previously inserted data"); - UCX_TEST_ASSERT(elements[1] == 13, - "NULL append corrupted previously inserted data"); - UCX_TEST_ASSERT(elements[2] == 37, - "NULL append corrupted previously inserted data"); - - UCX_TEST_END - - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_append_from_struct) { - struct teststruct { - unsigned long long x; - unsigned long long y; - unsigned long long z; - }; - - UcxArray *array = ucx_array_new(16, sizeof(struct teststruct)); - struct teststruct *elements; - - struct teststruct data; - data.x = 13; data.y = 37; data.z = 47; - - ucx_array_append_from(array, &data, 1); - UCX_TEST_BEGIN - - elements = array->data; - UCX_TEST_ASSERT(elements[0].x == 13, "failed"); - UCX_TEST_ASSERT(elements[0].y == 37, "failed"); - UCX_TEST_ASSERT(elements[0].z == 47, "failed"); - - data.x = 0; data.y = 8; data.z = 15; - ucx_array_append_from(array, &data, 1); - - elements = array->data; - UCX_TEST_ASSERT(array->size == 2, "incorrect size after append"); - UCX_TEST_ASSERT(elements[1].x == 0, "failed"); - UCX_TEST_ASSERT(elements[1].y == 8, "failed"); - UCX_TEST_ASSERT(elements[1].z == 15, "failed"); - - UCX_TEST_ASSERT(elements[0].x == 13, - "append corrupted previously inserted data"); - UCX_TEST_ASSERT(elements[0].y == 37, - "append corrupted previously inserted data"); - UCX_TEST_ASSERT(elements[0].z == 47, - "append corrupted previously inserted data"); - - UCX_TEST_END - - ucx_array_destroy(array); -} - -UCX_TEST(test_ucx_array_prepend_from) { - int *elems; - UcxArray *array = ucx_array_new(16, sizeof(int)); - - int x = 42; - ucx_array_prepend_from(array, &x, 1); - UCX_TEST_BEGIN - - elems = array->data; - UCX_TEST_ASSERT(elems[0] == 42, "failed"); - - int y[2] = {13, 37}; - ucx_array_prepend_from(array, y, 2); - - elems = array->data; - UCX_TEST_ASSERT(array->size == 3, "incorrect size after prepend"); - UCX_TEST_ASSERT(elems[0] == 13, "failed"); - UCX_TEST_ASSERT(elems[1] == 37, "failed"); - UCX_TEST_ASSERT(elems[2] == 42, - "prepend corrupted previously inserted data"); - - ucx_array_prepend_from(array, NULL, 2); - - elems = array->data; - UCX_TEST_ASSERT(array->size == 5, "incorrect size after NULL prepend"); - UCX_TEST_ASSERT(elems[0] == 0, "element is not zeroed"); - UCX_TEST_ASSERT(elems[1] == 0, "element is not zeroed"); - UCX_TEST_ASSERT(elems[2] == 13, - "NULL prepend corrupted previously inserted data"); - UCX_TEST_ASSERT(elems[3] == 37, - "NULL prepend corrupted previously inserted data"); - UCX_TEST_ASSERT(elems[4] == 42, - "NULL prepend corrupted previously inserted data"); - - UCX_TEST_END - - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_set_from) { - int *elems; - UcxArray *array = ucx_array_new(16, sizeof(int)); - - int x = 42; - - UCX_TEST_BEGIN - - ucx_array_set_from(array, 7, &x, 1); - - elems = array->data; - UCX_TEST_ASSERT(elems[7] == 42, "failed"); - UCX_TEST_ASSERT(array->size >= 8, "array not resized on set"); - UCX_TEST_ASSERT(array->capacity == 16, "capacity changed unnecessarily"); - - int y[2] = {13, 37}; - ucx_array_set_from(array, 27, y, 2); - - elems = array->data; - UCX_TEST_ASSERT(elems[27] == 13, "failed"); - UCX_TEST_ASSERT(elems[28] == 37, "failed"); - UCX_TEST_ASSERT(array->size == 29, "array not resized on set"); - UCX_TEST_ASSERT(array->capacity == 32, "capacity not grown"); - - ucx_array_set_from(array, 7, NULL, 2); - - elems = array->data; - UCX_TEST_ASSERT(elems[7] == 0, "not zeroed on NULL set"); - UCX_TEST_ASSERT(elems[8] == 0, "not zeroed on NULL set"); - - UCX_TEST_END - - ucx_array_free(array); -} - - -UCX_TEST(test_ucx_array_equals) { - UcxArray *a1 = ucx_array_new(16, sizeof(int32_t)); - UcxArray *a2 = ucx_array_new(16, sizeof(int32_t)); - UcxArray *a3 = ucx_array_new(16, sizeof(int64_t)); - UcxArray *a4 = ucx_array_new(16, sizeof(int32_t)); - - int32_t *intelems; - int64_t *longintelems; - - a1->size = 5; - intelems = a1->data; - intelems[0] = 47; - intelems[1] = 11; - intelems[2] = 0; - intelems[3] = 8; - intelems[4] = 15; - a2->size = 5; - intelems = a2->data; - intelems[0] = 47; - intelems[1] = 11; - intelems[2] = 0; - intelems[3] = 8; - intelems[4] = 15; - a3->size = 5; - longintelems = a3->data; - longintelems[0] = 47; - longintelems[1] = 11; - longintelems[2] = 0; - longintelems[3] = 8; - longintelems[4] = 15; - a4->size = 5; - intelems = a4->data; - intelems[0] = 47; - intelems[1] = 11; - intelems[2] = -6; - intelems[3] = 8; - intelems[4] = 15; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_array_equals(a1, a2, ucx_cmp_int32, NULL), "failed"); - UCX_TEST_ASSERT(!ucx_array_equals(a1, a4, ucx_cmp_int32, NULL), "failed"); - UCX_TEST_ASSERT(!ucx_array_equals(a4, a1, ucx_cmp_int32, NULL), "failed"); - UCX_TEST_ASSERT(!ucx_array_equals(a1, a3, ucx_cmp_int64, NULL), - "comparing arrays of different element size shall fail"); - UCX_TEST_ASSERT(!ucx_array_equals(a3, a1, ucx_cmp_int64, NULL), - "comparing arrays of different element size shall fail"); - - UCX_TEST_ASSERT(ucx_array_equals(a1, a2, NULL, NULL), - "compare using memcmp() failed"); - UCX_TEST_ASSERT(!ucx_array_equals(a1, a4, NULL, NULL), - "compare using memcmp() failed"); - - UCX_TEST_END - ucx_array_free(a1); - ucx_array_free(a2); - ucx_array_free(a3); - ucx_array_free(a4); -} - -UCX_TEST(test_ucx_array_concat) { - UcxArray *a1 = ucx_array_new(16, sizeof(int)); - UcxArray *a2 = ucx_array_new(16, sizeof(int)); - int *elems; - - a1->size = 2; - elems = a1->data; - elems[0] = 47; - elems[1] = 11; - a2->size = 3; - elems = a2->data; - elems[0] = 0; - elems[1] = 8; - elems[2] = 15; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!ucx_array_concat(a1, a2), "failed"); - UCX_TEST_ASSERT(a1->size == 5, "failed"); - elems = a1->data; - UCX_TEST_ASSERT(elems[0] == 47, "failed"); - UCX_TEST_ASSERT(elems[1] == 11, "failed"); - UCX_TEST_ASSERT(elems[2] == 0, "failed"); - UCX_TEST_ASSERT(elems[3] == 8, "failed"); - UCX_TEST_ASSERT(elems[4] == 15, "failed"); - - a1->elemsize *= 2; - UCX_TEST_ASSERT(ucx_array_concat(a1, a2), - "arrays of different element size must not be concatenated"); - UCX_TEST_ASSERT(a1->size == 5, - "arrays of different element size must not be concatenated"); - - UCX_TEST_END - ucx_array_free(a1); - ucx_array_free(a2); -} - -UCX_TEST(test_ucx_array_at) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - - int x[3] = {42, 13, 5}; - ucx_array_append_from(array, x, 3); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(*(int*)ucx_array_at(array, 1) == 13, "failed"); - *(int*)ucx_array_at(array, 1) = 80; - UCX_TEST_ASSERT(*(int*)ucx_array_at(array, 1) == 80, "assignment failed"); - - UCX_TEST_ASSERT(*(int*)ucx_array_at(array, 0) == 42, "corrupted data"); - UCX_TEST_ASSERT(*(int*)ucx_array_at(array, 2) == 5, "corrupted data"); - - UCX_TEST_END - - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_find) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - int *elems; - - array->size = 5; - elems = array->data; - elems[0] = 47; - elems[1] = 11; - elems[2] = 0; - elems[3] = 8; - elems[4] = 15; - - int x = 8; - int y = 90; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_array_find(array,(void*)&x,ucx_cmp_int,NULL) == 3, - "doesn't find element"); - UCX_TEST_ASSERT(ucx_array_find(array,(void*)&y,ucx_cmp_int,NULL) == 5, - "finds non-existing element"); - - UCX_TEST_ASSERT(ucx_array_find(array,(void*)&x,NULL,NULL) == 3, - "failed using memcmp()"); - UCX_TEST_ASSERT(ucx_array_find(array,(void*)&y,NULL,NULL) == 5, - "failed using memcmp()"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_contains) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - int *elems; - - array->size = 5; - elems = array->data; - elems[0] = 47; - elems[1] = 11; - elems[2] = 0; - elems[3] = 8; - elems[4] = 15; - - int x = 8; - int y = 90; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_array_contains(array,(void*)&x,ucx_cmp_int,NULL), - "false negative"); - UCX_TEST_ASSERT(!ucx_array_contains(array,(void*)&y,ucx_cmp_int,NULL), - "false positive"); - - UCX_TEST_ASSERT(ucx_array_contains(array,(void*)&x,NULL,NULL), - "false negative using memcmp()"); - UCX_TEST_ASSERT(!ucx_array_contains(array,(void*)&y,NULL,NULL), - "false positive using memcmp()"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_remove) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - int *elems; - - array->size = 5; - elems = array->data; - elems[0] = 47; - elems[1] = 11; - elems[2] = 0; - elems[3] = 8; - elems[4] = 15; - - UCX_TEST_BEGIN - - ucx_array_remove(array, 2); - elems = array->data; - UCX_TEST_ASSERT( - elems[0] == 47 && - elems[1] == 11 && - elems[2] == 8 && - elems[3] == 15, - "wrong contents after remove"); - UCX_TEST_ASSERT(array->size == 4, "wrong size after remove"); - - ucx_array_remove_fast(array, 1); - elems = array->data; - UCX_TEST_ASSERT( - elems[0] == 47 && - elems[1] == 15 && - elems[2] == 8, - "wrong contents after fast remove"); - UCX_TEST_ASSERT(array->size == 3, "wrong size after fast remove"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_clone) { - UcxArray array; - UcxArray copy; - ucx_array_init(&array, 16, sizeof(int)); - ucx_array_init(©, 4, 2*sizeof(double)); - int *elems; - - array.size = 5; - elems = array.data; - elems[0] = 47; - elems[1] = 11; - elems[2] = 0; - elems[3] = 8; - elems[4] = 15; - - ucx_array_clone(©, &array); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(array.data != copy.data, "no true copy"); - UCX_TEST_ASSERT(array.size == copy.size, "size mismatch"); - UCX_TEST_ASSERT(array.capacity == copy.capacity, "capacity mismatch"); - UCX_TEST_ASSERT(array.elemsize == copy.elemsize, "element size mismatch"); - UCX_TEST_ASSERT(array.allocator == copy.allocator, "allocator mismatch"); - UCX_TEST_ASSERT(ucx_array_equals(&array, ©, ucx_cmp_int, NULL), - "contents do not match after clone"); - - UCX_TEST_END - - ucx_array_destroy(&array); - ucx_array_destroy(©); -} - -static int ucx_cmp_int_reverse(const void* x, const void* y, void* data) { - return -ucx_cmp_int(x,y,data); -} - -UCX_TEST(test_ucx_array_sort) { - int *elems; - - UcxArray *array = ucx_array_new(16, sizeof(int)); - array->size = 5; - elems = array->data; - elems[0] = 47; - elems[1] = 11; - elems[2] = 0; - elems[3] = 8; - elems[4] = 15; - - UcxArray *expected = ucx_array_new(16, sizeof(int)); - expected->size = 5; - elems = expected->data; - elems[0] = 0; - elems[1] = 8; - elems[2] = 11; - elems[3] = 15; - elems[4] = 47; - - UcxArray *expectedrev = ucx_array_new(16, sizeof(int)); - expectedrev->size = 5; - elems = expectedrev->data; - elems[0] = 47; - elems[1] = 15; - elems[2] = 11; - elems[3] = 8; - elems[4] = 0; - - - UCX_TEST_BEGIN - void* original_ptr = array->data; - ucx_array_sort(array, ucx_cmp_int, NULL); - UCX_TEST_ASSERT(ucx_array_equals(array, expected, NULL, NULL), "failed"); - UCX_TEST_ASSERT(array->size == 5, "size corrupted"); - UCX_TEST_ASSERT(array->data == original_ptr, "shall not reallocate"); - - ucx_array_sort(array, ucx_cmp_int_reverse, NULL); - UCX_TEST_ASSERT(ucx_array_equals(array, expectedrev, NULL, NULL), "failed"); - - ucx_array_reserve(array, 32); - ucx_array_reserve(expected, 32); - array->size = expected->size = 32; - for (size_t i = 0 ; i < 32 ; i++) { - ((int*)array->data)[i]= ((i%2==0)?-1:1) * ((int) i); - ((int*)expected->data)[i] = (-30+2*i) - (i > 15 ? 1 : 0); - } - - /* dummy third argument to trigger a possible fallback for qsort_s */ - ucx_array_sort(array, ucx_cmp_int, array->data); - UCX_TEST_ASSERT(ucx_array_equals(array, expected, NULL, NULL), - "failed for bigger arrays"); - UCX_TEST_END - - ucx_array_free(expectedrev); - ucx_array_free(expected); - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_shrink) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - array->size = 4; - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(!ucx_array_shrink(array), "failed"); - UCX_TEST_ASSERT(array->capacity == 4, "incorrect capacity after shrink"); - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_resize) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - array->size = 8; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!ucx_array_resize(array, 32), "failed"); - UCX_TEST_ASSERT(array->capacity == 32, "incorrect capacity after resize"); - UCX_TEST_ASSERT(array->size == 8, "incorrect size after resize"); - - UCX_TEST_ASSERT(!ucx_array_resize(array, 4), "failed"); - UCX_TEST_ASSERT(array->capacity == 4, "incorrect capacity after resize"); - UCX_TEST_ASSERT(array->size == 4, "incorrect size after resize"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_reserve) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!ucx_array_reserve(array, 4), "failed"); - UCX_TEST_ASSERT(array->capacity == 16, "reserve shall not shrink"); - - UCX_TEST_ASSERT(!ucx_array_resize(array, 32), "failed"); - UCX_TEST_ASSERT(array->capacity == 32, "incorrect capacity after reserve"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_grow) { - UcxArray *array = ucx_array_new(16, sizeof(int)); - array->size = 12; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!ucx_array_grow(array, 4), "failed"); - UCX_TEST_ASSERT(array->capacity == 16, "shall be noop if contents fit"); - /* subsequent calls shall also be noops */ - UCX_TEST_ASSERT(!ucx_array_grow(array, 4), "failed"); - UCX_TEST_ASSERT(array->capacity == 16, "shall be noop if contents fit"); - - UCX_TEST_ASSERT(!ucx_array_grow(array, 6), "failed"); - UCX_TEST_ASSERT(array->capacity == 18, "incorrect capacity after grow"); - - UCX_TEST_END - ucx_array_free(array); -} - -UCX_TEST(test_ucx_array_util_set) { - size_t capacity = 16; - int* array = malloc(sizeof(int)*capacity); - int x; - - UCX_TEST_BEGIN - - x = 42; - ucx_array_util_set(&array, &capacity, sizeof(int), 7, &x); - - UCX_TEST_ASSERT(array[7] == 42, "failed"); - UCX_TEST_ASSERT(capacity == 16, "capacity changed unnecessarily"); - - x = 13; - ucx_array_util_set(&array, &capacity, sizeof(int), 37, &x); - x = 37; - ucx_array_util_set(&array, &capacity, sizeof(int), 38, &x); - - UCX_TEST_ASSERT(array[37] == 13, "failed"); - UCX_TEST_ASSERT(array[38] == 37, "failed"); - UCX_TEST_ASSERT(capacity == 64, "capacity not grown"); - - UCX_TEST_END - - free(array); -} - - -UCX_TEST(test_ucx_array_util_setptr) { - size_t capacity = 16; - double** array = malloc(sizeof(double*)*capacity); - double x, y, z; - - UCX_TEST_BEGIN - - ucx_array_util_setptr(&array, &capacity, 7, &x); - - UCX_TEST_ASSERT(array[7] == &x, "failed"); - UCX_TEST_ASSERT(capacity == 16, "capacity changed unnecessarily"); - - ucx_array_util_setptr(&array, &capacity, 37, &y); - ucx_array_util_setptr(&array, &capacity, 38, &z); - - UCX_TEST_ASSERT(array[37] == &y, "failed"); - UCX_TEST_ASSERT(array[38] == &z, "failed"); - UCX_TEST_ASSERT(capacity == 64, "capacity not grown"); - - UCX_TEST_END - - free(array); -} - diff -r 92e482410453 -r d345541018fa test/array_tests.h --- a/test/array_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,65 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef ARRAY_TESTS_H -#define ARRAY_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_array_destroy); -UCX_TEST(test_ucx_array_new); -UCX_TEST(test_ucx_array_at); -UCX_TEST(test_ucx_array_append_from); -UCX_TEST(test_ucx_array_append_from_struct); -UCX_TEST(test_ucx_array_prepend_from); -UCX_TEST(test_ucx_array_set_from); -UCX_TEST(test_ucx_array_equals); -UCX_TEST(test_ucx_array_concat); -UCX_TEST(test_ucx_array_find); -UCX_TEST(test_ucx_array_contains); -UCX_TEST(test_ucx_array_remove); -UCX_TEST(test_ucx_array_clone); -UCX_TEST(test_ucx_array_sort); -UCX_TEST(test_ucx_array_shrink); -UCX_TEST(test_ucx_array_resize); -UCX_TEST(test_ucx_array_reserve); -UCX_TEST(test_ucx_array_grow); -UCX_TEST(test_ucx_array_util_set); -UCX_TEST(test_ucx_array_util_setptr); - -#ifdef __cplusplus -} -#endif - -#endif /* ARRAY_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/avl_tests.c --- a/test/avl_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,335 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "avl_tests.h" - -#include - -static int node_height(UcxAVLNode *node) { - if(!node) { - return 0; - } - - int left = 0; - int right = 0; - if(node->left) { - left = node_height(node->left); - } - if(node->right) { - right = node_height(node->right); - } - - return left > right ? left+1 : right+1; -} - -static int check_tree(UcxAVLNode *node) { - if(!node) { - return 1; - } - - int left_height = node_height(node->left); - int right_height = node_height(node->right); - int bf = -left_height + right_height; - if(bf < -1 || bf > 1) { - return 0; - } - int height = left_height > right_height ? left_height : right_height; - height++; - if(height != node->height) { - return 0; - } - - if(!check_tree(node->left)) { - return 0; - } - if(!check_tree(node->right)) { - return 0; - } - - return 1; -} - -UCX_TEST(test_ucx_avl_put) { - UcxAVLTree *tree1 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree2 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree3 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree4 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree5 = ucx_avl_new(ucx_cmp_ptr); - - char *data1 = (char*)"data1"; - char *data2 = (char*)"data2"; - char *data3 = (char*)"data3"; - - UCX_TEST_BEGIN - - ucx_avl_put(tree1, 2, (char*)data2); - ucx_avl_put(tree1, 1, (char*)data1); - ucx_avl_put(tree1, 3, (char*)data3); - - UCX_TEST_ASSERT(check_tree(tree1->root), "check_tree failed (tree1)"); - UCX_TEST_ASSERT(ucx_avl_get(tree1, 1) == data1, "wrong data (tree1)"); - UCX_TEST_ASSERT(ucx_avl_get(tree1, 2) == data2, "wrong data (tree1)"); - UCX_TEST_ASSERT(ucx_avl_get(tree1, 3) == data3, "wrong data (tree1)"); - - for(int i=0;i<100000;i++) { - ucx_avl_put(tree2, i, data1); - } - UCX_TEST_ASSERT(check_tree(tree2->root), "check_tree failed (tree2)"); - - for(int i=100000;i>=0;i--) { - ucx_avl_put(tree3, i, data1); - } - UCX_TEST_ASSERT(check_tree(tree3->root), "check_tree failed (tree3)"); - - for(int i=0;i<100;i++) { - ucx_avl_put(tree4, i, data1); - } - for(int i=400;i<500;i++) { - ucx_avl_put(tree4, i, data2); - } - for(int i=399;i>200;i--) { - ucx_avl_put(tree4, i, data3); - } - for(int i=800;i<1000;i++) { - ucx_avl_put(tree4, i, data1); - } - UCX_TEST_ASSERT(check_tree(tree4->root), "check_tree failed (tree4)"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 0) == data1, "wrong data for key: 0"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 1) == data1, "wrong data for key: 1"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 99) == data1, "wrong data for key: 99"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 400)==data2, "wrong data for key: 400"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 410)==data2, "wrong data for key: 410"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 350)==data3, "wrong data for key: 350"); - UCX_TEST_ASSERT(ucx_avl_get(tree4, 900)==data1, "wrong data for key: 900"); - - int values[] = { 3, 6, 12, 9, 23, 1, 0, 20, 34, 5, 8, 7, 6, 14, 15, 2, 4}; - int len = sizeof(values) / sizeof(int); - for(int i=0;iroot), "check_tree failed (tree5)"); - - UCX_TEST_END - - ucx_avl_free(tree1); - ucx_avl_free(tree2); - ucx_avl_free(tree3); - ucx_avl_free(tree4); - ucx_avl_free(tree5); -} - -UCX_TEST(test_ucx_avl_remove) { - UcxAVLTree *tree1 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree2 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree3 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree4 = ucx_avl_new(ucx_cmp_ptr); - - char *data1 = (char*)"data1"; - char *data2 = (char*)"data2"; - char *data3 = (char*)"data3"; - - UCX_TEST_BEGIN - ucx_avl_put(tree1, 2, (char*)data2); - ucx_avl_put(tree1, 1, (char*)data1); - ucx_avl_put(tree1, 3, (char*)data3); - void *val; - ucx_avl_remove_s(tree1, 3, NULL, &val); - - UCX_TEST_ASSERT(check_tree(tree1->root), "check_tree failed (tree1)"); - UCX_TEST_ASSERT(val == data3, - "wrong return value for key: 1 (tree1)"); - UCX_TEST_ASSERT(ucx_avl_get(tree1, 3) == NULL, "value not removed (tree1)"); - - ucx_avl_remove_s(tree1, 2, NULL, &val); - UCX_TEST_ASSERT(val == data2, - "wrong return value for key: 2 (tree1)"); - UCX_TEST_ASSERT(check_tree(tree1->root), "check_tree failed (tree1)"); - - ucx_avl_remove_s(tree1, 1, NULL, &val); - UCX_TEST_ASSERT(val == data1, - "wrong return value for key: 1 (tree1)"); - UCX_TEST_ASSERT(check_tree(tree1->root), "check_tree failed (tree1)"); - UCX_TEST_ASSERT(tree1->root == NULL, "root not NULL (tree1)"); - - - for(int i=0;i<20;i++) { - if(i==10) { - ucx_avl_put(tree2, i, data3); - } else if(i==15) { - ucx_avl_put(tree2, i, data2); - } else { - ucx_avl_put(tree2, i, data1); - } - } - - ucx_avl_remove_s(tree2, 10, NULL, &val); - UCX_TEST_ASSERT(val == data3, - "wrong return value for key: 10 (tree2)"); - UCX_TEST_ASSERT(check_tree(tree2->root), "check_tree failed (tree2)"); - - ucx_avl_remove_s(tree2, 15, NULL, &val); - UCX_TEST_ASSERT(val == data2, - "wrong return value for key: 15 (tree2)"); - UCX_TEST_ASSERT(check_tree(tree2->root), "check_tree failed (tree2)"); - - for(int i=0;i<20;i++) { - ucx_avl_remove(tree2, i); - UCX_TEST_ASSERT(check_tree(tree2->root), "check_tree failed (tree2)"); - } - UCX_TEST_ASSERT(tree2->root == NULL, "root not NULL (tree2)"); - - for(int i=0;i<100000;i++) { - ucx_avl_put(tree3, i, data1); - } - for(int i=100000-1;i>=0;i--) { - ucx_avl_remove(tree3, i); - } - UCX_TEST_ASSERT(tree3->root == NULL, "root not NULL (tree3)"); - UCX_TEST_ASSERT(check_tree(tree3->root), "check_tree failed (tree3)"); - - ucx_avl_put(tree4, 1, data1); - ucx_avl_remove(tree4, 1); - UCX_TEST_ASSERT(check_tree(tree4->root), "check_tree failed (tree4)"); - UCX_TEST_ASSERT(tree4->root == NULL, "root not NULL (tree4)"); - UCX_TEST_END - - ucx_avl_free(tree1); - ucx_avl_free(tree2); - ucx_avl_free(tree3); - ucx_avl_free(tree4); -} - -static intmax_t dist_int(const void* a, const void* b, void* n) { - return ((intptr_t)a)-((intptr_t)b); -} - -UCX_TEST(test_ucx_avl_find) { - UcxAVLTree *tree = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree2 = ucx_avl_new(ucx_cmp_ptr); - UcxAVLTree *tree3 = ucx_avl_new(ucx_cmp_ptr); - - size_t len = 12; - int val[] = {10, 15, 3, 4, -30, 20, 14, -11, 12, -5, 1, 13}; - - for (size_t i = 0 ; i < len ; i++) { - ucx_avl_put(tree, val[i], &(val[i])); - } - - UCX_TEST_BEGIN - - void* ret; - - /* test present values */ - ret = ucx_avl_find(tree,(intptr_t)-5, dist_int, UCX_AVL_FIND_CLOSEST); - UCX_TEST_ASSERT(ret && *((int*)ret) == -5, "AVL find closest failed"); - ret = ucx_avl_find(tree,(intptr_t)-5, dist_int, UCX_AVL_FIND_EXACT); - UCX_TEST_ASSERT(ret && *((int*)ret) == -5, "AVL find exact failed"); - ret = ucx_avl_find(tree,(intptr_t)-5, dist_int, UCX_AVL_FIND_LOWER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == -5, "AVL find LB failed"); - ret = ucx_avl_find(tree,(intptr_t)-5, dist_int, UCX_AVL_FIND_UPPER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == -5, "AVL find UB failed"); - ret = ucx_avl_find(tree,(intptr_t)12, dist_int, UCX_AVL_FIND_CLOSEST); - UCX_TEST_ASSERT(ret && *((int*)ret) == 12, "AVL find closest failed"); - ret = ucx_avl_find(tree,(intptr_t)12, dist_int, UCX_AVL_FIND_EXACT); - UCX_TEST_ASSERT(ret && *((int*)ret) == 12, "AVL find exact failed"); - ret = ucx_avl_find(tree,(intptr_t)12, dist_int, UCX_AVL_FIND_LOWER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == 12, "AVL find LB failed"); - ret = ucx_avl_find(tree,(intptr_t)12, dist_int, UCX_AVL_FIND_UPPER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == 12, "AVL find UB failed"); - - /* test missing values */ - ret = ucx_avl_find(tree,(intptr_t)-10, dist_int, UCX_AVL_FIND_CLOSEST); - UCX_TEST_ASSERT(ret && *((int*)ret) == -11, "AVL find closest failed"); - ret = ucx_avl_find(tree,(intptr_t)-8, dist_int, UCX_AVL_FIND_EXACT); - UCX_TEST_ASSERT(!ret, "AVL find exact failed"); - ret = ucx_avl_find(tree,(intptr_t)-8, dist_int, UCX_AVL_FIND_LOWER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == -5, "AVL find LB failed"); - ret = ucx_avl_find(tree,(intptr_t)-8, dist_int, UCX_AVL_FIND_UPPER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == -11, "AVL find UB failed"); - ret = ucx_avl_find(tree,(intptr_t)18, dist_int, UCX_AVL_FIND_CLOSEST); - UCX_TEST_ASSERT(ret && *((int*)ret) == 20, "AVL find closest failed"); - ret = ucx_avl_find(tree,(intptr_t)7, dist_int, UCX_AVL_FIND_EXACT); - UCX_TEST_ASSERT(!ret, "AVL find exact failed"); - ret = ucx_avl_find(tree,(intptr_t)7, dist_int, UCX_AVL_FIND_LOWER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == 10, "AVL find LB failed"); - ret = ucx_avl_find(tree,(intptr_t)7, dist_int, UCX_AVL_FIND_UPPER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == 4, "AVL find UB failed"); - - int val2[] = { 10, 15 }; - ucx_avl_put(tree2, val2[0], &(val2[0])); - ucx_avl_put(tree2, val2[1], &(val2[1])); - ret = ucx_avl_find(tree2,(intptr_t)11, dist_int, UCX_AVL_FIND_UPPER_BOUNDED); - UCX_TEST_ASSERT(ret && *((int*)ret) == 10, "AVL find LB failed"); - - int val3[] = { 15, 16, 1 }; - ucx_avl_put(tree3, val3[0], &(val3[0])); - ucx_avl_put(tree3, val3[1], &(val3[1])); - ucx_avl_put(tree3, val3[2], &(val3[2])); - - ret = ucx_avl_find(tree3, (intptr_t)13, dist_int, UCX_AVL_FIND_CLOSEST); - UCX_TEST_ASSERT(ret && *((int*)ret) == 15, "AVL find closest failed"); - - UCX_TEST_END - - ucx_avl_free(tree); - ucx_avl_free(tree2); - ucx_avl_free(tree3); -} - -UCX_TEST(test_ucx_avl_traverse) { - UcxAVLTree *tree = ucx_avl_new(ucx_cmp_ptr); - - size_t len = 12; - - int val[] = {10, 15, 3, 4, -30, 20, 14, -11, 12, -5, 1, 13}; - int val_ordered[] = {-30, -11, -5, 1, 3, 4, 10, 12, 13, 14, 15, 20}; - - for (size_t i = 0 ; i < len ; i++) { - ucx_avl_put(tree, val[i], &(val[i])); - } - - UCX_TEST_BEGIN - - UcxAVLNode* node = ucx_avl_get_node(tree, (intptr_t) val_ordered[0]); - for (size_t i = 0 ; i < len ; i++) { - UCX_TEST_ASSERT(node->key == val_ordered[i], "AVL successor failed"); - node = ucx_avl_succ(node); - } - UCX_TEST_ASSERT(!node, "AVL maximum incorrectly has a successor"); - - node = ucx_avl_get_node(tree, (intptr_t) val_ordered[len-1]); - for (size_t i = len ; i > 0 ; i--) { - UCX_TEST_ASSERT(node->key == val_ordered[i-1],"AVL predecessor failed"); - node = ucx_avl_pred(node); - } - UCX_TEST_ASSERT(!node, "AVL minimum incorrectly has a predecessor"); - - UCX_TEST_END - - ucx_avl_free(tree); -} diff -r 92e482410453 -r d345541018fa test/avl_tests.h --- a/test/avl_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,49 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef AVL_TEST_H -#define AVL_TEST_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_avl_put); -UCX_TEST(test_ucx_avl_remove); -UCX_TEST(test_ucx_avl_find); -UCX_TEST(test_ucx_avl_traverse); - -#ifdef __cplusplus -} -#endif - -#endif /* AVL_TEST_H */ - diff -r 92e482410453 -r d345541018fa test/buffer_tests.c --- a/test/buffer_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,738 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "buffer_tests.h" -#include - -UCX_TEST(test_ucx_buffer_new) { - UcxBuffer *b = ucx_buffer_new(NULL, 16, UCX_BUFFER_AUTOEXTEND); - UcxBuffer *b2 = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(b->capacity==16, "wrong capacity"); - UCX_TEST_ASSERT(b2->capacity==32, "wrong capacity"); - - UCX_TEST_ASSERT(b->size==0, "wrong size"); - UCX_TEST_ASSERT(b2->size==0, "wrong size"); - - UCX_TEST_ASSERT(b->pos==0, "wrong position"); - UCX_TEST_ASSERT(b2->pos==0, "wrong position"); - - UCX_TEST_ASSERT(b->flags==(UCX_BUFFER_AUTOEXTEND|UCX_BUFFER_AUTOFREE), - "wrong flags for autoextending buffer"); - UCX_TEST_ASSERT(b2->flags==UCX_BUFFER_AUTOFREE, - "wrong flags for default bufer"); - - UCX_TEST_END - ucx_buffer_free(b2); - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_new_prealloc) { - char* test = (char*) malloc(16); - UcxBuffer *b = ucx_buffer_new(test, 16, UCX_BUFFER_DEFAULT); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(b->capacity==16, "wrong capacity"); - UCX_TEST_ASSERT(b->size==0, "wrong size"); - UCX_TEST_ASSERT(b->pos==0, "wrong position"); - - UCX_TEST_ASSERT(b->flags==0, "wrong flags - all should be cleared"); - - UCX_TEST_END - free(test); - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_eof) { - char *test = (char*)"0123456789ABCDEF"; - UcxBuffer *b = ucx_buffer_new(test, 16, UCX_BUFFER_DEFAULT); - UCX_TEST_BEGIN - b->pos = 9; b->size = 10; - UCX_TEST_ASSERT(!ucx_buffer_eof(b), "false positive"); - b->pos = 10; b->size = 10; - UCX_TEST_ASSERT(ucx_buffer_eof(b), "pos == size should be EOF"); - b->pos = 11; b->size = 10; - UCX_TEST_ASSERT(ucx_buffer_eof(b), "false negative"); - UCX_TEST_END - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_overflow) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->size = 32; - int r; - - UCX_TEST_BEGIN - const size_t sizemax = (size_t)-1; - size_t bigpos = sizemax - 5000; - b->pos = bigpos; - r = ucx_buffer_seek(b, 5016, SEEK_CUR); - UCX_TEST_ASSERT(r != 0, "seek cur overflow"); - UCX_TEST_ASSERT(b->pos == bigpos, - "failed seek shall leave pos unchanged"); - - b->pos = 0; - b->size = (sizemax >> 1) + 32; - - // we don't want to risk overflows in implicit constant casts - const size_t bigoff_comp = (sizemax >> 1) - 16; - off_t bigoff = (off_t)bigoff_comp; - - r = ucx_buffer_seek(b, -bigoff, SEEK_CUR); - UCX_TEST_ASSERT(r != 0, "seek cur underflow"); - UCX_TEST_ASSERT(b->pos == 0, - "failed seek shall leave pos unchanged"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_invalid) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->pos = 7; - int r; - - UCX_TEST_BEGIN - r = ucx_buffer_seek(b, 0, ~(SEEK_SET|SEEK_CUR|SEEK_END)); - UCX_TEST_ASSERT(r != 0, "invalid whence shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_oob) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->size = 16; // less than capacity - b->pos = 7; - int r; - - UCX_TEST_BEGIN - - r = ucx_buffer_seek(b, -1, SEEK_SET); - UCX_TEST_ASSERT(r != 0, "seek SET below bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - r = ucx_buffer_seek(b, 16, SEEK_SET); - UCX_TEST_ASSERT(r != 0, "seek SET above bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - r = ucx_buffer_seek(b, -8, SEEK_CUR); - UCX_TEST_ASSERT(r != 0, "seek CUR below bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - r = ucx_buffer_seek(b, 9, SEEK_CUR); - UCX_TEST_ASSERT(r != 0, "seek CUR above bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - r = ucx_buffer_seek(b, -17, SEEK_END); - UCX_TEST_ASSERT(r != 0, "seek END below bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - r = ucx_buffer_seek(b, 1, SEEK_END); - UCX_TEST_ASSERT(r != 0, "seek END above bounds shall fail"); - UCX_TEST_ASSERT(b->pos == 7, - "failed seek shall leave pos unchanged"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_set) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->size = 16; - int r; - - UCX_TEST_BEGIN - - r = ucx_buffer_seek(b, 5, SEEK_SET); - UCX_TEST_ASSERT(r == 0, "seek SET+5 failed"); - UCX_TEST_ASSERT(b->pos == 5, "seek SET+5 set wrong position"); - - - r = ucx_buffer_seek(b, 10, SEEK_SET); - UCX_TEST_ASSERT(r == 0, "seek SET+10 failed"); - UCX_TEST_ASSERT(b->pos == 10, "seek SET+10 set wrong position"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_cur) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->size = 16; - int r; - - UCX_TEST_BEGIN - - b->pos = 7; - r = ucx_buffer_seek(b, 5, SEEK_CUR); - UCX_TEST_ASSERT(r == 0, "seek CUR+5 failed"); - UCX_TEST_ASSERT(b->pos == 12, "seek CUR+5 set wrong position"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_seek_end) { - UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT); - b->size = 16; - int r; - - UCX_TEST_BEGIN - - r = ucx_buffer_seek(b, -5, SEEK_END); - UCX_TEST_ASSERT(r == 0, "seek END-5 failed"); - UCX_TEST_ASSERT(b->pos == 11, "seek END-5 set wrong position"); - - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_putc) { - char *buffer = (char*) malloc(16); - memset(buffer, 32, 16); - - UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT); - b->size = b->capacity; - - UCX_TEST_BEGIN - - ucx_buffer_seek(b, 0, SEEK_SET); - UCX_TEST_ASSERT(ucx_buffer_putc(b, '0'|~0xFF) == '0', - "putc shall return (arg & 0xFF)"); - ucx_buffer_putc(b, '0'); - ucx_buffer_putc(b, '0'); - - UCX_TEST_ASSERT(b->pos == 3, "pos wrong after first 3 puts"); - ucx_buffer_seek(b, 10, SEEK_CUR); - - ucx_buffer_putc(b, '0'); - ucx_buffer_putc(b, '0'); - ucx_buffer_putc(b, '0'); - - UCX_TEST_ASSERT(b->pos == 16, "pos wrong after last 3 puts"); - - UCX_TEST_ASSERT(!memcmp(b->space, "000 000", 16), - "buffer content wrong") - UCX_TEST_END - ucx_buffer_free(b); - free(buffer); -} - -UCX_TEST(test_ucx_buffer_putc_oob) { - UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_DEFAULT); - - UCX_TEST_BEGIN - b->pos = b->size = b->capacity = 1; - b->space[1] = 'X'; - - UCX_TEST_ASSERT(ucx_buffer_putc(b, 48) == EOF, "put shall return EOF " - "when buffer is full and auto extend is disabled"); - UCX_TEST_ASSERT(!memcmp(b->space, "\0X", 2), - "wrong buffer content after failed putc"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - - -UCX_TEST(test_ucx_buffer_putc_ae) { - UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND); - ucx_buffer_putc(b, '0'); - ucx_buffer_putc(b, '1'); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(b->pos == 2, "pos wrong after first 2 puts"); - UCX_TEST_ASSERT(b->size == 2, "size wrong after first 2 puts"); - UCX_TEST_ASSERT(b->capacity == 2, "buffer erroneously extended"); - UCX_TEST_ASSERT(!memcmp(b->space,"01", 2), "wrong content"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_putc_oobae) { - UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND); - ucx_buffer_putc(b, '0'); - ucx_buffer_putc(b, '1'); - - UCX_TEST_BEGIN - - ucx_buffer_putc(b, 'a'); - - UCX_TEST_ASSERT(b->pos == 3, "pos wrong after put"); - UCX_TEST_ASSERT(b->capacity == 4, "buffer not properly extended"); - UCX_TEST_ASSERT(b->size == 3, "wrong buffer size"); - - UCX_TEST_ASSERT(!memcmp(b->space,"01a\0", 4), "wrong content"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_putc_size) { - UcxBuffer *b = ucx_buffer_new(NULL, 4, UCX_BUFFER_DEFAULT); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(b->size == 0, "wrong initial size"); - ucx_buffer_putc(b, 'a'); - ucx_buffer_putc(b, 'b'); - ucx_buffer_putc(b, 'c'); - UCX_TEST_ASSERT(b->size == 3, "size does not increase"); - ucx_buffer_seek(b, 1, SEEK_SET); - ucx_buffer_putc(b, 'd'); - UCX_TEST_ASSERT(b->size == 3, "size shall not decrease"); - UCX_TEST_ASSERT(b->pos == 2, "wrong position after seek and putc"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_getc) { - char *buffer = (char*) malloc(16); - memset(buffer, 32, 8); - for (int i = 8; i < 16 ; i++) { - buffer[i] = 40+i; - } - - UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT); - b->size = b->capacity; - - unsigned char ubuffer[] = {127, 128, 129, 130}; - UcxBuffer *ub = ucx_buffer_new(ubuffer, 4, UCX_BUFFER_DEFAULT); - ub->size = 4; - - UCX_TEST_BEGIN - - char rb[16]; - for (size_t i = 0 ; i < 16 ; i++) { - UCX_TEST_ASSERT(b->pos == i, "wrong position"); - UCX_TEST_ASSERT(!ucx_buffer_eof(b), "EOF false positive"); - rb[i] = ucx_buffer_getc(b); - } - UCX_TEST_ASSERT(memcmp(rb, " 01234567", 16) == 0, - "read data incorrect"); - - UCX_TEST_ASSERT(ucx_buffer_eof(b), "EOF not set after last possible read"); - UCX_TEST_ASSERT(b->pos == 16, "wrong position after EOF"); - - UCX_TEST_ASSERT(ucx_buffer_getc(b) == EOF, - "out of bounds read does not return EOF"); - UCX_TEST_ASSERT(b->pos == 16, "wrong position after out of bounds read"); - - int uc[5]; - for(int i=0;i<5;i++) { - uc[i] = ucx_buffer_getc(ub); - } - UCX_TEST_ASSERT(uc[0] == 127, "wrong unsigned value(0)"); - UCX_TEST_ASSERT(uc[1] == 128, "wrong unsigned value(0)"); - UCX_TEST_ASSERT(uc[2] == 129, "wrong unsigned value(0)"); - UCX_TEST_ASSERT(uc[3] == 130, "wrong unsigned value(0)"); - UCX_TEST_ASSERT(uc[4] == EOF, "EOF not set after last ub read"); - - UCX_TEST_END - - ucx_buffer_free(b); - ucx_buffer_free(ub); - free(buffer); -} - -UCX_TEST(test_ucx_buffer_write) { - char *buffer = (char*) malloc(32); - memset(buffer, 0, 32); - - memset(buffer, 32, 8); - for (int i = 8; i < 16 ; i++) { - buffer[i] = 40+i; - } - - UcxBuffer *b = ucx_buffer_new(buffer, 32, UCX_BUFFER_DEFAULT); - int r; - - UCX_TEST_BEGIN - b->pos = 4; - r = ucx_buffer_write("test string", 1, 11, b); - UCX_TEST_ASSERT(r == 11, "returned incorrect number of written bytes"); - UCX_TEST_ASSERT(b->pos == 15, "incorrect position"); - UCX_TEST_ASSERT(memcmp(buffer, " test string7\0\0", 18) == 0, - "incorrect buffer content (test string)"); - - r = ucx_buffer_write(".", 1, 1, b); - UCX_TEST_ASSERT(r == 1, "returned incorrect number of written elements"); - UCX_TEST_ASSERT(b->pos == 16, "incorrect position"); - - int32_t testarr[4] = {0x09abcdef, 0x05fedcba, 0x01abefcd, 0x3cd07ab}; - r = ucx_buffer_write(testarr, 4, 4, b); - UCX_TEST_ASSERT(r = 4, "returned incorrect number of written elements"); - UCX_TEST_ASSERT(b->pos == 32, "incorrect position"); - - char cmp[32]; - memset(cmp, 0, 32); - memcpy(cmp, " test string.", 16); - int32_t *ptr = (int32_t*) (cmp+16); - ptr[0] = testarr[0]; - ptr[1] = testarr[1]; - ptr[2] = testarr[2]; - ptr[3] = testarr[3]; - UCX_TEST_ASSERT(memcmp(buffer, cmp, 32) == 0, - "incorrect buffer content (int array)"); - - UCX_TEST_END - - ucx_buffer_free(b); - free(buffer); -} - -UCX_TEST(test_ucx_buffer_write_oob) { - char *buffer = (char*) malloc(32); - memset(buffer, 0, 32); - - UcxBuffer *b = ucx_buffer_new(buffer, 15, UCX_BUFFER_DEFAULT); - int r; - - UCX_TEST_BEGIN - r = ucx_buffer_write("a very long string", 1, 18, b); - UCX_TEST_ASSERT(r == 15, "incorrect number of written bytes"); - UCX_TEST_ASSERT(memcmp(buffer, "a very long str\0\0\0", 18) == 0, - "invalid buffer content (test string)"); - - b->size = b->pos = 0; - int32_t intarr[4] = {0,-1,0,-1}; - memset(buffer, 0, 32); - - r = ucx_buffer_write(intarr, 4, 4, b); - UCX_TEST_ASSERT(r == 3, "incorrect number of written elements"); - UCX_TEST_ASSERT(memcmp(buffer, - "\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0", 16) == 0, - "invalid buffer content (test string)"); - - UCX_TEST_END - - ucx_buffer_free(b); - free(buffer); -} - -UCX_TEST(test_ucx_buffer_write_ax) { - char *buffer = (char*) malloc(16); - memset(buffer, 0, 16); - - UcxBuffer *b = ucx_buffer_new(buffer, 16, - UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE); - int r; - - UCX_TEST_BEGIN - - const char* teststring = "this is way too much"; - r = ucx_buffer_write((void*)teststring, 1, 20, b); - buffer = (char*) b->space; /*autoextend enabled, we MUST retrieve pointer*/ - UCX_TEST_ASSERT(r == 20, "not all characters written"); - UCX_TEST_ASSERT(b->capacity == 32, "buffer not properly extended"); - UCX_TEST_ASSERT(b->pos == 20, "position incorrect"); - UCX_TEST_ASSERT(memcmp(buffer, - "this is way too much\0\0\0\0\0\0\0\0\0\0\0\0", 32) == 0, - "incorrect buffer content"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_read) { - UcxBuffer *b = ucx_buffer_new(NULL, 8, UCX_BUFFER_AUTOFREE); - ucx_buffer_write("01234567", 1, 8, b); - b->pos = 0; - - char buf[32]; - memset(buf, 'X', 32); - int r; - - UCX_TEST_BEGIN - - ucx_buffer_seek(b, 2, SEEK_SET); - r = ucx_buffer_read(buf, 1, 2, b); - UCX_TEST_ASSERT(r == 2, "wrong number of bytes read (2 items)"); - UCX_TEST_ASSERT(buf[0] == '2' && buf[1] == '3' && buf[2] == 'X', - "buffer incorrect after read"); - UCX_TEST_ASSERT(b->pos == 4, "wrong position after read (2 items)"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_read_oob) { - UcxBuffer *b = ucx_buffer_new(NULL, 8, UCX_BUFFER_AUTOFREE); - ucx_buffer_write("01234567", 1, 8, b); - - char buf[32]; - memset(buf, 'X', 32); - int r; - - UCX_TEST_BEGIN - - b->pos = 2; - r = ucx_buffer_read(buf + 2, 1, 8, b); - UCX_TEST_ASSERT(r == 6, "wrong number of bytes read (8 items)"); - UCX_TEST_ASSERT(memcmp(buf, "XX234567XX", 10) == 0, - "buffer incorrect after read"); - UCX_TEST_ASSERT(b->pos == 8, - "wrong position after read (8 items out of bound)"); - - b->pos = 0; - memset(buf, 'X', 32); - - r = ucx_buffer_read(buf, 3, 3, b); - - UCX_TEST_ASSERT(r == 2, "wrong number of blocks read"); - UCX_TEST_ASSERT(memcmp(buf, "012345XX", 8) == 0, - "buffer incorrect after block out of bounds read"); - - r = ucx_buffer_read(buf+6, 1, 5, b); - - UCX_TEST_ASSERT(r == 2, "wrong number of remaining bytes read"); - UCX_TEST_ASSERT(memcmp(buf, "01234567XX", 10) == 0, - "buffer incorrect after remaining byte read"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_extract) { - char *buffer = (char*) malloc(16); - strcpy(buffer, "this is a test!"); - - UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE); - src->size = 16; - UcxBuffer *dst = ucx_buffer_extract(src, 5, 5, UCX_BUFFER_AUTOEXTEND); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(dst != NULL, "ucx_buffer_extract returned NULL"); - UCX_TEST_ASSERT(dst->flags == (UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE), - "autofree flag shall be enforced"); - UCX_TEST_ASSERT(dst->size == 5, "wrong size for new buffer"); - UCX_TEST_ASSERT(dst->capacity == 5, "wrong capacity for new buffer"); - UCX_TEST_ASSERT(dst->pos == 0, "wrong position for new buffer"); - char rb[5]; - ucx_buffer_read(rb, 1, 5, dst); - UCX_TEST_ASSERT(memcmp(rb, "is a ", 5) == 0, - "new buffer has incorrect content"); - - UCX_TEST_END - - ucx_buffer_free(dst); - ucx_buffer_free(src); -} - -UCX_TEST(test_ucx_buffer_extract_oob) { - char *buffer = (char*) malloc(16); - strcpy(buffer, "this is a test!"); - - UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE); - src->size = 16; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_buffer_extract(src, 5, 0, UCX_BUFFER_DEFAULT) == NULL, - "extract shall fail on zero length"); - UCX_TEST_ASSERT(ucx_buffer_extract(src, 10, 10, UCX_BUFFER_DEFAULT) == NULL, - "extract shall fail on invalid bounds (size exceeds limits)"); - UCX_TEST_ASSERT(ucx_buffer_extract(src, 20, -7, UCX_BUFFER_DEFAULT) == NULL, - "extract shall fail on invalid bounds (start exceeds limits)"); - - UCX_TEST_END - - ucx_buffer_free(src); -} - -UCX_TEST(test_ucx_buffer_extract_overflow) { - char *buffer = (char*) malloc(16); - strcpy(buffer, "this is a test!"); - - UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE); - src->size = 16; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_buffer_extract(src, 5, (size_t)-4, - UCX_BUFFER_DEFAULT) == NULL, "extract shall fail on integer overflow"); - - UCX_TEST_END - - ucx_buffer_free(src); -} - -UCX_TEST(test_ucx_buffer_extend) { - - UcxBuffer *b = ucx_buffer_new(NULL, 10, UCX_BUFFER_DEFAULT); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_buffer_extend(b, 15) == 0, "shall return 0 on success"); - UCX_TEST_ASSERT(b->capacity = 40, "wrong capacity"); - UCX_TEST_ASSERT((b->size == 0 && b->pos == 0), - "pos and size shall remain unchanged"); - - UCX_TEST_ASSERT(ucx_buffer_extend(b, (size_t) - 61) != 0, - "shall fail and return a non-zero value on overflow"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_shl) { - - const char* hw = "Shift the World!"; - - UcxBuffer *b = ucx_buffer_new(NULL, 20, UCX_BUFFER_DEFAULT); - ucx_buffer_puts(b, hw); - b->pos = 5; - - UCX_TEST_BEGIN - char* expected; - - ucx_buffer_shift_left(b, 2); - expected = "ift the World!"; - - UCX_TEST_ASSERT(b->pos == 3, "position after normal shl wrong"); - UCX_TEST_ASSERT(b->size == strlen(expected), "size after normal shl wrong"); - UCX_TEST_ASSERT(!memcmp(b->space, expected, b->size), - "contents after normal shl wrong"); - - - ucx_buffer_shift_left(b, 5); - expected = "he World!"; - - UCX_TEST_ASSERT(b->pos == 0, "position after overshift left wrong"); - UCX_TEST_ASSERT(b->size == strlen(expected), - "size after overshift left wrong"); - UCX_TEST_ASSERT(!memcmp(b->space, expected, b->size), - "contents after overshift left wrong"); - - ucx_buffer_shift_left(b, 10); - UCX_TEST_ASSERT(b->pos == 0, "position after 'shl everything away' wrong"); - UCX_TEST_ASSERT(b->size == 0, "size after 'shl everything away' wrong"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_shr) { - - const char* hw = "Shift the World!"; - - UcxBuffer *b = ucx_buffer_new(NULL, 20, UCX_BUFFER_DEFAULT); - ucx_buffer_puts(b, hw); - b->pos = 12; - - UCX_TEST_BEGIN - char* expected; - - ucx_buffer_shift_right(b, 2); - expected = "ShShift the World!"; - - UCX_TEST_ASSERT(b->pos == 14, "position after normal shr wrong"); - UCX_TEST_ASSERT(b->size == strlen(expected), "size after normal shr wrong"); - UCX_TEST_ASSERT(!memcmp(b->space, expected, b->size), - "contents after normal shr wrong"); - - - ucx_buffer_shift_right(b, 5); - expected = "ShShiShShift the Wor"; - UCX_TEST_ASSERT(strlen(expected) == b->capacity, - "Test data is wrong, please fix the test."); - - UCX_TEST_ASSERT(b->pos == 19, - "position after overshift right w/o auto-extend wrong"); - UCX_TEST_ASSERT(b->size == 20, - "size after overshift right w/o auto-extend wrong"); - UCX_TEST_ASSERT(b->capacity == 20, - "capacity after overshift right w/o auto-extend wrong"); - UCX_TEST_ASSERT(!memcmp(b->space, expected, b->size), - "contents after overshift right w/o auto-extend wrong"); - - ucx_buffer_shift_right(b, 15); - UCX_TEST_ASSERT(b->pos == b->capacity, "position after 'shr to eof' wrong"); - UCX_TEST_ASSERT(b->size == b->capacity, "size after 'shr to eof' wrong"); - UCX_TEST_ASSERT(ucx_buffer_eof(b), "buffer not eof after 'shr to eof'"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_buffer_shr_ax) { - - const char* hw = "Shift the World!"; - - UcxBuffer *b = ucx_buffer_new(NULL, 20, UCX_BUFFER_AUTOEXTEND); - ucx_buffer_puts(b, hw); - b->pos = 12; - - UCX_TEST_BEGIN - - const char* expected = "Shift the Shift the World!"; - - ucx_buffer_shift_right(b, 10); - UCX_TEST_ASSERT(b->pos == 22, "position after shr w/ auto-extend wrong"); - UCX_TEST_ASSERT(b->size == strlen(expected), - "size after shr w/ auto-extend wrong"); - UCX_TEST_ASSERT(b->capacity >= b->size, - "auto-extension of capacity after shr w/ auto-extend failed"); - UCX_TEST_ASSERT(!ucx_buffer_eof(b), - "buffer should not be eof after shr w/ auto-extend"); - UCX_TEST_ASSERT(!memcmp(b->space, expected, b->size), - "contents wrong after shr w/ auto-extend"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - diff -r 92e482410453 -r d345541018fa test/buffer_tests.h --- a/test/buffer_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,73 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef BUFFER_TEST_H -#define BUFFER_TEST_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_buffer_eof); -UCX_TEST(test_ucx_buffer_seek_set); -UCX_TEST(test_ucx_buffer_seek_end); -UCX_TEST(test_ucx_buffer_seek_cur); -UCX_TEST(test_ucx_buffer_seek_oob); -UCX_TEST(test_ucx_buffer_seek_invalid); -UCX_TEST(test_ucx_buffer_seek_overflow); -UCX_TEST(test_ucx_buffer_putc); -UCX_TEST(test_ucx_buffer_putc_ae); -UCX_TEST(test_ucx_buffer_putc_oob); -UCX_TEST(test_ucx_buffer_putc_oobae); -UCX_TEST(test_ucx_buffer_putc_size); -UCX_TEST(test_ucx_buffer_new); -UCX_TEST(test_ucx_buffer_new_prealloc); -UCX_TEST(test_ucx_buffer_getc); -UCX_TEST(test_ucx_buffer_read); -UCX_TEST(test_ucx_buffer_read_oob); -UCX_TEST(test_ucx_buffer_extract); -UCX_TEST(test_ucx_buffer_extract_oob); -UCX_TEST(test_ucx_buffer_extract_overflow); -UCX_TEST(test_ucx_buffer_extend); -UCX_TEST(test_ucx_buffer_write); -UCX_TEST(test_ucx_buffer_write_oob); -UCX_TEST(test_ucx_buffer_write_ax); -UCX_TEST(test_ucx_buffer_shl); -UCX_TEST(test_ucx_buffer_shr); -UCX_TEST(test_ucx_buffer_shr_ax); - - -#ifdef __cplusplus -} -#endif - -#endif /* BUFFER_TEST_H */ - diff -r 92e482410453 -r d345541018fa test/list_tests.c --- a/test/list_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,496 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "list_tests.h" -#include - -UCX_TEST(test_ucx_list_append) { - UcxList *list, *first; - list = first = ucx_list_append(NULL, (void*)"Hello"); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(strncmp((const char*)list->data, "Hello", 5) == 0, - "failed"); - - list = ucx_list_append(list, (void*)" World!"); - - UCX_TEST_ASSERT(list == first, "does not return first element"); - UCX_TEST_ASSERT(strncmp((const char*)list->next->data, " World!", 7) == 0, - "failed"); - UCX_TEST_ASSERT(list->next->prev == list, "failed"); - UCX_TEST_ASSERT(list->next->next == NULL, "failed"); - UCX_TEST_END - - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_prepend) { - UcxList *list, *last; - list = last = ucx_list_prepend(NULL, (void*)" World!"); - UCX_TEST_BEGIN - - list = ucx_list_prepend(list, (void*)"Hello"); - - UCX_TEST_ASSERT(strncmp((const char*)list->data, "Hello", 5) == 0, - "failed"); - UCX_TEST_ASSERT(strncmp((const char*)list->next->data, " World!", 7) == 0, - "failed"); - UCX_TEST_ASSERT(list == last->prev, "does not return first element"); - UCX_TEST_ASSERT(list->next->next == NULL, "failed"); - UCX_TEST_ASSERT(list->prev == NULL, "failed"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_equals) { - const char *hello = "Hello"; - const char *world = " World!"; - UcxList *list = ucx_list_append(NULL, (void*)hello); - list = ucx_list_append(list, (void*)world); - UcxList *list2 = ucx_list_prepend(NULL, (void*)world); - list2 = ucx_list_prepend(list2, (void*)hello); - UcxList *list3 = ucx_list_prepend(NULL, (void*)" Welt!"); - list3 = ucx_list_prepend(list3, (void*)"Hallo"); - UcxList *list4 = ucx_list_prepend(NULL, (void*)" World!"); - list4 = ucx_list_prepend(list4, (void*)"Hello"); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_equals(list, list4, ucx_cmp_str, NULL), "failed"); - UCX_TEST_ASSERT(!ucx_list_equals(list, list3, ucx_cmp_str, NULL), "failed"); - UCX_TEST_ASSERT(ucx_list_equals(list, list2, NULL, NULL), "failed"); - - UCX_TEST_END - ucx_list_free(list4); - ucx_list_free(list3); - ucx_list_free(list2); - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_concat) { - UcxList *list = ucx_list_append(NULL, (void*)"Hello"); - list = ucx_list_append(list, (void*)" my "); - UcxList *list2 = ucx_list_prepend(NULL, (void*)" World!"); - list2 = ucx_list_prepend(list2, (void*)" sweet "); - UCX_TEST_BEGIN - - list = ucx_list_concat(list, list2); - list = ucx_list_concat(list, NULL); - list = ucx_list_concat(NULL, list); - - UCX_TEST_ASSERT(!strncmp((const char*)list->data, "Hello", 5), - "failed"); - UCX_TEST_ASSERT(!strncmp((const char*)list->next->data, " my ", 4), - "failed"); - UCX_TEST_ASSERT(!strncmp((const char*)list->next->next->data, " sweet ", 7), - "failed"); - UCX_TEST_ASSERT(!strncmp((const char*)ucx_list_last(list)->data, - " World!", 7), "failed"); - - UCX_TEST_ASSERT(list->prev == NULL, "failed"); - - UCX_TEST_END - // don't free list2, as it is freed by freeing list; - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_size) { - UcxList *list = ucx_list_append(NULL, (void*)"This "); - list = ucx_list_append(list, (void*)"list "); - list = ucx_list_append(list, (void*)"has "); - list = ucx_list_append(list, (void*)"size "); - list = ucx_list_append(list, (void*)"5!"); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_size(list) == 5, "failed"); - list = ucx_list_remove(list, ucx_list_get(list, 2)); - UCX_TEST_ASSERT(ucx_list_size(list) == 4, "failed after removal"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_first) { - UcxList *list = ucx_list_append(NULL, (void*)"Find "); - list = ucx_list_append(list, (void*)"the "); - list = ucx_list_append(list, (void*)"first!"); - - UCX_TEST_BEGIN - - const char* first = (const char*) (ucx_list_first(list)->data); - - UCX_TEST_ASSERT(strncmp(first, "Find ", 5) == 0, "failed"); - UCX_TEST_ASSERT(ucx_list_first(list->next->next) == list, "failed"); - UCX_TEST_ASSERT(!ucx_list_first(NULL), - "does not return NULL on an empty list"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_last) { - UcxList *list = ucx_list_append(NULL, (void*)"Find "); - list = ucx_list_append(list, (void*)"the "); - list = ucx_list_append(list, (void*)"last!"); - - UCX_TEST_BEGIN - - const char* last = (const char*) (ucx_list_last(list->next->next)->data); - - UCX_TEST_ASSERT(strncmp(last, "last!", 5) == 0, "failed"); - UCX_TEST_ASSERT(ucx_list_last(list) == list->next->next, "failed"); - UCX_TEST_ASSERT(!ucx_list_last(NULL), - "does not return NULL on an empty list"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_get) { - UcxList *list = ucx_list_append(NULL, (void*)"Find "); - list = ucx_list_append(list, (void*)"the "); - list = ucx_list_append(list, (void*)"mid!"); - - UCX_TEST_BEGIN - - const char* first = (const char*) (ucx_list_get(list, 0)->data); - const char* mid = (const char*) (ucx_list_get(list, 1)->data); - const char* last = (const char*) (ucx_list_get(list, 2)->data); - - UCX_TEST_ASSERT(strncmp(first, "Find ", 5) == 0, "failed"); - UCX_TEST_ASSERT(strncmp(mid, "the ", 4) == 0, "failed"); - UCX_TEST_ASSERT(strncmp(last, "mid!", 4) == 0, "failed"); - UCX_TEST_ASSERT(!ucx_list_get(list, -1), "out of bounds (neg)"); - UCX_TEST_ASSERT(!ucx_list_get(list, 3), "out of bounds"); - UCX_TEST_ASSERT(!ucx_list_get(NULL, 0), "empty list"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_indexof) { - UcxList *list = ucx_list_append(NULL, (void*)"Find "); - list = ucx_list_append(list, (void*)"the "); - list = ucx_list_append(list, (void*)"mid!"); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_indexof(list, list) == 0, "failed"); - UCX_TEST_ASSERT(ucx_list_indexof(list, list->next) == 1, "failed"); - UCX_TEST_ASSERT(ucx_list_indexof(list, ucx_list_get(list, 2)) == 2, - "failed"); - - UcxList *otherlist = ucx_list_append(NULL, (void*) "the "); - UCX_TEST_ASSERT(ucx_list_indexof(list, otherlist) == -1, "failed"); - UCX_TEST_ASSERT(ucx_list_indexof(NULL, otherlist) == -1, "empty list"); - - ucx_list_free(otherlist); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_find) { - const char* teststr = "string!"; - UcxList *l = ucx_list_append(NULL, (void*)"find "); - l = ucx_list_append(l, (void*)"some "); - l = ucx_list_append(l, (void*)teststr); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_find(l,(void*)"some ",ucx_cmp_str,NULL) == 1, - "doesn't find string"); - UCX_TEST_ASSERT(ucx_list_find(l,(void*)"a",ucx_cmp_str,NULL) == -1, - "finds non-existing string"); - - UCX_TEST_ASSERT(ucx_list_find(l,(void*)teststr,NULL,NULL) == 2, - "doesn't find integer without cmp_func"); - - UCX_TEST_ASSERT(ucx_list_find(NULL, (void*)"some ",ucx_cmp_str,NULL) == -1, - "empty list"); - - UCX_TEST_END - ucx_list_free(l); -} - -UCX_TEST(test_ucx_list_contains) { - UcxList *l = ucx_list_append(NULL, (void*)"Contains "); - l = ucx_list_append(l, (void*)"a "); - l = ucx_list_append(l, (void*)"string!"); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_contains(l,(void*)"a ",ucx_cmp_str,NULL), - "false negative"); - UCX_TEST_ASSERT(!ucx_list_contains(l,(void*)"a",ucx_cmp_str,NULL), - "false positive"); - - UCX_TEST_END - ucx_list_free(l); -} - -UCX_TEST(test_ucx_list_remove) { - UcxList *list = ucx_list_append(NULL, (void*)"Hello"); - list = ucx_list_append(list, (void*)"fucking"); - list = ucx_list_append(list, (void*)"World!"); - - UcxList *list2 = ucx_list_append(NULL, (void*)"A"); - list2 = ucx_list_append(list2, (void*)"B"); - list2 = ucx_list_append(list2, (void*)"C"); - list2 = ucx_list_append(list2, (void*)"D"); - list2 = ucx_list_append(list2, (void*)"E"); - list2 = ucx_list_append(list2, (void*)"F"); - list2 = ucx_list_append(list2, (void*)"G"); - - UCX_TEST_BEGIN - - list = ucx_list_remove(list, ucx_list_get(list, 1)); - - UCX_TEST_ASSERT(strncmp((const char*)list->data, "Hello", 5) == 0, - "failed"); - UCX_TEST_ASSERT(strncmp((const char*)list->next->data, "World!", 7) == 0, - "failed"); - UCX_TEST_ASSERT(list->next->next == NULL, "failed"); - - // remove first element: B, C, D, E, F, G - list2 = ucx_list_remove(list2, list2); - - UCX_TEST_ASSERT(ucx_list_size(list2) == 6, "list2 has wrong size"); - UCX_TEST_ASSERT(strncmp((const char*)list2->data, "B", 1) == 0, - "wrong first element"); - UCX_TEST_ASSERT(strncmp((const char*)ucx_list_get(list2, 5)->data, "G", 1) - == 0, "wrong last element"); - - // remove second element: B, D, E, F, G - list2 = ucx_list_remove(list2, list2->next); - - UCX_TEST_ASSERT(ucx_list_size(list2) == 5, "list2 has wrong size"); - UCX_TEST_ASSERT(strncmp((const char*)list2->next->data, "D", 1) == 0, - "wrong second element"); - - UcxList *last = ucx_list_get(list2, 4); - list2 = ucx_list_remove(list2, last->prev); - - UCX_TEST_ASSERT(ucx_list_size(list2) == 4, "list2 has wrong size"); - UCX_TEST_ASSERT(strncmp((const char*)last->prev->data, "E", 1) == 0, - "wrong element"); - - // remove last element: B, D, E, F - list2 = ucx_list_remove(list2, last); - UCX_TEST_ASSERT(ucx_list_size(list2) == 3, "list2 has wrong size"); - UCX_TEST_ASSERT(strncmp((const char*)ucx_list_get(list2, 2)->data, "E", 1) - == 0, "wrong last element"); - - UCX_TEST_ASSERT(strncmp((const char*)list2->data, "B", 1) == 0, - "wrong element"); - - list2 = ucx_list_remove(list2, list2); - UCX_TEST_ASSERT(ucx_list_size(list2) == 2, "list2 has wrong size"); - list2 = ucx_list_remove(list2, list2); - UCX_TEST_ASSERT(ucx_list_size(list2) == 1, "list2 has wrong size"); - list2 = ucx_list_remove(list2, list2); - UCX_TEST_ASSERT(list2 == NULL, "list2 is not null"); - - UCX_TEST_END - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_clone) { - - char *hello = (char*)malloc(6); - char *world = (char*)malloc(8); - - memcpy(hello, "Hello", 6); - memcpy(world, " World!", 8); - - UcxList *list = ucx_list_append(NULL, hello); - list = ucx_list_append(list, world); - - UcxList *copy = ucx_list_clone(list, ucx_strcpy, NULL); - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(ucx_list_equals(list, copy, ucx_cmp_str, NULL), "failed"); - UCX_TEST_ASSERT(hello != copy->data, "first element is no copy"); - UCX_TEST_ASSERT(world != copy->next->data, "second element is no copy"); - - UCX_TEST_END - - ucx_list_free_content(copy, free); - - free(world); - free(hello); - ucx_list_free(list); - ucx_list_free(copy); -} - -UCX_TEST(test_ucx_list_sort) { - UcxList *list = ucx_list_append(NULL, (void*)"this"); - list = ucx_list_append(list, (void*)"is"); - list = ucx_list_append(list, (void*)"a"); - list = ucx_list_append(list, (void*)"test"); - list = ucx_list_append(list, (void*)"for"); - list = ucx_list_append(list, (void*)"partial"); - list = ucx_list_append(list, (void*)"correctness"); - list = ucx_list_append(list, (void*)"of"); - list = ucx_list_append(list, (void*)"the"); - list = ucx_list_append(list, (void*)"sort"); - list = ucx_list_append(list, (void*)"function"); - list = ucx_list_append(list, (void*)"that"); - list = ucx_list_append(list, (void*)"shall"); - list = ucx_list_append(list, (void*)"pass"); - list = ucx_list_append(list, (void*)"this"); - list = ucx_list_append(list, (void*)"test"); - - UcxList *expected = ucx_list_append(NULL, (void*)"a"); - expected = ucx_list_append(expected, (void*)"correctness"); - expected = ucx_list_append(expected, (void*)"for"); - expected = ucx_list_append(expected, (void*)"function"); - expected = ucx_list_append(expected, (void*)"is"); - expected = ucx_list_append(expected, (void*)"of"); - expected = ucx_list_append(expected, (void*)"partial"); - expected = ucx_list_append(expected, (void*)"pass"); - expected = ucx_list_append(expected, (void*)"shall"); - expected = ucx_list_append(expected, (void*)"sort"); - expected = ucx_list_append(expected, (void*)"test"); - expected = ucx_list_append(expected, (void*)"test"); - expected = ucx_list_append(expected, (void*)"that"); - expected = ucx_list_append(expected, (void*)"the"); - expected = ucx_list_append(expected, (void*)"this"); - expected = ucx_list_append(expected, (void*)"this"); - - list = ucx_list_sort(list, ucx_cmp_str, NULL); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT( - ucx_list_equals(list, expected, ucx_cmp_str, NULL), "failed"); - UCX_TEST_ASSERT(ucx_list_size(list) == 16, "list has now a wrong size"); - UcxList *l = list; - UCX_TEST_ASSERT(l->prev == NULL, "prev field of first entry is not null"); - while (l->next != NULL) { - UCX_TEST_ASSERT(l->next->prev == l, "next or prev pointer corrupted"); - l = l->next; - } - UCX_TEST_ASSERT(!ucx_list_sort(NULL, ucx_cmp_str, NULL), - "failed to sort empty list"); - UCX_TEST_END - - ucx_list_free(expected); - ucx_list_free(list); -} - -UCX_TEST(test_ucx_list_union) { - UcxList *left = ucx_list_append(NULL, (void*)"this"); - left = ucx_list_append(left, (void*)"is"); - left = ucx_list_append(left, (void*)"a"); - left = ucx_list_append(left, (void*)"test"); - - UcxList *right = ucx_list_append(NULL, (void*)"to"); - right = ucx_list_append(right, (void*)"test"); - right = ucx_list_append(right, (void*)"set"); - right = ucx_list_append(right, (void*)"operations"); - - UcxList *expected = ucx_list_append(NULL, (void*)"this"); - expected = ucx_list_append(expected, (void*)"is"); - expected = ucx_list_append(expected, (void*)"a"); - expected = ucx_list_append(expected, (void*)"test"); - expected = ucx_list_append(expected, (void*)"to"); - expected = ucx_list_append(expected, (void*)"set"); - expected = ucx_list_append(expected, (void*)"operations"); - - UcxList* result = ucx_list_union(left, right, ucx_cmp_str, - NULL, NULL, NULL); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(ucx_list_equals(result, expected, - ucx_cmp_str, NULL), "failed"); - UCX_TEST_END - - ucx_list_free(result); - ucx_list_free(expected); - ucx_list_free(right); - ucx_list_free(left); -} - -UCX_TEST(test_ucx_list_intersection) { - UcxList *left = ucx_list_append(NULL, (void*)"this"); - left = ucx_list_append(left, (void*)"is"); - left = ucx_list_append(left, (void*)"a"); - left = ucx_list_append(left, (void*)"test"); - - UcxList *right = ucx_list_append(NULL, (void*)"to"); - right = ucx_list_append(right, (void*)"test"); - right = ucx_list_append(right, (void*)"a"); - right = ucx_list_append(right, (void*)"set"); - right = ucx_list_append(right, (void*)"operation"); - - UcxList *expected = ucx_list_append(NULL, (void*)"a"); - expected = ucx_list_append(expected, (void*)"test"); - - UcxList* result = ucx_list_intersection(left, right, ucx_cmp_str, - NULL, NULL, NULL); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(ucx_list_equals(result, expected, - ucx_cmp_str, NULL), "failed"); - UCX_TEST_END - - ucx_list_free(result); - ucx_list_free(expected); - ucx_list_free(right); - ucx_list_free(left); -} - -UCX_TEST(test_ucx_list_difference) { - UcxList *left = ucx_list_append(NULL, (void*)"this"); - left = ucx_list_append(left, (void*)"is"); - left = ucx_list_append(left, (void*)"a"); - left = ucx_list_append(left, (void*)"test"); - - UcxList *right = ucx_list_append(NULL, (void*)"to"); - right = ucx_list_append(right, (void*)"test"); - right = ucx_list_append(right, (void*)"this"); - right = ucx_list_append(right, (void*)"set"); - right = ucx_list_append(right, (void*)"operations"); - - UcxList *expected = ucx_list_append(NULL, (void*)"is"); - expected = ucx_list_append(expected, (void*)"a"); - - UcxList* result = ucx_list_difference(left, right, ucx_cmp_str, - NULL, NULL, NULL); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(ucx_list_equals(result, expected, - ucx_cmp_str, NULL), "failed"); - UCX_TEST_END - - ucx_list_free(result); - ucx_list_free(expected); - ucx_list_free(right); - ucx_list_free(left); -} diff -r 92e482410453 -r d345541018fa test/list_tests.h --- a/test/list_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,67 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LIST_TESTS_H -#define LIST_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Assumed to be correct: - * ucx_list_free - */ - -UCX_TEST(test_ucx_list_append); -UCX_TEST(test_ucx_list_prepend); -UCX_TEST(test_ucx_list_equals); -UCX_TEST(test_ucx_list_concat); -UCX_TEST(test_ucx_list_size); -UCX_TEST(test_ucx_list_first); -UCX_TEST(test_ucx_list_last); -UCX_TEST(test_ucx_list_get); -UCX_TEST(test_ucx_list_indexof); -UCX_TEST(test_ucx_list_find); -UCX_TEST(test_ucx_list_contains); -UCX_TEST(test_ucx_list_remove); -UCX_TEST(test_ucx_list_clone); -UCX_TEST(test_ucx_list_sort); -UCX_TEST(test_ucx_list_union); -UCX_TEST(test_ucx_list_intersection); -UCX_TEST(test_ucx_list_difference); - -#ifdef __cplusplus -} -#endif - -#endif /* LIST_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/logging_tests.c --- a/test/logging_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,111 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "logging_tests.h" -#include - -UCX_TEST(test_ucx_logger_new) { - - FILE *stream = tmpfile(); - UcxLogger *logger = ucx_logger_new(stream, - UCX_LOGGER_INFO, UCX_LOGGER_SOURCE | UCX_LOGGER_LEVEL); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(logger->stream == stream, "stream not set"); - UCX_TEST_ASSERT(logger->mask == (UCX_LOGGER_SOURCE | UCX_LOGGER_LEVEL), - "mask not set"); - UCX_TEST_ASSERT(logger->level == UCX_LOGGER_INFO, - "level not set"); - UCX_TEST_ASSERT(logger->writer == (write_func)fwrite, - "writer not set to fwrite"); - UCX_TEST_ASSERT(strcmp(logger->dateformat, "%F %T %z ") == 0, - "date format not set to \"%F %T %z\""); - - UCX_TEST_ASSERT(logger->levels->count == 5, - "incorrect number of registered log levels"); - - int level = UCX_LOGGER_ERROR; - UCX_TEST_ASSERT(strcmp((char*)ucx_map_int_get(logger->levels, level), - "[ERROR]") == 0, "invalid error level"); - level = UCX_LOGGER_WARN; - UCX_TEST_ASSERT(strcmp((char*)ucx_map_int_get(logger->levels, level), - "[WARNING]") == 0, "invalid warning level"); - level = UCX_LOGGER_DEBUG; - UCX_TEST_ASSERT(strcmp((char*)ucx_map_int_get(logger->levels, level), - "[DEBUG]") == 0, "invalid debug level"); - level = UCX_LOGGER_INFO; - UCX_TEST_ASSERT(strcmp((char*)ucx_map_int_get(logger->levels, level), - "[INFO]") == 0, "invalid info level"); - level = UCX_LOGGER_TRACE; - UCX_TEST_ASSERT(strcmp((char*)ucx_map_int_get(logger->levels, level), - "[TRACE]") == 0, "invalid trace level"); - - UCX_TEST_END - - fclose(stream); - ucx_logger_free(logger); -} - -UCX_TEST(test_ucx_logger_log) { - char buffer[100]; - - FILE *stream = tmpfile(); - - UcxLogger *logger = ucx_logger_new(stream, - UCX_LOGGER_INFO, UCX_LOGGER_SOURCE | UCX_LOGGER_LEVEL); - logger->dateformat = (char*) "%Y-%m-%d:"; - - UCX_TEST_BEGIN - const unsigned int line1 = __LINE__; ucx_logger_info(logger, "allright"); - - ucx_logger_trace(logger, "dont log this!"); - - logger->mask |= UCX_LOGGER_TIMESTAMP; - time_t now = time(NULL); - char timestr[13]; - strftime(timestr, 12, "%Y-%m-%d:", localtime(&now)); - const unsigned int line2 = __LINE__; ucx_logger_error(logger, "error %d!", 42); - - fseek(stream, 0, SEEK_SET); - size_t r = fread(buffer, 1, 100, stream); - - const size_t expected_length = 87; - char expected[88]; - snprintf(expected, expected_length+1, - "[INFO] logging_tests.c:%u - allright\n" - "[ERROR] %slogging_tests.c:%u - error 42!\n", line1, timestr, line2); - - UCX_TEST_ASSERT(r == expected_length, "incorrect log length"); - UCX_TEST_ASSERT(strncmp(buffer, expected, expected_length) == 0, - "incorrect logs"); - - UCX_TEST_END - - ucx_logger_free(logger); - fclose(stream); -} diff -r 92e482410453 -r d345541018fa test/logging_tests.h --- a/test/logging_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,47 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LOGGING_TESTS_H -#define LOGGING_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_logger_new); -UCX_TEST(test_ucx_logger_log); - -#ifdef __cplusplus -} -#endif - -#endif /* LOGGING_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/main.c --- a/test/main.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,286 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include - -#include - -#include "main.h" - -#include "array_tests.h" -#include "allocator_tests.h" -#include "logging_tests.h" -#include "list_tests.h" -#include "string_tests.h" -#include "mpool_tests.h" -#include "stack_tests.h" -#include "map_tests.h" -#include "prop_tests.h" -#include "buffer_tests.h" -#include "utils_tests.h" -#include "avl_tests.h" - -#ifdef __cplusplus -extern "C" { -#endif -UCX_TEST(testTestSuitePositive) { - UCX_TEST_BEGIN - UCX_TEST_ASSERT(2*2 == 4, "the test framework fails"); - UCX_TEST_END -} - -UCX_TEST(testTestSuiteNegative) { - UCX_TEST_BEGIN - UCX_TEST_ASSERT(2*(-2) == 4, "the test framework works"); - UCX_TEST_END -} - -UCX_TEST_SUBROUTINE(testTestSuiteRoutineRoutine, float f) { - UCX_TEST_ASSERT(f == 3.14f, "calling routine in a routine fails"); -} - -UCX_TEST_SUBROUTINE(testTestSuiteRoutine2Param, int i, float f) { - UCX_TEST_ASSERT(i == 42, "two parameter routine fails"); - UCX_TEST_CALL_SUBROUTINE(testTestSuiteRoutineRoutine, f); -} - -UCX_TEST_SUBROUTINE(testTestSuiteRoutineSuccess, int* i) { - *i += 2; - UCX_TEST_ASSERT(*i==4, "the test framework fails"); -} - -UCX_TEST_SUBROUTINE(testTestSuiteRoutineFailure, int* i) { - *i += 2; - // Next test shall fail! - UCX_TEST_ASSERT(*i==4, "the test framework works"); -} - -UCX_TEST(testTestSuiteRoutinePositive) { - int i = 2; - UCX_TEST_BEGIN - UCX_TEST_CALL_SUBROUTINE(testTestSuiteRoutineSuccess, &i); - UCX_TEST_ASSERT(i==4, "the test framework fails"); - UCX_TEST_END -} - -UCX_TEST(testTestSuiteRoutineNegative) { - int i = 0; - UCX_TEST_BEGIN - UCX_TEST_CALL_SUBROUTINE(testTestSuiteRoutineFailure, &i); - UCX_TEST_ASSERT(1, "the test framework fails"); - UCX_TEST_END -} - -UCX_TEST(testTestSuiteRoutineMultiparam) { - UCX_TEST_BEGIN - UCX_TEST_CALL_SUBROUTINE(testTestSuiteRoutine2Param, 42, 3.14f); - UCX_TEST_END -} -#ifdef __cplusplus -} -#endif - -int main(int argc, char **argv) { - printf("UCX Tests\n---------\n"); - - printf("\nUcxTestSuite tests (2 failures are intended!)\n"); - UcxTestSuite* suite = ucx_test_suite_new(); - ucx_test_register(suite, testTestSuitePositive); - ucx_test_register(suite, testTestSuiteNegative); - ucx_test_register(suite, testTestSuiteRoutinePositive); - ucx_test_register(suite, testTestSuiteRoutineNegative); - ucx_test_register(suite, testTestSuiteRoutineMultiparam); - ucx_test_run(suite, stdout); - if (suite->failure == 2 && suite->success == 3) { - ucx_test_suite_free(suite); - - printf("\nLibrary function tests\n"); - suite = ucx_test_suite_new(); - /* UcxAllocator Tests */ - ucx_test_register(suite, test_ucx_default_allocator); - - /* sstring Tests */ - ucx_test_register(suite, test_sstr_macros); - ucx_test_register(suite, test_sstr); - ucx_test_register(suite, test_sstr_len); - ucx_test_register(suite, test_sstrcmp); - ucx_test_register(suite, test_sstrcasecmp); - ucx_test_register(suite, test_sstrcat); - ucx_test_register(suite, test_sstrchr_sstrrchr); - ucx_test_register(suite, test_sstrstr); - ucx_test_register(suite, test_sstrsplit); - ucx_test_register(suite, test_sstrtrim); - ucx_test_register(suite, test_sstrprefixsuffix); - ucx_test_register(suite, test_sstrcaseprefixsuffix); - ucx_test_register(suite, test_sstrreplace); - - /* UcxLogger Tests */ - ucx_test_register(suite, test_ucx_logger_new); - ucx_test_register(suite, test_ucx_logger_log); - - /* UcxArray Tests */ - ucx_test_register(suite, test_ucx_array_destroy); - ucx_test_register(suite, test_ucx_array_new); - ucx_test_register(suite, test_ucx_array_at); - ucx_test_register(suite, test_ucx_array_append_from); - ucx_test_register(suite, test_ucx_array_append_from_struct); - ucx_test_register(suite, test_ucx_array_prepend_from); - ucx_test_register(suite, test_ucx_array_set_from); - ucx_test_register(suite, test_ucx_array_equals); - ucx_test_register(suite, test_ucx_array_concat); - ucx_test_register(suite, test_ucx_array_find); - ucx_test_register(suite, test_ucx_array_contains); - ucx_test_register(suite, test_ucx_array_remove); - ucx_test_register(suite, test_ucx_array_clone); - ucx_test_register(suite, test_ucx_array_sort); - ucx_test_register(suite, test_ucx_array_shrink); - ucx_test_register(suite, test_ucx_array_resize); - ucx_test_register(suite, test_ucx_array_reserve); - ucx_test_register(suite, test_ucx_array_grow); - ucx_test_register(suite, test_ucx_array_util_set); - ucx_test_register(suite, test_ucx_array_util_setptr); - - /* UcxList Tests */ - ucx_test_register(suite, test_ucx_list_append); - ucx_test_register(suite, test_ucx_list_prepend); - ucx_test_register(suite, test_ucx_list_equals); - ucx_test_register(suite, test_ucx_list_concat); - ucx_test_register(suite, test_ucx_list_size); - ucx_test_register(suite, test_ucx_list_first); - ucx_test_register(suite, test_ucx_list_last); - ucx_test_register(suite, test_ucx_list_get); - ucx_test_register(suite, test_ucx_list_indexof); - ucx_test_register(suite, test_ucx_list_find); - ucx_test_register(suite, test_ucx_list_contains); - ucx_test_register(suite, test_ucx_list_remove); - ucx_test_register(suite, test_ucx_list_clone); - ucx_test_register(suite, test_ucx_list_sort); - ucx_test_register(suite, test_ucx_list_union); - ucx_test_register(suite, test_ucx_list_intersection); - ucx_test_register(suite, test_ucx_list_difference); - - /* UcxMemPool Tests */ - ucx_test_register(suite, test_ucx_mempool_new); - ucx_test_register(suite, test_ucx_mempool_malloc); - ucx_test_register(suite, test_ucx_mempool_malloc_with_chcap); - ucx_test_register(suite, test_ucx_mempool_calloc); - ucx_test_register(suite, test_ucx_mempool_free); - ucx_test_register(suite, test_ucx_mempool_set_destr); - ucx_test_register(suite, test_ucx_mempool_reg_destr); - ucx_test_register(suite, test_ucx_mempool_realloc); - - /* UcxStack Tests */ - ucx_test_register(suite, test_ucx_stack_init); - ucx_test_register(suite, test_ucx_stack_malloc); - ucx_test_register(suite, test_ucx_stack_calloc); - ucx_test_register(suite, test_ucx_stack_free); - ucx_test_register(suite, test_ucx_stack_realloc); - ucx_test_register(suite, test_ucx_stack_pop); - - /* UcxMap Tests */ - ucx_test_register(suite, test_ucx_map_new); - ucx_test_register(suite, test_ucx_key); - ucx_test_register(suite, test_ucx_map_put); - ucx_test_register(suite, test_ucx_map_get); - ucx_test_register(suite, test_ucx_map_remove); - ucx_test_register(suite, test_ucx_map_clear); - ucx_test_register(suite, test_ucx_map_iterator); - ucx_test_register(suite, test_ucx_map_iterator_chain); - ucx_test_register(suite, test_ucx_map_clone); - ucx_test_register(suite, test_ucx_map_rehash); - ucx_test_register(suite, test_ucx_map_union); - ucx_test_register(suite, test_ucx_map_intersection); - ucx_test_register(suite, test_ucx_map_difference); - - /* UcxPropertiesParser Tests */ - ucx_test_register(suite, test_ucx_properties_new); - ucx_test_register(suite, test_ucx_properties_next); - ucx_test_register(suite, test_ucx_properties_next_multi); - ucx_test_register(suite, test_ucx_properties_next_part); - ucx_test_register(suite, test_ucx_properties_next_long); - ucx_test_register(suite, test_ucx_properties2map); - ucx_test_register(suite, test_ucx_properties_load); - ucx_test_register(suite, test_ucx_properties_store); - - /* UcxBuffer Tests */ - ucx_test_register(suite, test_ucx_buffer_new); - ucx_test_register(suite, test_ucx_buffer_new_prealloc); - ucx_test_register(suite, test_ucx_buffer_eof); - ucx_test_register(suite, test_ucx_buffer_seek_set); - ucx_test_register(suite, test_ucx_buffer_seek_cur); - ucx_test_register(suite, test_ucx_buffer_seek_end); - ucx_test_register(suite, test_ucx_buffer_seek_oob); - ucx_test_register(suite, test_ucx_buffer_seek_invalid); - ucx_test_register(suite, test_ucx_buffer_seek_overflow); - ucx_test_register(suite, test_ucx_buffer_putc); - ucx_test_register(suite, test_ucx_buffer_putc_ae); - ucx_test_register(suite, test_ucx_buffer_putc_oob); - ucx_test_register(suite, test_ucx_buffer_putc_oobae); - ucx_test_register(suite, test_ucx_buffer_putc_size); - ucx_test_register(suite, test_ucx_buffer_getc); - ucx_test_register(suite, test_ucx_buffer_read); - ucx_test_register(suite, test_ucx_buffer_read_oob); - ucx_test_register(suite, test_ucx_buffer_extract); - ucx_test_register(suite, test_ucx_buffer_extract_oob); - ucx_test_register(suite, test_ucx_buffer_extract_overflow); - ucx_test_register(suite, test_ucx_buffer_extend); - ucx_test_register(suite, test_ucx_buffer_write); - ucx_test_register(suite, test_ucx_buffer_write_oob); - ucx_test_register(suite, test_ucx_buffer_write_ax); - ucx_test_register(suite, test_ucx_buffer_shl); - ucx_test_register(suite, test_ucx_buffer_shr); - ucx_test_register(suite, test_ucx_buffer_shr_ax); - - /* Utils Tests*/ - ucx_test_register(suite, test_ucx_fprintf); - ucx_test_register(suite, test_ucx_asprintf); - ucx_test_register(suite, test_ucx_sprintf); - ucx_test_register(suite, test_ucx_bprintf); - ucx_test_register(suite, test_ucx_stream_copy); - - /* AVL Tests */ - ucx_test_register(suite, test_ucx_avl_put); - ucx_test_register(suite, test_ucx_avl_remove); - ucx_test_register(suite, test_ucx_avl_find); - ucx_test_register(suite, test_ucx_avl_traverse); - - ucx_test_run(suite, stdout); - fflush(stdout); - - int exit_code = suite->failure > 0 ? EXIT_FAILURE: EXIT_SUCCESS; - - ucx_test_suite_free(suite); - - return exit_code; - } else { - ucx_test_suite_free(suite); - return EXIT_FAILURE; - } -} - diff -r 92e482410453 -r d345541018fa test/main.h --- a/test/main.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,46 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef MAIN_H -#define MAIN_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Some functions that are shared over the test */ -int cmp_string(void*, void*, void*); -void* copy_string(void*, void*); - - -#ifdef __cplusplus -} -#endif - -#endif /* MAIN_H */ - diff -r 92e482410453 -r d345541018fa test/map_tests.c --- a/test/map_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,431 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "map_tests.h" -#include - -UCX_TEST(test_ucx_map_new) { - UcxMap *map = ucx_map_new(16); - UCX_TEST_BEGIN - UCX_TEST_ASSERT(map->size == 16, "wrong size"); - UCX_TEST_ASSERT(map->map != NULL, "failed"); - - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_key) { - UcxKey key = ucx_key("This is a text.", 15); - UCX_TEST_BEGIN - UCX_TEST_ASSERT(strncmp((const char*)key.data, "This is a text.", 15) == 0, - "failed"); - UCX_TEST_ASSERT(key.len == 15, "failed"); - UCX_TEST_ASSERT(key.hash == 1261186027, "hash failed"); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_map_put) { - - UcxMap *map = ucx_map_new(4); - - int td[5]; - td[0] = 10; td[1] = 42; td[2] = 70; td[3] = 11200; td[4] = 80000; - - UCX_TEST_BEGIN - ucx_map_cstr_put(map, "Key2", &td[2]); /* 3.2 */ - ucx_map_cstr_put(map, "Key0", &td[0]); /* 0.0 */ - ucx_map_cstr_put(map, "Key1", &td[1]); /* 3.0 */ - ucx_map_cstr_put(map, "KeY3", &td[3]); /* 3.1 */ - ucx_map_cstr_put(map, "KEY4", &td[4]); /* 1.0 */ - - UCX_TEST_ASSERT(*((int*)map->map[0]->data) == td[0], "failed Key0"); - UCX_TEST_ASSERT(*((int*)map->map[1]->data) == td[4], "failed KEY4"); - UCX_TEST_ASSERT(*((int*)map->map[3]->data) == td[1], "failed Key1"); - - UCX_TEST_ASSERT(map->map[3]->next != NULL, "no list at slot 3"); - UCX_TEST_ASSERT(map->map[3]->next->next != NULL, "list corrupt at slot 3"); - UCX_TEST_ASSERT(*((int*)map->map[3]->next->data) == td[3], - "failed KeY3") - UCX_TEST_ASSERT(*((int*)map->map[3]->next->next->data) == td[2], - "failed KeY2"); - - UCX_TEST_ASSERT(map->map[0]->next == NULL, "slot 0 not terminated"); - UCX_TEST_ASSERT(map->map[1]->next == NULL, "slot 1 not terminated"); - UCX_TEST_ASSERT(map->map[2] == NULL, "slot 2 not empty"); - UCX_TEST_ASSERT(map->map[3]->next->next->next == NULL, - "slot 3 not terminated") - - ucx_map_cstr_put(map, "KeY3", &td[4]); /* replace 3.1 */ - - UCX_TEST_ASSERT(*((int*)map->map[3]->data) == td[1], - "overwrite failed") - UCX_TEST_ASSERT(*((int*)map->map[3]->next->data) == td[4], - "overwrite failed"); - UCX_TEST_ASSERT(*((int*)map->map[3]->next->next->data) == td[2], - "overwrite failed") - UCX_TEST_ASSERT(map->map[3]->next->next->next == NULL, "overwrite failed"); - - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_get) { - UcxMap *map = ucx_map_new(4); - - int td[5]; - td[0] = 10; td[1] = 42; td[2] = 70; td[3] = 11200; td[4] = 80000; - - ucx_map_cstr_put(map, "Key2", &td[2]); - ucx_map_cstr_put(map, "Key0", &td[0]); - ucx_map_cstr_put(map, "Key1", &td[1]); - ucx_map_cstr_put(map, "KeY3", &td[3]); - ucx_map_cstr_put(map, "KEY4", &td[4]); - UCX_TEST_BEGIN - - td[0] = *((int*)ucx_map_cstr_get(map, "Key0")); - td[1] = *((int*)ucx_map_cstr_get(map, "Key1")); - td[2] = *((int*)ucx_map_cstr_get(map, "Key2")); - td[3] = *((int*)ucx_map_cstr_get(map, "KeY3")); - td[4] = *((int*)ucx_map_cstr_get(map, "KEY4")); - UCX_TEST_ASSERT(td[0] == 10, "failed key 0"); - UCX_TEST_ASSERT(td[1] == 42, "failed key 1"); - UCX_TEST_ASSERT(td[2] == 70, "failed key 2"); - UCX_TEST_ASSERT(td[3] == 11200, "failed key 3"); - UCX_TEST_ASSERT(td[4] == 80000, "failed key 4"); - - UCX_TEST_ASSERT(map->count == 5, "expected 5 remaining values"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key0") != NULL, "element removed"); - - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_remove) { - UcxMap *map = ucx_map_new(4); - - int td[5]; - td[0] = 10; td[1] = 42; td[2] = 70; td[3] = 11200; td[4] = 80000; - - ucx_map_cstr_put(map, "Key2", &td[2]); /* 0 */ - ucx_map_cstr_put(map, "Key0", &td[0]); /* 0 */ - ucx_map_cstr_put(map, "Key1", &td[1]); /* 3 */ - ucx_map_cstr_put(map, "KeY3", &td[3]); /* 2 */ - ucx_map_cstr_put(map, "KEY4", &td[4]); /* 0 */ - UCX_TEST_BEGIN - - td[0] = *((int*)ucx_map_cstr_remove(map, "Key0")); - td[1] = *((int*)ucx_map_cstr_get(map, "Key1")); - td[2] = *((int*)ucx_map_cstr_remove(map, "Key2")); - td[3] = *((int*)ucx_map_cstr_get(map, "KeY3")); - td[4] = *((int*)ucx_map_cstr_get(map, "KEY4")); - UCX_TEST_ASSERT(td[0] == 10, "failed key 0"); - UCX_TEST_ASSERT(td[1] == 42, "failed key 1"); - UCX_TEST_ASSERT(td[2] == 70, "failed key 2"); - UCX_TEST_ASSERT(td[3] == 11200, "failed key 3"); - UCX_TEST_ASSERT(td[4] == 80000, "failed key 4"); - - UCX_TEST_ASSERT(map->count == 3, "expected 3 remaining values"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key0")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key1")!=NULL, "element removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key2")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "KeY3")!=NULL, "element removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "KEY4")!=NULL, "element removed"); - - UCX_TEST_ASSERT(ucx_map_cstr_remove(map, "Key2") == NULL, - "subsequent remove call shall return NULL"); - - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_clear) { - UcxMap *map = ucx_map_new(4); - - int value = 42; - - ucx_map_cstr_put(map, "Key0", &value); - ucx_map_cstr_put(map, "Key1", &value); - ucx_map_cstr_put(map, "Key2", &value); - ucx_map_cstr_put(map, "Key3", &value); - ucx_map_cstr_put(map, "Key4", &value); - ucx_map_cstr_put(map, "Key5", &value); - ucx_map_cstr_put(map, "Key6", &value); - UCX_TEST_BEGIN - - ucx_map_clear(map); - - UCX_TEST_ASSERT(map->count == 0, "map has not been cleared"); - UCX_TEST_ASSERT(map->size == 4, "map size has changed unexpectedly"); - - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key0")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key1")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key2")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key3")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key4")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key5")==NULL, "element not removed"); - UCX_TEST_ASSERT(ucx_map_cstr_get(map, "Key6")==NULL, "element not removed"); - - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST_SUBROUTINE(test_ucx_map_itersrt, UcxMap *map) { - int v1 = 10; - int v2 = 15; - int v3 = 7; - int v4 = 9; - - ucx_map_cstr_put(map, "v1", &v1); - ucx_map_cstr_put(map, "v2", &v2); - ucx_map_cstr_put(map, "v3", &v3); - ucx_map_cstr_put(map, "v4", &v4); - - UcxMapIterator i = ucx_map_iterator(map); - int check = 0; - int hit = 0; - - void* v; - UCX_MAP_FOREACH(key, v, i) { - check += *((int*)v); - hit++; - } - - UCX_TEST_ASSERT(hit == 4, "test1: wrong number of hits"); - UCX_TEST_ASSERT(check == v1+v2+v3+v4, "test1: wrong result"); -} - -UCX_TEST(test_ucx_map_iterator) { - UcxMap *map = ucx_map_new(16); - UCX_TEST_BEGIN - UCX_TEST_CALL_SUBROUTINE(test_ucx_map_itersrt, map) - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_iterator_chain) { - UcxMap *map = ucx_map_new(1); - UCX_TEST_BEGIN - UCX_TEST_CALL_SUBROUTINE(test_ucx_map_itersrt, map) - UCX_TEST_END - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_clone) { - UcxMap *map = ucx_map_new(4); - - ucx_map_cstr_put(map, "key1", (void*)"value1"); - ucx_map_cstr_put(map, "key2", (void*)"value2"); - ucx_map_cstr_put(map, "key3", (void*)"value3"); - - UcxMap *clone = ucx_map_clone(map, NULL, NULL); - - const char *v1 = (const char *) ucx_map_cstr_get(map, "key1"); - const char *v2 = (const char *) ucx_map_cstr_get(map, "key2"); - const char *v3 = (const char *) ucx_map_cstr_get(map, "key3"); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(v1 != NULL, "failed key 1"); - UCX_TEST_ASSERT(v2 != NULL, "failed key 2"); - UCX_TEST_ASSERT(v3 != NULL, "failed key 3"); - - const char *c1 = (const char *) ucx_map_cstr_get(clone, "key1"); - const char *c2 = (const char *) ucx_map_cstr_get(clone, "key2"); - const char *c3 = (const char *) ucx_map_cstr_get(clone, "key3"); - - UCX_TEST_ASSERT(c1 != NULL, "failed key 1 (clone)"); - UCX_TEST_ASSERT(c2 != NULL, "failed key 2 (clone)"); - UCX_TEST_ASSERT(c3 != NULL, "failed key 3 (clone)"); - - UCX_TEST_ASSERT(strcmp(c1, v1) == 0, "value error for key1"); - UCX_TEST_ASSERT(strcmp(c2, v2) == 0, "value error for key2"); - UCX_TEST_ASSERT(strcmp(c3, v3) == 0, "value error for key3"); - - UCX_TEST_END - - ucx_map_free(map); - ucx_map_free(clone); -} - -UCX_TEST(test_ucx_map_rehash) { - UcxMap *map = ucx_map_new(4); - - char keys[10][5]; - char values[10][7]; - for (int i = 0 ; i < 10 ; i++) { - strcpy(keys[i], "key"); - keys[i][3] = 48+i; keys[i][4] = 0; - strcpy(values[i], "value"); - values[i][5] = 48+i; values[i][6] = 0; - - ucx_map_cstr_put(map, keys[i], values[i]); - } - - ucx_map_rehash(map); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(map->size == 25, "new capacity shall be 2.5 * count"); - UCX_TEST_ASSERT(map->count == 10, "new map element count incorrect"); - for (int i = 0 ; i < 10 ; i++) { - const char *value = (const char *) ucx_map_cstr_get(map, keys[i]); - UCX_TEST_ASSERT(value != NULL, "new map is missing old keys"); - UCX_TEST_ASSERT(strncmp(value, values[i], 6) == 0, - "new map contains incorrect values"); - } - ucx_map_rehash(map); - UCX_TEST_ASSERT(map->size == 25, - "subsequent rehashing call shall not change size"); - UCX_TEST_END - - ucx_map_free(map); -} - -UCX_TEST(test_ucx_map_union) { - int td[5]; - size_t intlen = sizeof(int); - td[0] = 10; td[1] = 42; td[2] = 47; td[3] = 1337; td[4] = 9000; - - UcxMap *first = ucx_map_new(4); - UcxMap *second = ucx_map_new(4); - - ucx_map_cstr_put(first, "key0", &td[0]); - ucx_map_cstr_put(first, "key1", &td[1]); - ucx_map_cstr_put(second, "key2", &td[2]); - ucx_map_cstr_put(second, "key0", &td[3]); - ucx_map_cstr_put(second, "key3", &td[4]); - - UcxMap *result = ucx_map_union(first, second, ucx_memcpy, &intlen); - - UCX_TEST_BEGIN - - int* r; - UCX_TEST_ASSERT(result->count == 4, - "result has incorrect number of elements"); - - r = (int*)ucx_map_cstr_get(result, "key0"); - UCX_TEST_ASSERT(!!r, "key0 is not present"); - UCX_TEST_ASSERT(*r == td[3], "key0 has not been overwritten"); - r = (int*)ucx_map_cstr_get(result, "key1"); - UCX_TEST_ASSERT(!!r, "key1 is not present"); - UCX_TEST_ASSERT(*r == td[1], "key1 contains wrong data"); - r = (int*)ucx_map_cstr_get(result, "key2"); - UCX_TEST_ASSERT(!!r, "key2 is not present"); - UCX_TEST_ASSERT(*r == td[2], "key2 contains wrong data"); - r = (int*)ucx_map_cstr_get(result, "key3"); - UCX_TEST_ASSERT(!!r, "key3 is not present"); - UCX_TEST_ASSERT(*r == td[4], "key3 contains wrong data"); - - UCX_TEST_END - - ucx_map_free_content(result, NULL); - ucx_map_free(result); - ucx_map_free(second); - ucx_map_free(first); -} - -UCX_TEST(test_ucx_map_intersection) { - int td[5]; - size_t intlen = sizeof(int); - td[0] = 10; td[1] = 42; td[2] = 47; td[3] = 1337; td[4] = 9000; - - UcxMap *first = ucx_map_new(4); - UcxMap *second = ucx_map_new(4); - - ucx_map_cstr_put(first, "key0", &td[0]); - ucx_map_cstr_put(first, "key1", &td[1]); - ucx_map_cstr_put(first, "key4", &td[3]); - ucx_map_cstr_put(second, "key2", &td[2]); - ucx_map_cstr_put(second, "key0", &td[3]); - ucx_map_cstr_put(second, "key3", &td[4]); - ucx_map_cstr_put(second, "key4", &td[4]); - - UcxMap *result = ucx_map_intersection(first, second, - ucx_memcpy, &intlen); - - UCX_TEST_BEGIN - - int* r; - UCX_TEST_ASSERT(result->count == 2, - "result has incorrect number of elements"); - - r = (int*)ucx_map_cstr_get(result, "key0"); - UCX_TEST_ASSERT(!!r, "key0 is not present"); - UCX_TEST_ASSERT(*r == td[0], "key0 has not original data"); - r = (int*)ucx_map_cstr_get(result, "key4"); - UCX_TEST_ASSERT(!!r, "key4 is not present"); - UCX_TEST_ASSERT(*r == td[3], "key4 has not original data"); - - UCX_TEST_END - - ucx_map_free_content(result, NULL); - ucx_map_free(result); - ucx_map_free(second); - ucx_map_free(first); -} - - -UCX_TEST(test_ucx_map_difference) { - int td[5]; - size_t intlen = sizeof(int); - td[0] = 10; td[1] = 42; td[2] = 47; td[3] = 1337; td[4] = 9000; - - UcxMap *first = ucx_map_new(4); - UcxMap *second = ucx_map_new(4); - - ucx_map_cstr_put(first, "key0", &td[0]); - ucx_map_cstr_put(first, "key1", &td[1]); - ucx_map_cstr_put(first, "key2", &td[2]); - ucx_map_cstr_put(first, "key4", &td[3]); - ucx_map_cstr_put(second, "key0", &td[3]); - ucx_map_cstr_put(second, "key3", &td[4]); - ucx_map_cstr_put(second, "key4", &td[4]); - - UcxMap *result = ucx_map_difference(first, second, ucx_memcpy, &intlen); - - UCX_TEST_BEGIN - - int* r; - UCX_TEST_ASSERT(result->count == 2, - "result has incorrect number of elements"); - - r = (int*)ucx_map_cstr_get(result, "key1"); - UCX_TEST_ASSERT(!!r, "key1 is not present"); - UCX_TEST_ASSERT(*r == td[1], "key1 has incorrect data"); - r = (int*)ucx_map_cstr_get(result, "key2"); - UCX_TEST_ASSERT(!!r, "key2 is not present"); - UCX_TEST_ASSERT(*r == td[2], "key2 has incorrect data"); - - UCX_TEST_END - - ucx_map_free_content(result, NULL); - ucx_map_free(result); - ucx_map_free(second); - ucx_map_free(first); -} - diff -r 92e482410453 -r d345541018fa test/map_tests.h --- a/test/map_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef MAP_TESTS_H -#define MAP_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_map_new); -UCX_TEST(test_ucx_key); -UCX_TEST(test_ucx_map_put); -UCX_TEST(test_ucx_map_get); -UCX_TEST(test_ucx_map_remove); -UCX_TEST(test_ucx_map_clear); -UCX_TEST(test_ucx_map_iterator); -UCX_TEST(test_ucx_map_iterator_chain); -UCX_TEST(test_ucx_map_clone); -UCX_TEST(test_ucx_map_rehash); -UCX_TEST(test_ucx_map_union); -UCX_TEST(test_ucx_map_intersection); -UCX_TEST(test_ucx_map_difference); - - -#ifdef __cplusplus -} -#endif - -#endif /* MAP_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/mpool_tests.c --- a/test/mpool_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,239 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include - -#include "mpool_tests.h" - -UCX_TEST(test_ucx_mempool_new) { - UcxMempool *pool = ucx_mempool_new(16); - UCX_TEST_BEGIN - UCX_TEST_ASSERT(pool->size == 16, "wrong size"); - UCX_TEST_ASSERT(pool->ndata == 0, "uninitialized counter"); - UCX_TEST_ASSERT(pool->data != NULL, "no memory addressed"); - UCX_TEST_END - ucx_mempool_destroy(pool); -} - -UCX_TEST(test_ucx_mempool_malloc) { - - UcxMempool *pool = ucx_mempool_new(1); - UCX_TEST_BEGIN - intptr_t *test = (intptr_t*) ucx_mempool_malloc(pool, sizeof(intptr_t)); - - UCX_TEST_ASSERT(pool->ndata == 1, "counter not incremented"); - UCX_TEST_ASSERT(pool->size == 1, "chcap called"); - - intptr_t *pooladdr = - (intptr_t*)((char*)pool->data[0] + sizeof(ucx_destructor)); - *pooladdr = 5; - - UCX_TEST_ASSERT(*test == 5, "wrong pointer"); - - UCX_TEST_END - ucx_mempool_destroy(pool); -} - -UCX_TEST(test_ucx_mempool_malloc_with_chcap) { - - UcxMempool *pool = ucx_mempool_new(1); - UCX_TEST_BEGIN - ucx_mempool_malloc(pool, sizeof(int)); - intptr_t *test = (intptr_t*) ucx_mempool_malloc(pool, sizeof(intptr_t)); - - UCX_TEST_ASSERT(pool->ndata == 2, "counter not incremented"); - UCX_TEST_ASSERT(pool->size == 2, "chcap not called"); - - intptr_t *pooladdr = - (intptr_t*)((char*)pool->data[1] + sizeof(ucx_destructor)); - *pooladdr = 5; - - UCX_TEST_ASSERT(*test == 5, "wrong pointer"); - - // overflow test - void *n0 = ucx_mempool_malloc(pool, (size_t)-1); - void *n1 = ucx_mempool_malloc(pool, ((size_t)-1) - sizeof(void*)/2); - - UCX_TEST_ASSERT(n0 == NULL, "should not allocate SIZE_MAX bytes"); - UCX_TEST_ASSERT(n1 == NULL, "should detect integer overflow"); - - UCX_TEST_END - ucx_mempool_destroy(pool); -} - -UCX_TEST(test_ucx_mempool_calloc) { - - UcxMempool *pool = ucx_mempool_new(1); - UCX_TEST_BEGIN - - intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t)); - - UCX_TEST_ASSERT(test != NULL, "no memory for test data"); - UCX_TEST_ASSERT(test[0] == 0 && test[1] == 0, "failed"); - - // overflow test - void *n0 = ucx_mempool_calloc(pool, (size_t)-1, 1); - void *n1 = ucx_mempool_calloc(pool, ((size_t)-1)/2, 3); - - UCX_TEST_ASSERT(n0 == NULL, "should not allocate SIZE_MAX bytes"); - UCX_TEST_ASSERT(n1 == NULL, "should detect integer overflow"); - - UCX_TEST_END - ucx_mempool_destroy(pool); -} - -UCX_TEST(test_ucx_mempool_free) { - UcxMempool *pool = ucx_mempool_new(16); - void *mem1; - void *mem2; - - UCX_TEST_BEGIN - - mem1 = ucx_mempool_malloc(pool, 16); - ucx_mempool_free(pool, mem1); - - UCX_TEST_ASSERT(pool->ndata == 0, "mempool not empty"); - - ucx_mempool_malloc(pool, 16); - ucx_mempool_malloc(pool, 16); - mem1 = ucx_mempool_malloc(pool, 16); - ucx_mempool_malloc(pool, 16); - mem2 = ucx_mempool_malloc(pool, 16); - - ucx_mempool_free(pool, mem1); - - UCX_TEST_ASSERT(pool->ndata == 4, "wrong mempool size"); - - ucx_mempool_free(pool, mem2); - - UCX_TEST_ASSERT(pool->ndata == 3, "wrong mempool size"); - - UCX_TEST_END - ucx_mempool_destroy(pool); -} - -#ifdef __cplusplus -extern "C" -#endif -void test_setdestr(void* elem) { - intptr_t *cb = (intptr_t*) ((intptr_t*) elem)[1]; - *cb = 42; -} - -UCX_TEST(test_ucx_mempool_set_destr) { - - intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t)); - UCX_TEST_BEGIN - UcxMempool *pool = ucx_mempool_new(2); - - ucx_mempool_malloc(pool, sizeof(intptr_t)); - intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t)); - - UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data"); - - test[0] = 5; test[1] = (intptr_t) cb; - *cb = 13; - - ucx_mempool_set_destr(test, test_setdestr); - UCX_TEST_ASSERT( - *(ucx_destructor*)(pool->data[1]) == test_setdestr, "failed") - UCX_TEST_ASSERT( - test[0] == 5 && test[1] == (intptr_t) cb, "setdestr destroyed data") - - ucx_mempool_destroy(pool); - - UCX_TEST_ASSERT(*cb == 42, "destructor not called"); - - UCX_TEST_END - if (cb != NULL) free(cb); -} - - -UCX_TEST(test_ucx_mempool_reg_destr) { - - intptr_t *test = (intptr_t*) calloc(2, sizeof(intptr_t)); - intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t)); - UCX_TEST_BEGIN - UcxMempool *pool = ucx_mempool_new(1); - - UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data"); - - test[0] = 5; test[1] = (intptr_t) cb; - *cb = 13; - - ucx_mempool_reg_destr(pool, test, test_setdestr); - - ucx_destructor *pooladdr = (ucx_destructor*) - ((char*)pool->data[0] + sizeof(ucx_destructor)); - - UCX_TEST_ASSERT(*pooladdr == test_setdestr, "failed"); - - ucx_mempool_destroy(pool); - UCX_TEST_ASSERT(*cb == 42, "destructor not called"); - UCX_TEST_END - - if (test != NULL) free(test); - if (cb != NULL) free(cb); -} - -UCX_TEST(test_ucx_mempool_realloc) { - - intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t)); - UCX_TEST_BEGIN - UcxMempool *pool = ucx_mempool_new(2); - - ucx_mempool_malloc(pool, sizeof(intptr_t)); - intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t)); - - UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data"); - - test[0] = 5; test[1] = (intptr_t) cb; - *cb = 13; - - ucx_mempool_set_destr(test, test_setdestr); - - intptr_t *rtest, n = 2; - do { - n *= 2; - UCX_TEST_ASSERT(n < 65536, "test corrupt - no movement for realloc"); - rtest = (intptr_t*) ucx_mempool_realloc(pool, test, n*sizeof(intptr_t)); - } while (rtest == test); - test = rtest; - - UCX_TEST_ASSERT(*(ucx_destructor*)(pool->data[1]) == test_setdestr, - "realloc killed destructor") - UCX_TEST_ASSERT( - test[0] == 5 && test[1] == (intptr_t) cb, "realloc destroyed data") - - ucx_mempool_destroy(pool); - - UCX_TEST_ASSERT(*cb == 42, "destructor not called"); - - UCX_TEST_END - if (cb != NULL) free(cb); -} diff -r 92e482410453 -r d345541018fa test/mpool_tests.h --- a/test/mpool_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,53 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef MPOOL_TESTS_H -#define MPOOL_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_mempool_new); -UCX_TEST(test_ucx_mempool_malloc); -UCX_TEST(test_ucx_mempool_malloc_with_chcap); -UCX_TEST(test_ucx_mempool_calloc); -UCX_TEST(test_ucx_mempool_free); -UCX_TEST(test_ucx_mempool_set_destr); -UCX_TEST(test_ucx_mempool_reg_destr); -UCX_TEST(test_ucx_mempool_realloc); - -#ifdef __cplusplus -} -#endif - -#endif /* MPOOL_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/prop_tests.c --- a/test/prop_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,545 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "prop_tests.h" -#include - -UCX_TEST(test_ucx_properties_new) { - UcxProperties *parser = ucx_properties_new(); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(parser != NULL, "failed"); - UCX_TEST_ASSERT(parser->buffer == NULL, "parser has buffer"); - UCX_TEST_ASSERT(parser->tmp == NULL, "parser has tmp buffer"); - - UCX_TEST_END - - ucx_properties_free(parser); -} - -UCX_TEST(test_ucx_properties_next) { - const char *tests[] = { - "name = value\n", - "name=value\n", - "n=value\n", - "name=v\n", - "n=v\n", - "name = value # comment\n", - "#comment\nn=v\n", - "# comment1\n# comment2\n\n \n\nname = value\n", - " name = value\n", - "name = value\n\n" - }; - - const char *names[] = { - "name", - "name", - "n", - "name", - "n", - "name", - "n", - "name", - "name", - "name" - }; - - const char *values[] = { - "value", - "value", - "value", - "v", - "v", - "value", - "v", - "value", - "value", - "value" - }; - - UCX_TEST_BEGIN - - sstr_t name; - sstr_t value; - - for(int i=0;i<10;i++) { - UcxProperties *parser = ucx_properties_new(); - - ucx_properties_fill(parser, (char*)tests[i], strlen(tests[i])); - UCX_TEST_ASSERT(parser->buffer == tests[i], "fill failed"); - UCX_TEST_ASSERT(parser->buflen == strlen(tests[i]), "wrong buflen"); - - int r = ucx_properties_next(parser, &name, &value); - sstr_t n = sstr((char*)names[i]); - sstr_t v = sstr((char*)values[i]); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong property name"); - UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong property value"); - - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - UCX_TEST_ASSERT(parser->tmp == NULL, "tmp not NULL"); - UCX_TEST_ASSERT(parser->tmpcap == 0, "tmpcap not NULL"); - UCX_TEST_ASSERT(parser->tmplen == 0, "tmplen not NULL"); - - ucx_properties_free(parser); - } - - UCX_TEST_END -} - -UCX_TEST(test_ucx_properties_next_multi) { - const char *names[] = { - "a", - "b", - "c", - "uap", - "name", - "key1", - "key2", - "key3" - }; - - const char *values[] = { - "a value", - "b value", - "core", - "core", - "ucx", - "value1", - "value2", - "value3" - }; - - const char *str = "#\n" - "# properties\n" - "# contains key/value pairs\n" - "#\n" - "a = a value\n" - "b = b value\n" - "c = core\n" - "\n# test\n" - "uap = core\n" - "name = ucx\n" - "# no = property\n" - "key1 = value1\n" - "#key1 = wrong value\n" - "#key2 = not value 2\n" - "key2 = value2\n" - "\n\n\n \n key3=value3\n"; - - UcxProperties *parser = ucx_properties_new(); - - UCX_TEST_BEGIN - - ucx_properties_fill(parser, (char*)str, strlen(str)); - - sstr_t name; - sstr_t value; - for(int i=0;i<8;i++) { - int r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)names[i]))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)values[i]))), - "wrong value"); - } - int r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - UCX_TEST_END - - ucx_properties_free(parser); -} - -UCX_TEST(test_ucx_properties_next_part) { - UcxProperties *parser = ucx_properties_new(); - const char *str; - int r; - sstr_t name; - sstr_t value; - - UCX_TEST_BEGIN - - str = ""; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = " \n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "name"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = " "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "= "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "value"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"name"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value"); - - // second round - str = "#comment\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "#comment\nname = "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "value\na = b\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"name"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value"); - - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"a"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"b"))), "wrong value"); - - str = "# comment\n#\n#\ntests = "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "test1 "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "test2 test3 test4\n"; - sstr_t testv = sstr((char*)"test1 test2 test3 test4"); - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"tests"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, testv)), "wrong value"); - - // test if ucx_properties_next finds a name/value after a tmp comment - str = "# just a comment"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = " in 3"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = " parts\na = 1\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"a"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"1"))), "wrong value"); - - UCX_TEST_END - - ucx_properties_free(parser); -} - -UCX_TEST(test_ucx_properties_next_long) { - UcxProperties *parser = ucx_properties_new(); - int r; - size_t name_len = 512; - char *long_name = (char*)malloc(name_len); - memset(long_name, 'a', 70); - memset(long_name+70, 'b', 242); - memset(long_name+312, 'c', 200); - - size_t value_len = 2048; - char *long_value = (char*)malloc(value_len); - memset(long_value, 'x', 1024); - memset(long_value+1024, 'y', 1024); - - UCX_TEST_BEGIN - - sstr_t name; - sstr_t value; - - ucx_properties_fill(parser, long_name, 10); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_name+10, 202); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_name+212, 200); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_name+412, 100); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - const char *str = " = "; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_value, 512); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_value+512, 1024); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - ucx_properties_fill(parser, long_value+1536, 512); - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - str = "\n#comment\nkey = value\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - r = ucx_properties_next(parser, &name, &value); - sstr_t n = sstrn(long_name, name_len); - sstr_t v = sstrn(long_value, value_len); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong value"); - - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 1, "next returned 0"); - UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"key"))), "wrong name"); - UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value"); - - r = ucx_properties_next(parser, &name, &value); - UCX_TEST_ASSERT(r == 0, "next returned 1"); - - UCX_TEST_END - - free(long_name); - free(long_value); - ucx_properties_free(parser); -} - -UCX_TEST(test_ucx_properties2map) { - UcxMempool *mp = ucx_mempool_new(64); - UcxMap *map = ucx_map_new_a(mp->allocator, 16); - UcxProperties *parser = ucx_properties_new(); - - UCX_TEST_BEGIN - - const char *str = "key1 = value1\nkey2 = value2\n\n#comment\n\nkey3 = value3\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - - int r = ucx_properties2map(parser, map); - - UCX_TEST_ASSERT(r == 0, "properties2map failed"); - UCX_TEST_ASSERT(map->count == 3, "wrong number of properties"); - - char *v1 = (char*)ucx_map_cstr_get(map, "key1"); - char *v2 = (char*)ucx_map_cstr_get(map, "key2"); - char *v3 = (char*)ucx_map_cstr_get(map, "key3"); - - UCX_TEST_ASSERT(v1, "value for key1 not found"); - UCX_TEST_ASSERT(v2, "value for key2 not found"); - UCX_TEST_ASSERT(v3, "value for key3 not found"); - - UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value for key1"); - UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value for key2"); - UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value for key3"); - - // second test - ucx_map_free(map); - map = ucx_map_new_a(mp->allocator, 16); - - str = "\n#comment\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - - r = ucx_properties2map(parser, map); - UCX_TEST_ASSERT(r == 0, "properties2map failed"); - UCX_TEST_ASSERT(map->count == 0, "wrong number of properties"); - - str = "key1 = value1\nsyntax error line\n"; - ucx_properties_fill(parser, (char*)str, strlen(str)); - - r = ucx_properties2map(parser, map); - UCX_TEST_ASSERT(r == 1, "properties2map should return 1"); - UCX_TEST_ASSERT(map->count == 1, "wrong number of properties"); - - char *v = (char*)ucx_map_cstr_get(map, "key1"); - UCX_TEST_ASSERT((!strcmp(v, "value1")), "wrong value"); - - UCX_TEST_END - - ucx_mempool_destroy(mp); - ucx_properties_free(parser); -} - -UCX_TEST(test_ucx_properties_load) { - UCX_TEST_BEGIN - FILE *f = tmpfile(); - UCX_TEST_ASSERT(f, "test file cannot be opened, test aborted"); - - fprintf(f, "# properties file\n\nkey1 = value1\nkey2 = value2\n"); - fprintf(f, "\n\nkey3 = value3\n\n"); - - size_t name_len = 512; - char *long_name = (char*)malloc(name_len); - memset(long_name, 'k', 512); - - size_t value_len = 2048; - char *long_value = (char*)malloc(value_len); - memset(long_value, 'v', 2048); - - fwrite(long_name, 1, name_len, f); - fprintf(f, " = "); - fwrite(long_value, 1, value_len, f); - fprintf(f, " \n"); - - fprintf(f, "\n\n\n\nlast_key = property value\n"); - - fflush(f); - fseek(f, 0, SEEK_SET); - - UcxMap *map = ucx_map_new(8); - int r = ucx_properties_load(map, f); - - UCX_TEST_ASSERT(r == 0, "ucx_properties_load failed"); - UCX_TEST_ASSERT(map->count == 5, "wrong number of properties"); - - char *v1 = (char*)ucx_map_cstr_get(map, "key1"); - char *v2 = (char*)ucx_map_cstr_get(map, "key2"); - char *v3 = (char*)ucx_map_cstr_get(map, "key3"); - char *lv = (char*)ucx_map_sstr_get(map, sstrn(long_name, name_len)); - char *lk = (char*)ucx_map_cstr_get(map, "last_key"); - - UCX_TEST_ASSERT(v1, "value for key1 not found"); - UCX_TEST_ASSERT(v2, "value for key2 not found"); - UCX_TEST_ASSERT(v3, "value for key3 not found"); - UCX_TEST_ASSERT(lv, "value for long key not found"); - UCX_TEST_ASSERT(lk, "value for last_key not found"); - - UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value for key1"); - UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value for key2"); - UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value for key3"); - sstr_t long1 = sstrn(long_value, value_len); - sstr_t long2 = sstr(lv); - UCX_TEST_ASSERT((!sstrcmp(long1, long2)), "wrong value for long key"); - UCX_TEST_ASSERT(!strcmp(lk, "property value"), "wrong value for last_key"); - - free(v1); - free(v2); - free(v3); - free(lv); - free(lk); - ucx_map_free(map); - fclose(f); - - free(long_name); - free(long_value); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_properties_store) { - UcxMap *map1 = ucx_map_new(16); - ucx_map_cstr_put(map1, "key1", "value1"); - ucx_map_cstr_put(map1, "key2", "value2"); - ucx_map_cstr_put(map1, "key3", "value3"); - ucx_map_cstr_put(map1, "key4", "value4"); - ucx_map_cstr_put(map1, "property.key1", "some value 1"); - ucx_map_cstr_put(map1, "property.key2", "some value 2"); - ucx_map_cstr_put(map1, "property.key3", "some value 3"); - ucx_map_cstr_put(map1, "property.key4", "some value 4"); - - UCX_TEST_BEGIN - - FILE *f = tmpfile(); - fprintf(f, "#\n# test property file\n#\n#\n"); - ucx_properties_store(map1, f); - - fflush(f); - fseek(f, 0, SEEK_SET); - UcxMap *map2 = ucx_map_new(16); - ucx_properties_load(map2, f); - - UCX_TEST_ASSERT(map2->count == 8, "wrong number of properties in map2"); - - char *v1 = (char*)ucx_map_cstr_get(map2, "key1"); - char *v2 = (char*)ucx_map_cstr_get(map2, "key2"); - char *v3 = (char*)ucx_map_cstr_get(map2, "key3"); - char *v4 = (char*)ucx_map_cstr_get(map2, "key4"); - char *v5 = (char*)ucx_map_cstr_get(map2, "property.key1"); - char *v6 = (char*)ucx_map_cstr_get(map2, "property.key2"); - char *v7 = (char*)ucx_map_cstr_get(map2, "property.key3"); - char *v8 = (char*)ucx_map_cstr_get(map2, "property.key4"); - - UCX_TEST_ASSERT(v1 && v2 && v3 && v4 && v5 && v6 && v7 && v8, - "missing values"); - - UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value 1"); - UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value 2"); - UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value 3"); - UCX_TEST_ASSERT((!strcmp(v4, "value4")), "wrong value 4"); - UCX_TEST_ASSERT((!strcmp(v5, "some value 1")), "wrong value 5"); - UCX_TEST_ASSERT((!strcmp(v6, "some value 2")), "wrong value 6"); - UCX_TEST_ASSERT((!strcmp(v7, "some value 3")), "wrong value 7"); - UCX_TEST_ASSERT((!strcmp(v8, "some value 4")), "wrong value 8"); - - free(v1); - free(v2); - free(v3); - free(v4); - free(v5); - free(v6); - free(v7); - free(v8); - ucx_map_free(map2); - fclose(f); - - UCX_TEST_END - - ucx_map_free(map1); -} diff -r 92e482410453 -r d345541018fa test/prop_tests.h --- a/test/prop_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,53 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef PROP_TESTS_H -#define PROP_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_properties_new); -UCX_TEST(test_ucx_properties_next); -UCX_TEST(test_ucx_properties_next_multi); -UCX_TEST(test_ucx_properties_next_part); -UCX_TEST(test_ucx_properties_next_long); -UCX_TEST(test_ucx_properties2map); -UCX_TEST(test_ucx_properties_load); -UCX_TEST(test_ucx_properties_store); - -#ifdef __cplusplus -} -#endif - -#endif /* PROP_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/stack_tests.c --- a/test/stack_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,209 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "stack_tests.h" - -#define test_ucx_stack_before \ - char space[99]; \ - UcxStack stack; \ - ucx_stack_init(&stack, space, 99) \ - -UCX_TEST(test_ucx_stack_init) { - - test_ucx_stack_before; - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT( - stack.allocator.malloc == (ucx_allocator_malloc) ucx_stack_malloc && - stack.allocator.calloc == (ucx_allocator_calloc) ucx_stack_calloc && - stack.allocator.realloc == (ucx_allocator_realloc) ucx_stack_realloc && - stack.allocator.free == (ucx_allocator_free) ucx_stack_free && - stack.allocator.pool == &stack, - "allocator not properly set"); - - UCX_TEST_ASSERT(!stack.top && stack.space == space - && stack.size == 99 - 99 % sizeof(void*), - "struct fields not properly set"); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_stack_malloc) { - - test_ucx_stack_before; - - const size_t metasize = sizeof(struct ucx_stack_metadata); - - - char* first = (char*) ucx_stack_malloc(&stack, 30); - char* second = (char*) ucx_stack_malloc(&stack, 30); - char* full = (char*) ucx_stack_malloc(&stack, 30); - - memcpy(first, "012345678901234567890123456789", 30); - memcpy(second, "abcdefghijklmnopqrstuvwxyzABCD", 30); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!memcmp(space + metasize, - "012345678901234567890123456789", 30), "first element corrupted"); - UCX_TEST_ASSERT(!memcmp(space + 32+2*metasize, - "abcdefghijklmnopqrstuvwxyzABCD", 30), "first element corrupted"); - - UCX_TEST_ASSERT(!full, "stack can be overflowed"); - UCX_TEST_ASSERT(stack.top == space + 32 + 2*metasize, "wrong top pointer"); - - if (3*metasize < 32) { - UCX_TEST_ASSERT(ucx_stack_avail(&stack) == 32-3*metasize, - "wrong remaining available memory"); - } else { - UCX_TEST_ASSERT(ucx_stack_avail(&stack) == 0, - "wrong remaining available memory"); - } - - UCX_TEST_END -} - -UCX_TEST(test_ucx_stack_calloc) { - - test_ucx_stack_before; - - char zeros[99]; - memset(zeros, 0, 99); - memset(space, 32, 99); - ucx_stack_calloc(&stack, 4, sizeof(int)); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(!memcmp(space+sizeof(struct ucx_stack_metadata), - zeros, 4*sizeof(int)), "memory not nulled"); - UCX_TEST_ASSERT(!memcmp(space+sizeof(struct ucx_stack_metadata) - +4*sizeof(int), " ", 10), "too much memory nulled"); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_stack_free) { - - test_ucx_stack_before; - - void *fst = ucx_stack_malloc(&stack, 10); - void *snd = ucx_stack_malloc(&stack, 10); - void *thrd = ucx_stack_malloc(&stack, 10); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(stack.top == thrd, "wrong stack"); - UCX_TEST_ASSERT(((struct ucx_stack_metadata*) thrd - 1)->prev == snd, - "wrong thrd prev pointer before free"); - - ucx_stack_free(&stack, snd); - - UCX_TEST_ASSERT(((struct ucx_stack_metadata*) thrd - 1)->prev == fst, - "wrong thrd prev pointer after freeing snd"); - UCX_TEST_ASSERT(stack.top == thrd, "wrong top after freeing snd"); - - ucx_stack_free(&stack, thrd); - - UCX_TEST_ASSERT(stack.top == fst, "wrong top after freeing thrd"); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_stack_realloc) { - - test_ucx_stack_before; - - void *fst = ucx_stack_malloc(&stack, 14); - void *snd = ucx_stack_malloc(&stack, 10); - - UCX_TEST_BEGIN - - void *nfst = ucx_stack_realloc(&stack, fst, 16); - UCX_TEST_ASSERT(nfst == fst, "unnecessary move on reallocation"); - UCX_TEST_ASSERT(((struct ucx_stack_metadata*)fst - 1)->size == 16, - "wrong size after reallocation"); - - void *nsnd = ucx_stack_realloc(&stack, snd, 30); - UCX_TEST_ASSERT(nsnd == snd, "unnecessary move on top reallocation"); - UCX_TEST_ASSERT(ucx_stack_topsize(&stack) == 30, - "wrong size after top reallocation"); - - nsnd = ucx_stack_realloc(&stack, snd, 5); - UCX_TEST_ASSERT(nsnd == snd, "unnecessary move on top shrink"); - UCX_TEST_ASSERT(ucx_stack_topsize(&stack) == 5, - "wrong size after top shrink"); - UCX_TEST_ASSERT(ucx_stack_avail(&stack) == - 72-3*sizeof(struct ucx_stack_metadata), "wrong size after top shrink"); - - nfst = ucx_stack_realloc(&stack, fst, 24); - UCX_TEST_ASSERT(nfst != fst, "missing move on huge reallocation"); - UCX_TEST_ASSERT(stack.top == nfst, "wrong top after huge reallocation"); - UCX_TEST_ASSERT(ucx_stack_topsize(&stack) == 24, - "wrong size after huge reallocation"); - UCX_TEST_ASSERT(!((struct ucx_stack_metadata*)snd - 1)->prev, - "element not freed after huge reallocation"); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_stack_pop) { - - test_ucx_stack_before; - memset(space, 32, 99); - - void *fst = ucx_stack_malloc(&stack, 10); - void *snd = ucx_stack_malloc(&stack, 10); - ucx_stack_malloc(&stack, 10); - - char buf[16]; - - UCX_TEST_BEGIN - - memset(buf, '0', 16); - ucx_stack_pop(&stack, buf); - UCX_TEST_ASSERT(memcmp(buf, " 000000", 16) == 0, - "popped wrong content"); - UCX_TEST_ASSERT(stack.top == snd, "wrong top after pop"); - - memset(buf, '0', 16); - ucx_stack_popn(&stack, buf, 5); - UCX_TEST_ASSERT(memcmp(buf, " 00000000000", 16) == 0, - "n-popped wrong content"); - UCX_TEST_ASSERT(stack.top == fst, "wrong top after pop"); - - ucx_stack_pop(&stack, buf); - UCX_TEST_ASSERT(!stack.top, "top not NULL after last pop"); - - memset(buf, '0', 16); - ucx_stack_pop(&stack, buf); - UCX_TEST_ASSERT(memcmp(buf, "0000000000000000", 16) == 0, - "content not unchanged after empty pop"); - - UCX_TEST_END -} diff -r 92e482410453 -r d345541018fa test/stack_tests.h --- a/test/stack_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,51 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef STACK_TESTS_H -#define STACK_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_stack_init); -UCX_TEST(test_ucx_stack_malloc); -UCX_TEST(test_ucx_stack_calloc); -UCX_TEST(test_ucx_stack_free); -UCX_TEST(test_ucx_stack_realloc); -UCX_TEST(test_ucx_stack_pop); - -#ifdef __cplusplus -} -#endif - -#endif /* STACK_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/string_tests.c --- a/test/string_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,589 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "string_tests.h" - -UCX_TEST(test_sstr_macros) { - sstr_t hello = ST("Hello"); - sstr_t world = S("World"); - - char buf[20]; - snprintf(buf, sizeof(buf), "%" PRIsstr ", %" PRIsstr "!", SFMT(hello), SFMT(world)); - - UCX_TEST_BEGIN - const char* cmp = "Hello, World!"; - UCX_TEST_ASSERT(!strcmp(cmp, buf), "Something weird happened."); - UCX_TEST_END -} - -UCX_TEST(test_sstr) { - sstr_t s1 = sstr((char*)"1234"); - sstr_t s2 = sstrn((char*)"ab", 2); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(s1.length == 4, "s1 length must be 4"); - UCX_TEST_ASSERT(s2.length == 2, "s2 length must be 2"); - - UCX_TEST_END -} - -UCX_TEST(test_sstr_len) { - sstr_t s1 = ST("1234"); - sstr_t s2 = ST(".:.:."); - sstr_t s3 = ST("X"); - - size_t len1 = sstrnlen(1, s1); - size_t len2 = sstrnlen(2, s1, s2); - size_t len3 = sstrnlen(3, s1, s2, s3); - - UCX_TEST_BEGIN - - UCX_TEST_ASSERT(len1 == 4, "sstrnlen returned wrong size"); - UCX_TEST_ASSERT(len2 == 9, "sstrnlen returned wrong size"); - UCX_TEST_ASSERT(len3 == 10, "sstrnlen returned wrong size"); - - UCX_TEST_END -} - - -UCX_TEST(test_sstrchr_sstrrchr) { - sstr_t str = ST("I will find you - and I will kill you"); - UCX_TEST_BEGIN - - sstr_t notfound = sstrchr(str, 'x'); - UCX_TEST_ASSERT(notfound.length == 0, - "string length not 0 after forward search w/o result"); - - notfound = sstrrchr(str, 'x'); - UCX_TEST_ASSERT(notfound.length == 0, - "string length not 0 after reverse search w/o result"); - - sstr_t result = sstrchr(str, 'w'); - UCX_TEST_ASSERT(result.length == 35, "sstrchr returned wrong length"); - UCX_TEST_ASSERT(strcmp("will find you - and I will kill you", result.ptr) - == 0, "sstrchr did not return the expected string"); - - result = sstrrchr(str, 'w'); - UCX_TEST_ASSERT(result.length == 13, "sstrrchr returned wrong length"); - UCX_TEST_ASSERT(strcmp("will kill you", result.ptr) - == 0, "sstrrchr did not return the expected string"); - - UCX_TEST_END -} - -UCX_TEST(test_sstrstr) { - sstr_t str = ST("find the match in this string"); - sstr_t longstr = ST( - "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl" - "mnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx" - "yzabcdeababababnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghij" - "klmnopqrstuvwxyzaababababababababrstuvwxyzabcdefghijklmnopqrstuv" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "wxyz1234567890"); - sstr_t longstrpattern = ST( - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - ); - sstr_t longstrresult = ST( - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "abababababababababababababababababababababababababababababababab" - "wxyz1234567890" - ); - UCX_TEST_BEGIN - - sstr_t notfound = sstrstr(str, S("no match")); - UCX_TEST_ASSERT(notfound.length == 0, "no match must return empty string"); - - sstr_t result = sstrstr(str, S("match")); - UCX_TEST_ASSERT(result.length == 20, "sstrstr returned wrong length"); - UCX_TEST_ASSERT(!strcmp("match in this string", result.ptr), - "sstrstr did not return the expected string"); - - result = sstrstr(str, S("")); - UCX_TEST_ASSERT(result.length == str.length, - "sstrstr with empty match string returned wrong length"); - UCX_TEST_ASSERT(!strcmp(str.ptr, result.ptr), - "sstrstr with empty match string did not return the original string"); - - result = sstrstr(longstr, longstrpattern); - UCX_TEST_ASSERT(result.length == longstrresult.length, - "long string result length incorrect"); - UCX_TEST_ASSERT(!strcmp(result.ptr, longstrresult.ptr), - "long string result content incorrect"); - - UCX_TEST_END -} - -UCX_TEST(test_sstrcmp) { - sstr_t str = ST("compare this"); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(sstrcmp(str, S("")) == 1, "empty cmp failed"); - UCX_TEST_ASSERT(sstrcmp(S(""), S("")) == 0, "empty cmp false negative"); - UCX_TEST_ASSERT(sstrcmp(str, S("compare this")) == 0, "false negative"); - UCX_TEST_ASSERT(sstrcmp(str, S("Compare This")) != 0, "false positive"); - UCX_TEST_ASSERT(sstrcmp(str, S("compare tool")) < 0, "memcmp < 0 failed"); - UCX_TEST_ASSERT(sstrcmp(str, S("compare shit")) > 0, "memcmp > 0 failed"); - UCX_TEST_ASSERT(sstrcmp(str, S("compare this not")) < 0, "len < 0 failed"); - UCX_TEST_ASSERT(sstrcmp(str, S("compare")) > 0, "len > 0 failed"); - UCX_TEST_END -} - -UCX_TEST(test_sstrcasecmp) { - - sstr_t str = ST("compare this"); - - UCX_TEST_BEGIN - UCX_TEST_ASSERT(sstrcasecmp(str, S("")) == 1, "empty cmp failed"); - UCX_TEST_ASSERT(sstrcasecmp(S(""), S("")) == 0, "empty cmp false negative"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("compare this")) == 0, "false negative"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("Compare This")) == 0, - "not ignoring case"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("compare tool")) < 0, "< 0 failed"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("compare shit")) > 0, "> 0 failed"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("compare this not")) < 0, - "len < 0 failed"); - UCX_TEST_ASSERT(sstrcasecmp(str, S("compare")) > 0, "len > 0 failed"); - UCX_TEST_END -} - - -UCX_TEST(test_sstrcat) { - sstr_t s1 = S("12"); - sstr_t s2 = S("34"); - sstr_t s3 = S("56"); - sstr_t sn = { NULL, 0 }; - - UCX_TEST_BEGIN - - sstr_t t1 = sstrcat(2, s1, s2); - UCX_TEST_ASSERT(!sstrcmp(t1, S("1234")), "t1: wrong content"); - free(t1.ptr); - - sstr_t t2 = sstrcat(3, s1, s2, s3); - UCX_TEST_ASSERT(!sstrcmp(t2, S("123456")), "t2: wrong content"); - free(t2.ptr); - - sstr_t t3 = sstrcat(6, s1, sn, s2, sn, s3, sn); - UCX_TEST_ASSERT(!sstrcmp(t3, S("123456")), "t3: wrong content"); - free(t3.ptr); - - sstr_t t4 = sstrcat(2, sn, sn); - UCX_TEST_ASSERT(t4.ptr, "t4.ptr is NULL"); - UCX_TEST_ASSERT(t4.length == 0, "t4 has wrong length"); - free(t4.ptr); - - // overflow test - sstr_t o0; - o0.ptr = ""; - o0.length = ((size_t)-1) - 50; - sstr_t o1; - o1.ptr = ""; - o1.length = 100; - sstr_t o2; - o2.ptr = ""; - o2.length = 10; - - sstr_t n = sstrcat(2, o0, o1); - UCX_TEST_ASSERT(n.ptr == NULL && n.length == 0, "overflow not detected"); - sstr_t n2 = sstrcat(3, o0, o2, o1); - UCX_TEST_ASSERT(n2.ptr == NULL && n2.length == 0, "n2: overflow not detected"); - - UCX_TEST_END - -} - -UCX_TEST(test_sstrsplit) { - - const char *original = "this,is,a,csv,string"; - sstr_t test = ST("this,is,a,csv,string"); /* use copy of original here */ - ssize_t n; - sstr_t *list; - - UCX_TEST_BEGIN - - /* Nullpointer check */ - n = 0; - UCX_TEST_ASSERT(sstrsplit(test, S(""), &n) == NULL, - "empty delimiter must return NULL"); - - /* no delimiter occurence (ndo) */ - n = 0; - list = sstrsplit(test, S("z"), &n); - UCX_TEST_ASSERT(n == 1, "ndo, list length must be 1"); - UCX_TEST_ASSERT(strcmp(list[0].ptr, original) == 0, "ndo, " - "original string shall be returned as single list element"); - UCX_TEST_ASSERT(strcmp(test.ptr, original) == 0, - "ndo, original has been modified"); - for(int i=0;i -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_sstr_macros); -UCX_TEST(test_sstr); -UCX_TEST(test_sstr_len); -UCX_TEST(test_sstrcmp); -UCX_TEST(test_sstrcasecmp); -UCX_TEST(test_sstrcat); -UCX_TEST(test_sstrchr_sstrrchr); -UCX_TEST(test_sstrstr); -UCX_TEST(test_sstrsplit); -UCX_TEST(test_sstrtrim); -UCX_TEST(test_sstrprefixsuffix); -UCX_TEST(test_sstrcaseprefixsuffix); -UCX_TEST(test_sstrreplace); - -#ifdef __cplusplus -} -#endif - -#endif /* STRING_TESTS_H */ - diff -r 92e482410453 -r d345541018fa test/test_list.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/test_list.c Sat Feb 06 19:11:44 2021 +0100 @@ -0,0 +1,31 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +int main() { + return 0; +} diff -r 92e482410453 -r d345541018fa test/utils_tests.c --- a/test/utils_tests.c Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,187 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "utils_tests.h" -#include - -UCX_TEST(test_ucx_fprintf) { - UcxBuffer *b1 = ucx_buffer_new(NULL, 32, UCX_BUFFER_AUTOEXTEND); - UcxBuffer *b2 = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND); - - char *teststr1 = (char*)calloc(1, 1024); - char *teststr2 = (char*)calloc(1, 1024); - memset(teststr1, 'a', 1023); - memset(teststr2, 'b', 1023); - - UCX_TEST_BEGIN - - ucx_fprintf(b1, (write_func)ucx_buffer_write, "Hello %s", "World"); - UCX_TEST_ASSERT(!strcmp(b1->space, "Hello World"), "wrong content in b1"); - ucx_fprintf(b1, (write_func)ucx_buffer_write, "\nend.\n"); - UCX_TEST_ASSERT(!strcmp(b1->space, "Hello World\nend.\n"), - "wrong content in b1 after second fprintf"); - - ucx_bprintf(b2, "%s%s", teststr1, teststr2); - UCX_TEST_ASSERT(b2->pos == 2046, "wrong length"); - UCX_TEST_ASSERT(!memcmp(b2->space, teststr1, 1023), - "wrong first half in b2"); - UCX_TEST_ASSERT(!memcmp(b2->space+1023, teststr2, 1023), - "wrong second half in b2"); - - UCX_TEST_END - - ucx_buffer_free(b1); - ucx_buffer_free(b2); - free(teststr1); - free(teststr2); -} - -UCX_TEST(test_ucx_asprintf) { - char *teststr1 = (char*)calloc(1, 1024); - char *teststr2 = (char*)calloc(1, 1024); - memset(teststr1, 'a', 1023); - memset(teststr2, 'b', 1023); - UcxAllocator *a = ucx_default_allocator(); - - UCX_TEST_BEGIN - - sstr_t s1 = ucx_asprintf(a, "int: %d\nHello %s!", 123, "World"); - UCX_TEST_ASSERT(s1.ptr, "s1.ptr is NULL"); - UCX_TEST_ASSERT(s1.length == 21, "wrong length"); - UCX_TEST_ASSERT(!sstrcmp(s1, S("int: 123\nHello World!")), "wrong content"); - free(s1.ptr); - - sstr_t s2 = ucx_asprintf(a, "%s%s", teststr1, teststr2); - UCX_TEST_ASSERT(s2.ptr, "s2.ptr is NULL"); - UCX_TEST_ASSERT(s2.length == 2046, "wrong length"); - UCX_TEST_ASSERT(!memcmp(s2.ptr, teststr1, 1023), - "wrong first half in s2"); - UCX_TEST_ASSERT(!memcmp(s2.ptr+1023, teststr2, 1023), - "wrong second half in s2"); - free(s2.ptr); - - UCX_TEST_END - - free(teststr1); - free(teststr2); -} - -UCX_TEST(test_ucx_sprintf) { - UCX_TEST_BEGIN - - sstr_t s1 = ucx_sprintf("int: %d\nHello %s!", 123, "World"); - UCX_TEST_ASSERT(s1.ptr, "s1.ptr is NULL"); - UCX_TEST_ASSERT(s1.length == 21, "wrong length"); - UCX_TEST_ASSERT(!sstrcmp(s1, S("int: 123\nHello World!")), "wrong content"); - free(s1.ptr); - - sstr_t s2 = ucx_sprintf("Nothing to format!"); - UCX_TEST_ASSERT(s2.ptr, "s2.ptr is NULL"); - UCX_TEST_ASSERT(s2.length == 18, "wrong length"); - UCX_TEST_ASSERT(!memcmp(s2.ptr, "Nothing to format!", 18), - "wrong string without format arguments"); - free(s2.ptr); - - UCX_TEST_END -} - -UCX_TEST(test_ucx_bprintf) { - UcxBuffer *b = ucx_buffer_new(NULL, 64, UCX_BUFFER_DEFAULT); - - UCX_TEST_BEGIN - - ucx_bprintf(b, "int: %d\nHello %s!", 123, "World"); - UCX_TEST_ASSERT(b->size == 21, "wrong length"); - UCX_TEST_ASSERT(!memcmp(b->space, "int: 123\nHello World!", 21), - "wrong content"); - - ucx_buffer_clear(b); - - ucx_bprintf(b, "Nothing to format!"); - UCX_TEST_ASSERT(b->size == 18, "wrong length"); - UCX_TEST_ASSERT(!memcmp(b->space, "Nothing to format!", 18), - "wrong string without format arguments"); - - UCX_TEST_END - - ucx_buffer_free(b); -} - -UCX_TEST(test_ucx_stream_copy) { - UcxBuffer *b1 = ucx_buffer_new(NULL, 64, UCX_BUFFER_DEFAULT); - UcxBuffer *b2 = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND); - - UCX_TEST_BEGIN - - ucx_buffer_write("01234567", 1, 8, b1); - ucx_buffer_write("abcdefgh", 1, 8, b1); - UCX_TEST_ASSERT(b1->size == 16, "failed to fill buffer b1"); - ucx_buffer_seek(b1, 0, SEEK_SET); - - char copybuf[256]; - size_t ncp = ucx_stream_bcopy(b1, b2, ucx_buffer_read, ucx_buffer_write, - copybuf, sizeof(copybuf)); - UCX_TEST_ASSERT(ncp == 16, "wrong number of copied bytes"); - UCX_TEST_ASSERT(b2->size == 16, "b2 has wrong size"); - UCX_TEST_ASSERT(memcmp(b1->space, b2->space, 16) == 0, - "b1 and b2 have not the same content"); - - memset(b2->space, 0, b2->capacity); - b2->pos = 0; - b2->size = 0; - ucx_buffer_seek(b1, 0, SEEK_SET); - - FILE *file = tmpfile(); - UCX_TEST_ASSERT(file, "test file cannot be opened, test aborted"); - - ncp = ucx_stream_copy(b1, file, ucx_buffer_read, fwrite); - UCX_TEST_ASSERT(ncp == 16, "copied wrong number of bytes to file"); - - fseek(file, 0, SEEK_SET); - - ncp = ucx_stream_copy(file, b2, fread, ucx_buffer_write); - UCX_TEST_ASSERT(ncp == 16, "copied wrong number of bytes from file"); - - UCX_TEST_ASSERT(memcmp(b1->space, b2->space, 16) == 0, - "b1 and b2 content mismatch"); - - fclose(file); - - ucx_buffer_clear(b1); - ucx_buffer_seek(b2, 0, SEEK_SET); - ncp = ucx_stream_ncopy(b2, b1, ucx_buffer_read, ucx_buffer_write, 8); - UCX_TEST_ASSERT(ncp == 8, "copied wrong number of bytes with ncopy"); - UCX_TEST_ASSERT(memcmp(b1->space, "01234567\0\0\0\0\0\0\0\0", 16) == 0, - "content wrong after ncopy"); - - UCX_TEST_END - - ucx_buffer_free(b1); - ucx_buffer_free(b2); -} - diff -r 92e482410453 -r d345541018fa test/utils_tests.h --- a/test/utils_tests.h Mon Dec 30 09:54:10 2019 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. - * - * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef UTILS_TESTS_H -#define UTILS_TESTS_H - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -UCX_TEST(test_ucx_fprintf); -UCX_TEST(test_ucx_asprintf); -UCX_TEST(test_ucx_sprintf); -UCX_TEST(test_ucx_bprintf); -UCX_TEST(test_ucx_stream_copy); - -#ifdef __cplusplus -} -#endif - -#endif /* UTILS_TESTS_H */ -