libcmutils.h

Go to the documentation of this file.

/*
MIT License
 
Copyright (c) 2020 Dennis Soungjin Park<xcomart@gmail.com>
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 */
 
#ifndef LIBCMUTILS_H__
#define LIBCMUTILS_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(__CYGWIN__)     /* CYGWIN implements a UNIX API */
# undef WIN
# undef _WIN
# undef _WIN32
# undef _WIN64
# undef MSWIN
#endif
 
#if (defined(_WIN32) || defined(_WIN64)) && !defined(MSWIN)
# define MSWIN
#endif
 
#if defined(__APPLE__) && !defined(APPLE)
# define APPLE
#endif
 
#if defined(_MSC_VER)
# include <winsock2.h>
# include <windows.h>
#else
# include <sys/time.h>
# include <unistd.h>
# include <netinet/in.h>
#endif
#include <stdarg.h>
#include <stdint.h>
 
#define __STDC_FORMAT_MACROS 1 /* for 64bit integer-related macros */
#include <inttypes.h>
#include <sys/types.h>
 
#ifndef CMUTIL_API
# if defined(MSWIN)
#  if defined(CMUTIL_EXPORT)
#   define CMUTIL_API  __declspec(dllexport)
#  else
#   define CMUTIL_API  __declspec(dllimport)
#  endif
# else
#  define CMUTIL_API
# endif
#endif
 
#if !defined(MSWIN)
# if !defined(SOCKET)
#  define SOCKET            int
# endif
# if !defined(closesocket)
#  define closesocket       close
# endif
# if !defined(ioctlsocket)
#  define ioctlsocket       ioctl
# endif
# if !defined(SOCKET_ERROR)
#  define SOCKET_ERROR      -1
# endif
# if !defined(INVALID_SOCKET)
#  define INVALID_SOCKET    -1
# endif
#endif
 
/*
 * to remove a noisy warning in qtcreator
 */
#ifndef __null
# define __null (void*)0
#endif
 
/*
 * MSVC compatible definitions.
 */
#if defined(_MSC_VER)
# define strcasecmp     _stricmp
# define strncasecmp    _strnicmp
# define stat           _stat
# define pid_t          DWORD
# define usleep(x)      Sleep(x / 1000)
#endif
 
 
#if !defined(INT64_MAX)
# define INT64_MAX  i64(0x7FFFFFFFFFFFFFFF)
#endif
#if !defined(UINT64_MAX)
# define UINT64_MAX ui64(0xFFFFFFFFFFFFFFFF)
#endif
 
#define CMUTIL_APPEND(a,b)  a ## b
#if defined(_MSC_VER)
# define i64(x)     CMUTIL_APPEND(x, i64)
# define ui64(x)    CMUTIL_APPEND(x, ui64)
#else
# define i64(x)     CMUTIL_APPEND(x, LL)
# define ui64(x)    CMUTIL_APPEND(x, ULL)
#endif
 
#if defined(_MSC_VER)
# include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif
 
#if defined(_MSC_VER)
CMUTIL_API int __gettimeofday(struct timeval *tv, void *tz);
 
#define gettimeofday(tv, tz) __gettimeofday(tv, tz)
#endif
 
 
typedef enum CMBool {
    CMTrue         = 1,
    CMFalse        = 0
} CMBool;
 
#if defined(APPLE)
# define gethostbyname_r    CMUTIL_NetworkGetHostByNameR
# if !defined(CMUTIL_EXPORT)
#  define gethostbyname    CMUTIL_NetworkGetHostByName
CMUTIL_API struct hostent *CMUTIL_NetworkGetHostByName(const char *name);
# endif
CMUTIL_API int CMUTIL_NetworkGetHostByNameR(
        const char *name, struct hostent *ret, char *buf, size_t buflen,
         struct hostent **result, int *h_errnop);
#endif
 
#define CMUTIL_UNUSED(a,...) CMUTIL_UnusedP((void*)(int64_t)(a), ## __VA_ARGS__)
CMUTIL_API void CMUTIL_UnusedP(void *a, ...);
 
#if !defined(CMUTIL_CALL_NESTED)
# if defined(__STDC_VERSION__) && __STDC_VERSION__ > 201710L
   /* C23, and the C2x drafts that already carried __VA_OPT__ */
#  define CMUTIL_CALL_NESTED 1
# elif defined(__cplusplus) && __cplusplus >= 202002L
#  define CMUTIL_CALL_NESTED 1
# elif defined(_MSC_VER) && _MSC_VER >= 1929 && \
       defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL == 0
   /* the conforming preprocessor, /Zc:preprocessor */
#  define CMUTIL_CALL_NESTED 1
# else
#  define CMUTIL_CALL_NESTED 0
# endif
#endif
 
#if !defined(CMUTIL_CALL_SINGLE_EVAL)
# if defined(__GNUC__)
#  define CMUTIL_CALL_SINGLE_EVAL 1
# elif defined(__cplusplus) && (!defined(_MSC_VER) || \
       (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL == 0))
   /* MSVC only with /Zc:preprocessor - the traditional one mangles
    * __VA_ARGS__ on its way into the inner macro. */
#  define CMUTIL_CALL_SINGLE_EVAL 1
# else
#  define CMUTIL_CALL_SINGLE_EVAL 0
# endif
#endif
 
#if CMUTIL_CALL_SINGLE_EVAL && \
    !defined(__GNUC__) && !defined(__cplusplus)
# error "CMUTIL_CALL_SINGLE_EVAL needs a statement expression or a lambda"
#endif
 
#define CMUTIL_CAT2__(a,b)  a ## b
#define CMUTIL_CAT__(a,b)   CMUTIL_CAT2__(a,b)
 
#if CMUTIL_CALL_SINGLE_EVAL
# if defined(__GNUC__)
   /* statement expression: GCC and Clang, C and C++ alike */
#  if CMUTIL_CALL_NESTED
#   define CMUTIL_CALL_EXPR__(o,a,b,...) __extension__ ({                     \
        __typeof__(a) o = (a); o->b(o __VA_OPT__(,) __VA_ARGS__); })
#   define CMUTIL_CALL__(a,b,...) CMUTIL_CALL_EXPR__(                         \
        CMUTIL_CAT__(cmutil_self__,__COUNTER__), a, b __VA_OPT__(,) __VA_ARGS__)
#  else
#   define CMUTIL_CALL_EXPR__(o,a,b,...) __extension__ ({                     \
        __typeof__(a) o = (a); o->b(o, ## __VA_ARGS__); })
#   define CMUTIL_CALL__(a,b,...) CMUTIL_CALL_EXPR__(                         \
        CMUTIL_CAT__(cmutil_self__,__COUNTER__), a, b, ## __VA_ARGS__)
#  endif
# else
   /* immediately invoked lambda: any C++ compiler, MSVC included */
#  if CMUTIL_CALL_NESTED
#   define CMUTIL_CALL_EXPR__(o,a,b,...) ([&]{                                \
        auto o = (a); return o->b(o __VA_OPT__(,) __VA_ARGS__); }())
#   define CMUTIL_CALL__(a,b,...) CMUTIL_CALL_EXPR__(                         \
        CMUTIL_CAT__(cmutil_self__,__COUNTER__), a, b __VA_OPT__(,) __VA_ARGS__)
#  else
#   define CMUTIL_CALL_EXPR__(o,a,b,...) ([&]{                                \
        auto o = (a); return o->b(o, ## __VA_ARGS__); }())
#   define CMUTIL_CALL__(a,b,...) CMUTIL_CALL_EXPR__(                         \
        CMUTIL_CAT__(cmutil_self__,__COUNTER__), a, b, ## __VA_ARGS__)
#  endif
# endif
#else
   /* the receiver is named twice */
# if CMUTIL_CALL_NESTED
#  define CMUTIL_CALL__(a,b,...)  (a)->b((a) __VA_OPT__(,) __VA_ARGS__)
# else
#  define CMUTIL_CALL__(a,b,...)  (a)->b((a), ## __VA_ARGS__)
# endif
#endif
 
#define CMCall CMUTIL_CALL__
// for backward compatibility
#define CMUTIL_CALL CMUTIL_CALL__
 
CMUTIL_API const char *CMUTIL_GetLibVersion(void);
 
typedef int (*CMCompareCB)(const void*, const void*);
 
typedef void (*CMFreeCB)(void*);
 
typedef void (*CMProcCB)(void*);
 
typedef enum CMMemOper {
    CMMemSystem = 0,
    CMMemRecycle,
    CMMemDebug
} CMMemOper;
 
CMUTIL_API void CMUTIL_Init(CMMemOper memoper);
 
CMUTIL_API CMBool CMUTIL_Clear(void);
 
typedef struct CMUTIL_Mem {
    void *(*Alloc)(
            size_t size);
 
    void *(*Calloc)(
            size_t nmem,
            size_t size);
 
    void *(*Realloc)(
            void *ptr,
            size_t size);
 
    char *(*Strdup)(
            const char *str);
 
    void (*Free)(
            void *ptr);
} CMUTIL_Mem;
 
CMUTIL_API CMUTIL_Mem *CMUTIL_GetMem(void);
 
#define CMAlloc     CMUTIL_GetMem()->Alloc
 
#define CMCalloc    CMUTIL_GetMem()->Calloc
 
#define CMRealloc   CMUTIL_GetMem()->Realloc
 
#define CMStrdup    CMUTIL_GetMem()->Strdup
 
#define CMFree      CMUTIL_GetMem()->Free
 
typedef struct CMUTIL_Cond CMUTIL_Cond;
struct CMUTIL_Cond {
 
    void (*Wait)(
            CMUTIL_Cond *cond);
 
    CMBool (*TimedWait)(
            CMUTIL_Cond *cond,
            long millisec);
 
    void (*Set)(
            CMUTIL_Cond *cond);
 
    void (*Reset)(
            CMUTIL_Cond *cond);
 
    void (*Destroy)(
            CMUTIL_Cond *cond);
};
 
CMUTIL_API CMUTIL_Cond *CMUTIL_CondCreate(CMBool manual_reset);
 
typedef struct CMUTIL_Mutex CMUTIL_Mutex;
struct CMUTIL_Mutex {
 
    void (*Lock)(CMUTIL_Mutex *mutex);
 
    void (*Unlock)(CMUTIL_Mutex *mutex);
 
    CMBool (*TryLock)(CMUTIL_Mutex *mutex);
 
    void (*Destroy)(CMUTIL_Mutex *mutex);
};
 
CMUTIL_API CMUTIL_Mutex *CMUTIL_MutexCreate(void);
 
#define CMSync(a, ...) do {     \
    CMCall((a), Lock);          \
    __VA_ARGS__                 \
    CMCall((a), Unlock);        \
} while(0)
 
typedef struct CMUTIL_Thread CMUTIL_Thread;
struct CMUTIL_Thread {
 
    CMBool (*Start)(CMUTIL_Thread *thread);
 
    void *(*Join)(CMUTIL_Thread *thread);
 
    CMBool (*IsRunning)(const CMUTIL_Thread *thread);
 
    uint32_t (*GetId)(const CMUTIL_Thread *thread);
 
    const char *(*GetName)(const CMUTIL_Thread *thread);
};
 
CMUTIL_API CMUTIL_Thread *CMUTIL_ThreadCreate(
        void*(*proc)(void*), void *udata, const char *name);
 
CMUTIL_API uint32_t CMUTIL_ThreadSelfId(void);
 
CMUTIL_API CMUTIL_Thread *CMUTIL_ThreadSelf(void);
 
CMUTIL_API uint64_t CMUTIL_ThreadSystemSelfId(void);
 
typedef struct CMUTIL_ThreadPool CMUTIL_ThreadPool;
struct CMUTIL_ThreadPool {
 
    void (*Execute)(CMUTIL_ThreadPool *tp, CMProcCB runnable, void *udata);
 
    void (*Wait)(CMUTIL_ThreadPool *tp);
 
    void (*Destroy)(CMUTIL_ThreadPool *tp);
};
 
CMUTIL_API CMUTIL_ThreadPool *CMUTIL_ThreadPoolCreate(
        int pool_size, const char *name);
 
typedef struct CMUTIL_Semaphore CMUTIL_Semaphore;
struct CMUTIL_Semaphore {
 
    CMBool (*Acquire)(
            CMUTIL_Semaphore *semaphore, long millisec);
 
    void (*Release)(
            CMUTIL_Semaphore *semaphore);
 
    void (*Destroy)(CMUTIL_Semaphore *semaphore);
};
 
CMUTIL_API CMUTIL_Semaphore *CMUTIL_SemaphoreCreate(int initcnt);
 
 
typedef struct CMUTIL_RWLock CMUTIL_RWLock;
struct CMUTIL_RWLock {
 
    void (*ReadLock)(
            CMUTIL_RWLock *rwlock);
 
    void (*ReadUnlock)(
            CMUTIL_RWLock *rwlock);
 
    void (*WriteLock)(
            CMUTIL_RWLock *rwlock);
 
    void (*WriteUnlock)(
            CMUTIL_RWLock *rwlock);
 
    void (*Destroy)(CMUTIL_RWLock *rwlock);
};
 
CMUTIL_API CMUTIL_RWLock *CMUTIL_RWLockCreate(void);
 
typedef struct CMUTIL_Iterator CMUTIL_Iterator;
struct CMUTIL_Iterator {
 
    CMBool (*HasNext)(
            const CMUTIL_Iterator *iter);
 
    void *(*Next)(
            CMUTIL_Iterator *iter);
 
    void (*Destroy)(
            CMUTIL_Iterator *iter);
};
 
 
typedef struct CMUTIL_Array CMUTIL_Array;
struct CMUTIL_Array {
 
    CMBool (*Add)(CMUTIL_Array *array, void *item, void **ret);
 
    void *(*Remove)(CMUTIL_Array *array, const void *compval);
 
    void *(*InsertAt)(CMUTIL_Array *array, void *item, uint32_t index);
 
    void *(*RemoveAt)(CMUTIL_Array *array, uint32_t index);
 
    void *(*SetAt)(CMUTIL_Array *array, void *item, uint32_t index);
 
    void *(*GetAt)(const CMUTIL_Array *array, uint32_t index);
 
    void *(*Find)(const CMUTIL_Array *array, const void *compval, uint32_t *index);
 
    size_t  (*GetSize)(const CMUTIL_Array *array);
 
    CMBool (*Push)(CMUTIL_Array *array, void *item);
 
    void *(*Pop)(CMUTIL_Array *array);
 
    void *(*Top)(const CMUTIL_Array *array);
 
    void *(*Bottom)(const CMUTIL_Array *array);
 
    CMUTIL_Iterator *(*Iterator)(const CMUTIL_Array *array);
 
    void (*Clear)(CMUTIL_Array *array);
 
    void (*Destroy)(CMUTIL_Array *array);
};
 
#define CMUTIL_ARRAY_DEFAULT    10
 
#define CMUTIL_ArrayCreate()    \
        CMUTIL_ArrayCreateEx(CMUTIL_ARRAY_DEFAULT, NULL, NULL)
 
CMUTIL_API CMUTIL_Array *CMUTIL_ArrayCreateEx(
        size_t initcapacity,
        CMCompareCB comparator,
        CMFreeCB freecb);
 
typedef struct CMUTIL_String CMUTIL_String;
struct CMUTIL_String {
    ssize_t (*AddString)(
            CMUTIL_String *string, const char *tobeadded);
 
    ssize_t (*AddNString)(
            CMUTIL_String *string, const char *tobeadded, size_t size);
 
    ssize_t (*AddChar)(
            CMUTIL_String *string, char tobeadded);
 
    ssize_t (*AddPrint)(
            CMUTIL_String *string, const char *fmt, ...);
 
    ssize_t (*AddVPrint)(
            CMUTIL_String *string, const char *fmt, va_list args);
 
    ssize_t (*AddAnother)(
            CMUTIL_String *string, const CMUTIL_String *tobeadded);
 
    ssize_t (*InsertString)(
            CMUTIL_String *string, const char *tobeadded, uint32_t at);
 
    ssize_t (*InsertNString)(
            CMUTIL_String *string,
            const char *tobeadded, uint32_t at, size_t size);
 
    ssize_t (*InsertPrint)(
            CMUTIL_String *string, uint32_t idx, const char *fmt, ...);
 
    ssize_t (*InsertVPrint)(
            CMUTIL_String *string, uint32_t idx,
            const char *fmt, va_list args);
 
    ssize_t (*InsertAnother)(
            CMUTIL_String *string, uint32_t idx, CMUTIL_String *tobeadded);
 
    void (*CutTailOff)(
            CMUTIL_String *string, size_t length);
 
    CMUTIL_String *(*Substring)(
            const CMUTIL_String *string, uint32_t offset, size_t length);
 
    CMUTIL_String *(*ToLower)(
            const CMUTIL_String *string);
 
    void (*SelfToLower)(
            CMUTIL_String *string);
 
    CMUTIL_String *(*ToUpper)(
            const CMUTIL_String *string);
 
    void (*SelfToUpper)(
            CMUTIL_String *string);
 
    CMUTIL_String *(*Replace)(
            const CMUTIL_String *string,
            const char *needle, const char *alter);
 
    size_t (*GetSize)(
            const CMUTIL_String *string);
 
    const char *(*GetCString)(
            const CMUTIL_String *string);
 
    int (*GetChar)(
            const CMUTIL_String *string, uint32_t idx);
 
    void (*Clear)(
            CMUTIL_String *string);
 
    CMUTIL_String *(*Clone)(
            const CMUTIL_String *string);
 
    void (*Destroy)(
            CMUTIL_String *string);
 
    void (*SelfTrim)(CMUTIL_String *string);
};
 
#define CMUTIL_STRING_DEFAULT   32
 
#define CMUTIL_StringCreate()   \
        CMUTIL_StringCreateEx(CMUTIL_STRING_DEFAULT, NULL)
 
CMUTIL_API CMUTIL_String *CMUTIL_StringCreateEx(
        size_t initcapacity,
        const char *initcontent);
 
 
typedef struct CMUTIL_StringArray CMUTIL_StringArray;
struct CMUTIL_StringArray {
    void (*Add)(
            CMUTIL_StringArray *array, CMUTIL_String *string);
 
    void (*AddCString)(
            CMUTIL_StringArray *array, const char *string);
 
    CMBool (*InsertAt)(
            CMUTIL_StringArray *array, CMUTIL_String *string, uint32_t index);
 
    CMBool (*InsertAtCString)(
            CMUTIL_StringArray *array, const char *string, uint32_t index);
 
    CMUTIL_String *(*RemoveAt)(
            CMUTIL_StringArray *array, uint32_t index);
 
    CMUTIL_String *(*SetAt)(
            CMUTIL_StringArray *array, CMUTIL_String *string, uint32_t index);
 
    CMUTIL_String *(*SetAtCString)(
            CMUTIL_StringArray *array, const char *string, uint32_t index);
 
    const CMUTIL_String *(*GetAt)(
            const CMUTIL_StringArray *array, uint32_t index);
 
    const char *(*GetCString)(
            const CMUTIL_StringArray *array, uint32_t index);
 
    size_t (*GetSize)(
            const CMUTIL_StringArray *array);
 
    CMUTIL_Iterator *(*Iterator)(
            const CMUTIL_StringArray *array);
 
    void (*Destroy)(
            CMUTIL_StringArray *array);
 
    void (*PrintTo)(
            const CMUTIL_StringArray *array,
            CMUTIL_String *out);
};
 
#define CMUTIL_STRINGARRAY_DEFAULT  32
 
#define CMUTIL_StringArrayCreate()  \
        CMUTIL_StringArrayCreateEx(CMUTIL_STRINGARRAY_DEFAULT)
 
CMUTIL_API CMUTIL_StringArray *CMUTIL_StringArrayCreateEx(
        size_t initcapacity);
 
 
#define CMUTIL_StringArrayCreateWith(s, ...) \
        CMUTIL_StringArrayCreateWithEx(s, __VA_ARGS__, NULL)
 
CMUTIL_API CMUTIL_StringArray *CMUTIL_StringArrayCreateWithEx(
        const char *str, ...);
 
CMUTIL_API char *CMUTIL_StrRTrim(char *inp);
 
CMUTIL_API char *CMUTIL_StrLTrim(char *inp);
 
CMUTIL_API char *CMUTIL_StrTrim(char *inp);
 
CMUTIL_API const char *CMUTIL_StrNextToken(
    char *dest, size_t buflen, const char *src, const char *delims);
 
CMUTIL_API const char *CMUTIL_StrSkipSpaces(
        const char *src, const char *spaces);
 
CMUTIL_API CMUTIL_StringArray *CMUTIL_StringSplit(
    const char *haystack, const char *needle);
 
CMUTIL_API int CMUTIL_StringHexToBytes(uint8_t *dest, const char *src, int len);
 
 
typedef struct CMUTIL_ByteBuffer CMUTIL_ByteBuffer;
struct CMUTIL_ByteBuffer {
 
    CMUTIL_ByteBuffer *(*AddByte)(
            CMUTIL_ByteBuffer *buffer,
            uint8_t b);
 
    CMUTIL_ByteBuffer *(*AddBytes)(
            CMUTIL_ByteBuffer *buffer,
            const uint8_t *bytes,
            uint32_t length);
 
    CMUTIL_ByteBuffer *(*AddBytesPart)(
            CMUTIL_ByteBuffer *buffer,
            const uint8_t *bytes,
            uint32_t offset,
            uint32_t length);
 
    CMUTIL_ByteBuffer *(*InsertByteAt)(
            CMUTIL_ByteBuffer *buffer,
            uint32_t index,
            uint8_t b);
 
    CMUTIL_ByteBuffer *(*InsertBytesAt)(
            CMUTIL_ByteBuffer *buffer,
            uint32_t index,
            const uint8_t *bytes,
            uint32_t length);
 
    int (*GetAt)(
            const CMUTIL_ByteBuffer *buffer,
            uint32_t index);
 
    size_t (*GetSize)(
            const CMUTIL_ByteBuffer *buffer);
 
    uint8_t *(*GetBytes)(
            CMUTIL_ByteBuffer *buffer);
 
    CMBool (*ShrinkTo)(
            CMUTIL_ByteBuffer *buffer,
            size_t size);
 
    size_t (*GetCapacity)(
            const CMUTIL_ByteBuffer *buffer);
 
    void (*Destroy)(
            CMUTIL_ByteBuffer *buffer);
 
    void (*Clear)(
            CMUTIL_ByteBuffer *buffer);
};
 
#define CMUTIL_BYTEBUFFER_DEFAULT   32
 
#define CMUTIL_ByteBufferCreate()   \
        CMUTIL_ByteBufferCreateEx(CMUTIL_BYTEBUFFER_DEFAULT)
 
CMUTIL_API CMUTIL_ByteBuffer *CMUTIL_ByteBufferCreateEx(
        size_t initcapacity);
 
typedef struct CMUTIL_MapPair CMUTIL_MapPair;
struct CMUTIL_MapPair {
    const char *(*GetKey)(const CMUTIL_MapPair *pair);
 
    void *(*GetValue)(const CMUTIL_MapPair *pair);
};
 
 
typedef struct CMUTIL_Map CMUTIL_Map;
struct CMUTIL_Map {
    CMBool (*Put)(
            CMUTIL_Map *map, const char* key, void* value, void** prev);
 
    void (*PutAll)(
            CMUTIL_Map *map, const CMUTIL_Map *src);
 
    void *(*Get)(
            const CMUTIL_Map *map, const char* key);
 
    void *(*Remove)(
            CMUTIL_Map *map, const char* key);
 
    CMUTIL_StringArray *(*GetKeys)(
            const CMUTIL_Map *map);
 
    const CMUTIL_Array *(*GetPairs)(
            const CMUTIL_Map *map);
 
    size_t (*GetSize)(
            const CMUTIL_Map *map);
 
    CMUTIL_Iterator *(*Iterator)(
            const CMUTIL_Map *map);
 
    void (*Clear)(
            CMUTIL_Map *map);
 
    void (*ClearLink)(
            CMUTIL_Map *map);
 
    void (*Destroy)(
            CMUTIL_Map *map);
 
    void (*PrintTo)(
            const CMUTIL_Map *map, CMUTIL_String *out, const char*(*to_strcb)(void*));
 
    void *(*GetAt)(
            const CMUTIL_Map *map, uint32_t index);
 
    void *(*RemoveAt)(
            CMUTIL_Map *map, uint32_t index);
};
 
#define CMUTIL_MAP_DEFAULT  256
 
#define CMUTIL_MapCreate()  CMUTIL_MapCreateEx(\
        CMUTIL_MAP_DEFAULT, CMFalse, NULL, 0.75f)
 
CMUTIL_API CMUTIL_Map *CMUTIL_MapCreateEx(
        uint32_t bucketsize, CMBool isucase, CMFreeCB freecb,
        float load_factor);
 
 
typedef struct CMUTIL_List CMUTIL_List;
struct CMUTIL_List {
 
    void (*AddFront)(CMUTIL_List *list, void *data);
 
    void (*AddTail)(CMUTIL_List *list, void *data);
 
    void *(*GetFront)(const CMUTIL_List *list);
 
    void *(*GetTail)(const CMUTIL_List *list);
 
    void *(*RemoveFront)(CMUTIL_List *list);
 
    void *(*RemoveTail)(CMUTIL_List *list);
 
    void *(*Remove)(CMUTIL_List *list, void *data);
 
    size_t (*GetSize)(const CMUTIL_List *list);
 
    CMUTIL_Iterator *(*Iterator)(const CMUTIL_List *list);
 
    void (*Destroy)(CMUTIL_List *list);
 
    void (*MoveAll)(CMUTIL_List *dst, CMUTIL_List *src);
};
 
#define CMUTIL_ListCreate() CMUTIL_ListCreateEx(NULL)
 
CMUTIL_API CMUTIL_List *CMUTIL_ListCreateEx(CMFreeCB freecb);
 
typedef enum CMXmlNodeKind {
    CMXmlNodeUnknown = 0,
    CMXmlNodeText,
    CMXmlNodeTag
} CMXmlNodeKind;
 
 
typedef struct CMUTIL_XmlNode CMUTIL_XmlNode;
struct CMUTIL_XmlNode {
    CMUTIL_StringArray *(*GetAttributeNames)(const CMUTIL_XmlNode *node);
 
    CMUTIL_String *(*GetAttribute)(
            const CMUTIL_XmlNode *node, const char *key);
 
    void (*SetAttribute)(
            CMUTIL_XmlNode *node, const char *key, const char *value);
 
    size_t (*ChildCount)(const CMUTIL_XmlNode *node);
 
    void (*AddChild)(CMUTIL_XmlNode *node, CMUTIL_XmlNode *child);
 
    CMUTIL_XmlNode *(*ChildAt)(const CMUTIL_XmlNode *node, uint32_t index);
 
    CMUTIL_XmlNode *(*GetParent)(const CMUTIL_XmlNode *node);
 
    const char *(*GetName)(const CMUTIL_XmlNode *node);
 
    void (*SetName)(CMUTIL_XmlNode *node, const char *name);
 
    CMXmlNodeKind (*GetType)(const CMUTIL_XmlNode *node);
 
    CMUTIL_String *(*ToDocument)(
            const CMUTIL_XmlNode *node, CMBool beutify);
 
    void (*SetUserData)(
            CMUTIL_XmlNode *node, void *udata, void(*freef)(void*));
 
    void *(*GetUserData)(const CMUTIL_XmlNode *node);
 
    void (*Destroy)(CMUTIL_XmlNode *node);
};
 
CMUTIL_API CMUTIL_XmlNode *CMUTIL_XmlParse(CMUTIL_String *str);
 
CMUTIL_API CMUTIL_XmlNode *CMUTIL_XmlParseString(
        const char *xmlstr, size_t len);
 
CMUTIL_API CMUTIL_XmlNode *CMUTIL_XmlParseFile(const char *fpath);
 
CMUTIL_API CMUTIL_XmlNode *CMUTIL_XmlNodeCreate(
        CMXmlNodeKind type, const char *tagname);
 
CMUTIL_API CMUTIL_XmlNode *CMUTIL_XmlNodeCreateWithLen(
        CMXmlNodeKind type, const char *tagname, size_t len);
 
typedef struct CMUTIL_CSConv CMUTIL_CSConv;
struct CMUTIL_CSConv {
    CMUTIL_String *(*Forward)(
            const CMUTIL_CSConv *conv, CMUTIL_String *instr);
 
    CMUTIL_String *(*Backward)(
            const CMUTIL_CSConv *conv, CMUTIL_String *instr);
 
    void (*Destroy)(CMUTIL_CSConv *conv);
};
 
CMUTIL_API CMUTIL_CSConv *CMUTIL_CSConvCreate(
        const char *fromcs, const char *tocs);
 
typedef struct CMUTIL_TimerTask CMUTIL_TimerTask;
struct CMUTIL_TimerTask {
    void (*Cancel)(CMUTIL_TimerTask *task);
};
 
typedef struct CMUTIL_Timer CMUTIL_Timer;
struct CMUTIL_Timer {
    CMUTIL_TimerTask *(*ScheduleAtTime)(
            CMUTIL_Timer *timer, struct timeval *attime,
            CMProcCB proc, void *param);
 
    CMUTIL_TimerTask *(*ScheduleDelay)(
            CMUTIL_Timer *timer, long delay,
            CMProcCB proc, void *param);
 
    CMUTIL_TimerTask *(*ScheduleAtRepeat)(
            CMUTIL_Timer *timer, struct timeval *first, long period,
            CMBool elapse_skip, CMProcCB proc, void *param);
 
    CMUTIL_TimerTask *(*ScheduleDelayRepeat)(
            CMUTIL_Timer *timer, long delay, long period,
            CMBool elapse_skip, CMProcCB proc, void *param);
 
    void (*Purge)(CMUTIL_Timer *timer);
 
    void (*Destroy)(CMUTIL_Timer *timer);
};
 
#define CMUTIL_TIMER_PRECISION  1
 
#define CMUTIL_TIMER_THREAD     2
 
#define CMUTIL_TimerCreate()    \
        CMUTIL_TimerCreateEx(CMUTIL_TIMER_PRECISION, CMUTIL_TIMER_THREAD)
 
CMUTIL_API CMUTIL_Timer *CMUTIL_TimerCreateEx(long precision, int threads);
 
typedef struct CMUTIL_Pool CMUTIL_Pool;
struct CMUTIL_Pool {
    void *(*CheckOut)(CMUTIL_Pool *pool, long millisec);
 
    void (*Release)(CMUTIL_Pool *pool, void *resource);
 
    void (*AddResource)(CMUTIL_Pool *pool, void *resource);
 
    void (*Destroy)(CMUTIL_Pool *pool);
};
 
typedef void* (*CMPoolItemCreateCB)(void *udata);
 
typedef void (*CMPoolItemFreeCB)(void *resource, void *udata);
 
typedef CMBool (*CMPoolItemTestCB)(void *resource, void *udata);
 
CMUTIL_API CMUTIL_Pool *CMUTIL_PoolCreate(
        int initcnt,
        int maxcnt,
        CMPoolItemCreateCB createproc,
        CMPoolItemFreeCB destroyproc,
        CMPoolItemTestCB testproc,
        long pinginterval,
        CMBool testonborrow,
        void *udata,
        CMUTIL_Timer *timer);
 
typedef struct CMUTIL_Library CMUTIL_Library;
struct CMUTIL_Library {
 
    void *(*GetProcedure)(
            const CMUTIL_Library *lib,
            const char *proc_name);
 
    void (*Destroy)(
            CMUTIL_Library *lib);
};
 
CMUTIL_API CMUTIL_Library *CMUTIL_LibraryCreate(const char *path);
 
typedef struct CMUTIL_FileList CMUTIL_FileList;
 
typedef struct CMUTIL_File CMUTIL_File;
struct CMUTIL_FileList {
    size_t (*Count)(
            const CMUTIL_FileList *flist);
 
    CMUTIL_File *(*GetAt)(
            const CMUTIL_FileList *flist,
            uint32_t index);
 
    void (*Destroy)(
            CMUTIL_FileList *flist);
};
 
typedef enum CMFileOpenMode {
    CMFileOpenRead = 0,
    CMFileOpenWrite,
    CMFileOpenAppend
} CMFileOpenMode;
 
typedef struct CMUTIL_FileStream CMUTIL_FileStream;
struct CMUTIL_FileStream {
        ssize_t (*Read)(
                const CMUTIL_FileStream *fs,
                CMUTIL_String *buffer,
                size_t size);
 
        ssize_t (*Write)(
                const CMUTIL_FileStream *fs,
                const CMUTIL_String *buffer,
                size_t offset,
                size_t size);
 
        void (*Close)(
                CMUTIL_FileStream *fs);
};
 
struct CMUTIL_File {
    CMUTIL_String *(*GetContents)(
            const CMUTIL_File *file);
 
    CMBool (*Delete)(
            const CMUTIL_File *file);
 
    CMBool (*IsFile)(
            const CMUTIL_File *file);
 
    CMBool (*IsDirectory)(
            const CMUTIL_File *file);
 
    CMBool (*IsExists)(
            const CMUTIL_File *file);
 
    long (*Length)(
            const CMUTIL_File *file);
 
    const char *(*GetName)(
            const CMUTIL_File *file);
 
    const char *(*GetFullPath)(
            const CMUTIL_File *file);
 
    time_t (*ModifiedTime)(
            const CMUTIL_File *file);
 
    CMUTIL_FileList *(*Children)(
            const CMUTIL_File *file);
 
    CMUTIL_FileList *(*Find)(
            const CMUTIL_File *file,
            const char *pattern, CMBool recursive);
 
    CMUTIL_FileStream *(*CreateStream)(
            const CMUTIL_File *file,
            CMFileOpenMode mode);
 
    void (*Destroy)(
            CMUTIL_File *file);
};
 
CMUTIL_API CMUTIL_File *CMUTIL_FileCreate(const char *path);
 
CMUTIL_API CMBool CMUTIL_PathCreate(const char *path, uint32_t mode);
 
typedef struct CMUTIL_Config CMUTIL_Config;
struct CMUTIL_Config {
    void (*Save)(const CMUTIL_Config *conf, const char *path);
 
    const char *(*Get)(const CMUTIL_Config *conf, const char *key);
 
    void (*Set)(CMUTIL_Config *conf, const char *key, const char *value);
 
    long (*GetLong)(const CMUTIL_Config *conf, const char *key);
 
    void (*SetLong)(CMUTIL_Config *conf, const char *key, long value);
 
    double (*GetDouble)(const CMUTIL_Config *conf, const char *key);
 
    void (*SetDouble)(CMUTIL_Config *conf, const char *key, double value);
 
    CMBool (*GetBoolean)(const CMUTIL_Config *conf, const char *key);
 
    void (*SetBoolean)(CMUTIL_Config *conf, const char *key, CMBool value);
 
    void(*Destroy)(CMUTIL_Config *conf);
};
 
CMUTIL_API CMUTIL_Config *CMUTIL_ConfigCreate(void);
 
CMUTIL_API CMUTIL_Config *CMUTIL_ConfigLoad(const char *fconf);
 
#define CMUTIL_LOG_CONFIG_DEFAULT       "cmutil_log.jsonc"
 
typedef enum CMLogLevel {
    CMLogLevel_Trace = 0,
    CMLogLevel_Debug,
    CMLogLevel_Info,
    CMLogLevel_Warn,
    CMLogLevel_Error,
    CMLogLevel_Fatal
} CMLogLevel;
 
typedef enum CMLogTerm {
    CMLogTerm_Year = 0,
    CMLogTerm_Month,
    CMLogTerm_Date,
    CMLogTerm_Hour,
    CMLogTerm_Minute
} CMLogTerm;
 
typedef struct CMUTIL_LogAppender CMUTIL_LogAppender;
 
typedef struct CMUTIL_ConfLogger CMUTIL_ConfLogger;
struct CMUTIL_ConfLogger {
 
    void(*AddAppender)(
        const CMUTIL_ConfLogger *logger,
        CMUTIL_LogAppender *appender,
        CMLogLevel level);
};
 
typedef struct CMUTIL_Logger CMUTIL_Logger;
struct CMUTIL_Logger {
    void(*LogEx)(
        CMUTIL_Logger *logger,
        CMLogLevel level,
        const char *file,
        int line,
        CMBool printStack,
        const char *fmt,
        ...);
 
    CMBool(*IsEnabled)(
            CMUTIL_Logger *logger,
            CMLogLevel level);
};
 
struct CMUTIL_LogAppender {
    const char *(*GetName)(
            const CMUTIL_LogAppender *appender);
 
    void(*SetAsync)(
            CMUTIL_LogAppender *appender, size_t buffersz);
 
    void(*Append)(
        CMUTIL_LogAppender *appender,
        CMUTIL_Logger *logger,
        CMLogLevel level,
        CMUTIL_StringArray *stack,
        const char *file,
        int line,
        CMUTIL_String *logmsg);
 
    void(*Flush)(CMUTIL_LogAppender *appender);
 
    void(*Destroy)(CMUTIL_LogAppender *appender);
};
 
CMUTIL_API CMUTIL_LogAppender *CMUTIL_LogConsoleAppenderCreate(
    const char *name,
    const char *pattern,
    CMBool use_stderr);
 
CMUTIL_API CMUTIL_LogAppender *CMUTIL_LogFileAppenderCreate(
    const char *name,
    const char *fpath,
    const char *pattern);
 
CMUTIL_API CMUTIL_LogAppender *CMUTIL_LogRollingFileAppenderCreate(
    const char *name,
    const char *fpath,
    CMLogTerm logterm,
    const char *rollpath,
    const char *pattern);
 
CMUTIL_API CMUTIL_LogAppender *CMUTIL_LogSocketAppenderCreate(
    const char *name,
    const char *accept_host,
    int listen_port,
    const char *pattern);
 
CMUTIL_API void CMUTIL_LogFallback(CMLogLevel level,
        const char *file, int line, const char *fmt, ...);
 
#define CMUTIL_LogDefine(name)                                           \
    static CMUTIL_Logger *l___logger = NULL;                             \
    static CMUTIL_LogSystem *s__lsys = NULL;                             \
    static CMUTIL_Logger *g__CMUTIL_GetLogger() {                        \
        if (l___logger == NULL || s__lsys != CMUTIL_LogSystemGet()) {    \
            s__lsys = CMUTIL_LogSystemGet();                             \
            if (s__lsys) l___logger = CMCall(s__lsys, GetLogger, name);  \
            else l___logger = NULL;                                      \
        }                                                                \
        return l___logger;                                               \
    }
 
CMUTIL_API CMBool CMUTIL_LogIsEnabled(
        CMUTIL_Logger *logger, CMLogLevel level);
 
#define CMLogIsEnabled(level) CMUTIL_LogIsEnabled(g__CMUTIL_GetLogger(),level)
 
#define CMUTIL_Log__(level,stack,f,...) do {                              \
    CMUTIL_Logger *g__logger = g__CMUTIL_GetLogger();                     \
    if (g__logger)                                                        \
        g__logger->LogEx(g__logger, CMLogLevel_##level,__FILE__,__LINE__, \
                      CM##stack,f,##__VA_ARGS__);                         \
    else                                                                  \
        CMUTIL_LogFallback(CMLogLevel_##level, __FILE__, __LINE__,        \
                           f, ##__VA_ARGS__);                             \
    } while(0)
 
#define CMUTIL_Log2__(level,stack,f,...)    do {                        \
    CMUTIL_Logger *g__logger = g__CMUTIL_GetLogger();                   \
    if (g__logger)                                                      \
        g__logger->LogEx(g__logger, level,__FILE__,__LINE__,            \
                      CM##stack,f,##__VA_ARGS__);                       \
    else                                                                \
        CMUTIL_LogFallback(level, __FILE__, __LINE__,                   \
                           f, ##__VA_ARGS__);                           \
    } while(0)
 
#define CMLogTrace(f,...)   CMUTIL_Log__(Trace,False,f,##__VA_ARGS__)
 
#define CMLogTraceS(f,...)  CMUTIL_Log__(Trace,True ,f,##__VA_ARGS__)
 
#define CMLogDebug(f,...)   CMUTIL_Log__(Debug,False,f,##__VA_ARGS__)
 
#define CMLogDebugS(f,...)  CMUTIL_Log__(Debug,True ,f,##__VA_ARGS__)
 
#define CMLogInfo(f,...)    CMUTIL_Log__(Info ,False,f,##__VA_ARGS__)
 
#define CMLogInfoS(f,...)   CMUTIL_Log__(Info ,True ,f,##__VA_ARGS__)
 
#define CMLogWarn(f,...)    CMUTIL_Log__(Warn ,False,f,##__VA_ARGS__)
 
#define CMLogWarnS(f,...)   CMUTIL_Log__(Warn ,True ,f,##__VA_ARGS__)
 
#define CMLogError(f,...)   CMUTIL_Log__(Error,False,f,##__VA_ARGS__)
 
#define CMLogErrorS(f,...)  CMUTIL_Log__(Error,True ,f,##__VA_ARGS__)
 
#define CMLogFatal(f,...)   CMUTIL_Log__(Fatal,False,f,##__VA_ARGS__)
 
#define CMLogFatalS(f,...)  CMUTIL_Log__(Fatal,True ,f,##__VA_ARGS__)
 
#define CMLog(l,f,...)      CMUTIL_Log2__(l,False,f,##__VA_ARGS__)
 
#define CMLogS(l,f,...)     CMUTIL_Log2__(l,True ,f,##__VA_ARGS__)
 
typedef struct CMUTIL_LogSystem CMUTIL_LogSystem;
struct CMUTIL_LogSystem {
 
    void(*AddAppender)(
            const CMUTIL_LogSystem *logsys, CMUTIL_LogAppender *appender);
    CMUTIL_ConfLogger *(*CreateLogger)(
        const CMUTIL_LogSystem *logsys,
        const char *name,
        CMLogLevel level,
        CMBool additivity);
 
    CMUTIL_Logger *(*GetLogger)(
            const CMUTIL_LogSystem *logsys, const char *name);
 
    void(*Destroy)(CMUTIL_LogSystem *logsys);
 
    CMBool (*UpdateEnv)(CMUTIL_LogSystem *logsys);
};
 
CMUTIL_API CMUTIL_LogSystem *CMUTIL_LogSystemCreate(void);
 
CMUTIL_API CMUTIL_LogSystem *CMUTIL_LogSystemConfigureFomJson(
        const char *jsonfile);
 
CMUTIL_API CMUTIL_LogSystem *CMUTIL_LogSystemGet(void);
 
CMUTIL_API void CMUTIL_LogSystemSet(CMUTIL_LogSystem *lsys);
 
typedef struct CMUTIL_StackWalker CMUTIL_StackWalker;
struct CMUTIL_StackWalker {
 
    CMUTIL_StringArray *(*GetStack)(
            const CMUTIL_StackWalker *walker, int skipdepth);
 
    void(*PrintStack)(
            const CMUTIL_StackWalker *walker,
            CMUTIL_String *outbuf, int skipdepth);
 
    void(*Destroy)(CMUTIL_StackWalker *walker);
};
 
CMUTIL_API CMUTIL_StackWalker *CMUTIL_StackWalkerCreate(void);
 
typedef enum CMSocketResult {
    CMSocketOk = 0,
    CMSocketTimeout,
    CMSocketPollFailed,
    CMSocketReceiveFailed,
    CMSocketSendFailed,
    CMSocketUnsupported,
    CMSocketNotConnected,
    CMSocketConnectFailed,
    CMSocketBindFailed,
    CMSocketUnknownError = 0x7FFFFFFF
} CMSocketResult;
 
typedef struct sockaddr_storage CMUTIL_SocketAddr;
 
CMUTIL_API CMSocketResult CMUTIL_SocketAddrGet(
        const CMUTIL_SocketAddr *saddr, char *hostbuf, int *port);
 
CMUTIL_API CMSocketResult CMUTIL_SocketAddrSet(
        CMUTIL_SocketAddr *saddr, const char *host, int port);
 
typedef struct CMUTIL_Socket CMUTIL_Socket;
struct CMUTIL_Socket {
 
    CMSocketResult (*Read)(
            const CMUTIL_Socket *socket,
            CMUTIL_ByteBuffer *buffer,
            uint32_t size, long timeout);
 
    CMSocketResult (*Write)(
            const CMUTIL_Socket *socket,
            const void *data,
            uint32_t size, long timeout);
 
    CMSocketResult (*WritePart)(
            const CMUTIL_Socket *socket, const void *data,
            uint32_t offset, uint32_t length, long timeout);
 
    CMSocketResult (*CheckReadBuffer)(
            const CMUTIL_Socket *socket, long timeout);
 
    CMSocketResult (*CheckWriteBuffer)(
            const CMUTIL_Socket *socket, long timeout);
 
    CMUTIL_Socket *(*ReadSocket)(
            const CMUTIL_Socket *socket,
            long timeout, CMSocketResult *rval);
 
    CMSocketResult (*WriteSocket)(
            const CMUTIL_Socket *socket,
            CMUTIL_Socket *tobesent, pid_t pid, long timeout);
 
    CMSocketResult (*GetRemoteAddr)(
            const CMUTIL_Socket *socket, CMUTIL_SocketAddr *addr);
 
    void (*Close)(
            CMUTIL_Socket *socket);
 
    SOCKET (*GetRawSocket)(
            const CMUTIL_Socket *socket);
 
    int (*ReadByte)(
            const CMUTIL_Socket *socket, long timeout);
 
    CMSocketResult (*WriteByte)(
            const CMUTIL_Socket *socket, uint8_t c, long timeout);
 
    void (*SetSilent)(
            CMUTIL_Socket *socket, CMBool silent);
};
 
CMUTIL_API CMUTIL_Socket *CMUTIL_SocketConnect(
        const char *host, int port, long timeout);
 
CMUTIL_API CMUTIL_Socket *CMUTIL_SocketConnectWithAddr(
        const CMUTIL_SocketAddr *saddr, long timeout);
 
CMUTIL_API CMUTIL_Socket *CMUTIL_SocketConnectIPC(
        const char *ipc_path, long timeout);
 
CMUTIL_API CMUTIL_Socket *CMUTIL_SSLSocketConnect(
        const char *cert, const char *key, const char *ca,
        const char *servername,
        const char *host, int port, long timeout);
 
CMUTIL_API CMUTIL_Socket *CMUTIL_SSLSocketConnectWithAddr(
        const char *cert, const char *key, const char *ca,
        const char *servername,
        const CMUTIL_SocketAddr *saddr, long timeout);
 
typedef struct CMUTIL_ServerSocket CMUTIL_ServerSocket;
struct CMUTIL_ServerSocket {
 
    CMSocketResult (*Accept)(
            const CMUTIL_ServerSocket *server,
            CMUTIL_Socket **res,
            long timeout);
 
    void (*Close)(CMUTIL_ServerSocket *server);
 
    void (*SetSilent)(
            CMUTIL_ServerSocket *socket, CMBool silent);
 
};
 
CMUTIL_API CMUTIL_ServerSocket *CMUTIL_ServerSocketCreate(
        const char *host, int port, int qcnt, CMBool silent);
 
CMUTIL_API CMUTIL_ServerSocket *CMUTIL_ServerSocketCreateIPC(
        const char *ipc_path, int qcnt, CMBool silent);
 
CMUTIL_API CMUTIL_ServerSocket *CMUTIL_SSLServerSocketCreate(
        const char *cert, const char *key, const char *ca,
        const char *host, int port, int qcnt);
 
CMUTIL_API CMBool CMUTIL_SocketPair(
        CMUTIL_Socket **s1, CMUTIL_Socket **s2);
 
typedef struct CMUTIL_DGramSocket CMUTIL_DGramSocket;
struct CMUTIL_DGramSocket {
    CMSocketResult (*Bind)(
            CMUTIL_DGramSocket *dsock,
            const CMUTIL_SocketAddr *saddr);
 
    CMSocketResult (*Connect)(
            CMUTIL_DGramSocket *dsock,
            const CMUTIL_SocketAddr *saddr);
 
    CMBool (*IsConnected)(
            CMUTIL_DGramSocket *dsock);
 
    void (*Disconnect)(
            CMUTIL_DGramSocket *dsock);
 
    CMSocketResult (*GetRemoteAddr)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_SocketAddr *saddr);
 
    CMSocketResult (*GetLocalAddr)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_SocketAddr *saddr);
 
    CMSocketResult (*Send)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_ByteBuffer *buf,
            long timeout);
 
    CMSocketResult (*Recv)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_ByteBuffer *buf,
            long timeout);
 
    CMSocketResult (*SendTo)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_ByteBuffer *buf,
            CMUTIL_SocketAddr *saddr,
            long timeout);
 
    CMSocketResult (*RecvFrom)(
            CMUTIL_DGramSocket *dsock,
            CMUTIL_ByteBuffer *buf,
            CMUTIL_SocketAddr *saddr,
            long timeout);
 
    void (*Close)(
            CMUTIL_DGramSocket *dsock);
};
 
CMUTIL_API CMUTIL_DGramSocket *CMUTIL_DGramSocketCreate(void);
 
CMUTIL_API CMUTIL_DGramSocket *CMUTIL_DGramSocketCreateBind(
        CMUTIL_SocketAddr *addr);
 
 
typedef struct CMUTIL_HttpClient CMUTIL_HttpClient;
struct CMUTIL_HttpClient {
 
    CMBool (*SetVerify)(
            CMUTIL_HttpClient *client,
            CMBool verify_host,
            CMBool verify_peer);
 
    CMBool (*SetSSLCert)(
            CMUTIL_HttpClient *client,
            const char *certfile,
            const char *keyfile,
            const char *cafile );
 
    void (*SetKeepAlive)(
            CMUTIL_HttpClient *client,
            CMBool keepalive);
 
    CMUTIL_ByteBuffer *(*Request)(
            CMUTIL_HttpClient *client,
            const char *method,
            CMUTIL_Map *headers,
            const char *uri,
            CMUTIL_ByteBuffer *body,
            int *status,
            long timeout);
 
    CMUTIL_ByteBuffer *(*Get)(
            CMUTIL_HttpClient *client,
            CMUTIL_Map *headers,
            const char *uri,
            int *status,
            long timeout);
 
    CMUTIL_ByteBuffer *(*Post)(
            CMUTIL_HttpClient *client,
            CMUTIL_Map *headers,
            const char *uri,
            CMUTIL_ByteBuffer *body,
            int *status,
            long timeout);
 
    void (*Destroy)(
            CMUTIL_HttpClient *client);
};
 
CMUTIL_API CMUTIL_HttpClient *CMUTIL_HttpClientCreate(const char *urlprefix);
 
typedef enum CMJsonType {
    CMJsonTypeValue = 0,
    CMJsonTypeObject,
    CMJsonTypeArray
} CMJsonType;
 
typedef struct CMUTIL_Json CMUTIL_Json;
struct CMUTIL_Json {
    void (*ToString)(
            const CMUTIL_Json *json, CMUTIL_String *buf, CMBool pretty);
 
    CMJsonType (*GetType)(
            const CMUTIL_Json *json);
 
    CMUTIL_Json *(*Clone)(
            const CMUTIL_Json *json);
 
    void (*Destroy)(CMUTIL_Json *json);
};
 
#define CMUTIL_JsonDestroy(a)   CMCall((CMUTIL_Json*)(a), Destroy)
 
typedef enum CMJsonValueType {
    CMJsonValueLong = 0,
    CMJsonValueDouble,
    CMJsonValueString,
    CMJsonValueBoolean,
    CMJsonValueNull
} CMJsonValueType;
 
typedef struct CMUTIL_JsonValue CMUTIL_JsonValue;
struct CMUTIL_JsonValue {
    CMUTIL_Json parent;
 
    CMJsonValueType (*GetValueType)(
            const CMUTIL_JsonValue *jval);
 
    int64_t (*GetLong)(
            const CMUTIL_JsonValue *jval);
 
    double (*GetDouble)(
            const CMUTIL_JsonValue *jval);
 
    const CMUTIL_String *(*GetString)(
            const CMUTIL_JsonValue *jval);
 
    const char *(*GetCString)(
            const CMUTIL_JsonValue *jval);
 
    CMBool (*GetBoolean)(
            const CMUTIL_JsonValue *jval);
 
    void (*SetLong)(
            CMUTIL_JsonValue *jval, int64_t inval);
 
    void (*SetDouble)(
            CMUTIL_JsonValue *jval, double inval);
 
    void (*SetString)(
            CMUTIL_JsonValue *jval, const char *inval);
 
    void (*SetBoolean)(
            CMUTIL_JsonValue *jval, CMBool inval);
 
    void (*SetNull)(
            CMUTIL_JsonValue *jval);
};
 
CMUTIL_API CMUTIL_JsonValue *CMUTIL_JsonValueCreate(void);
 
typedef struct CMUTIL_JsonObject CMUTIL_JsonObject;
struct CMUTIL_JsonObject {
    CMUTIL_Json parent;
 
    CMUTIL_StringArray *(*GetKeys)(
            const CMUTIL_JsonObject *jobj);
 
    CMUTIL_Json *(*Get)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    int64_t (*GetLong)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    double (*GetDouble)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    const CMUTIL_String *(*GetString)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    const char *(*GetCString)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    CMBool (*GetBoolean)(
            const CMUTIL_JsonObject *jobj, const char *key);
 
    void (*Put)(
            CMUTIL_JsonObject *jobj, const char *key, CMUTIL_Json *json);
 
    void (*PutLong)(
            CMUTIL_JsonObject *jobj, const char *key, int64_t value);
 
    void (*PutDouble)(
            CMUTIL_JsonObject *jobj, const char *key, double value);
 
    void (*PutString)(
            CMUTIL_JsonObject *jobj, const char *key, const char *value);
 
    void (*PutBoolean)(
            CMUTIL_JsonObject *jobj, const char *key, CMBool value);
 
    void (*PutNull)(
            CMUTIL_JsonObject *jobj, const char *key);
 
    CMUTIL_Json *(*Remove)(
            CMUTIL_JsonObject *jobj, const char *key);
 
    void (*Delete)(
            CMUTIL_JsonObject *jobj, const char *key);
};
 
CMUTIL_API CMUTIL_JsonObject *CMUTIL_JsonObjectCreate(void);
 
typedef struct CMUTIL_JsonArray CMUTIL_JsonArray;
struct CMUTIL_JsonArray {
    CMUTIL_Json parent;
 
    size_t (*GetSize)(
            const CMUTIL_JsonArray *jarr);
 
    CMUTIL_Json *(*Get)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    int64_t (*GetLong)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    double (*GetDouble)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    const CMUTIL_String *(*GetString)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    const char *(*GetCString)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    CMBool (*GetBoolean)(
            const CMUTIL_JsonArray *jarr, uint32_t index);
 
    void (*Add)(
            CMUTIL_JsonArray *jarr, CMUTIL_Json *json);
 
    void (*AddLong)(
            CMUTIL_JsonArray *jarr, int64_t value);
 
    void (*AddDouble)(
            CMUTIL_JsonArray *jarr, double value);
 
    void (*AddString)(
            CMUTIL_JsonArray *jarr, const char *value);
 
    void (*AddBoolean)(
            CMUTIL_JsonArray *jarr, CMBool value);
 
    void (*AddNull)(
            CMUTIL_JsonArray *jarr);
 
    CMUTIL_Json *(*Remove)(
            CMUTIL_JsonArray *jarr, uint32_t index);
 
    void (*Delete)(
            CMUTIL_JsonArray *jarr, uint32_t index);
};
 
CMUTIL_API CMUTIL_JsonArray *CMUTIL_JsonArrayCreate(void);
 
CMUTIL_API CMUTIL_Json *CMUTIL_JsonParse(CMUTIL_String *jsonstr);
 
CMUTIL_API CMUTIL_Json *CMUTIL_XmlToJson(CMUTIL_XmlNode *node);
 
typedef struct CMUTIL_RestClient CMUTIL_RestClient;
struct CMUTIL_RestClient {
    CMUTIL_HttpClient base;
 
    CMUTIL_Json *(*Get)(
            CMUTIL_RestClient *client,
            CMUTIL_Map *headers,
            const char *uri);
 
    CMUTIL_Json *(*Post)(
            CMUTIL_RestClient *client,
            CMUTIL_Map *headers,
            const char *uri,
            CMUTIL_Json *data);
 
    CMBool (*Put)(
            CMUTIL_RestClient *client,
            CMUTIL_Map *headers,
            const char *uri,
            CMUTIL_Json *data);
 
    void (*Delete)(
        CMUTIL_RestClient *client,
        CMUTIL_Map *headers,
        const char *uri);
 
    void (*SetTimeout)(
        CMUTIL_RestClient *client,
        long timeout);
 
    int (*GetStatus)(
        const CMUTIL_RestClient *client);
};
 
#define CMUTIL_REST_DEFAULT_TIMEOUT 30000L
 
CMUTIL_API CMUTIL_RestClient *CMUTIL_RestClientCreate(const char *urlprefix);
 
typedef enum CMProcStreamType {
    CMProcStreamNone = 0,
    CMProcStreamRead = 1,
    CMProcStreamWrite = 2,
    CMProcStreamReadWrite = 3,
    CMProcStreamReadErr = 4
} CMProcStreamType;
 
typedef struct CMUTIL_Process CMUTIL_Process;
struct CMUTIL_Process {
    CMBool (*Start)(CMUTIL_Process *proc, CMProcStreamType type);
 
    pid_t (*GetPid)(CMUTIL_Process *proc);
 
    const char *(*GetCommand)(CMUTIL_Process *proc);
 
    const char *(*GetWorkDir)(CMUTIL_Process *proc);
 
    const CMUTIL_StringArray *(*GetArgs)(CMUTIL_Process *proc);
 
    const CMUTIL_Map *(*GetEnv)(CMUTIL_Process *proc);
 
    void (*Suspend)(CMUTIL_Process *proc);
 
    void (*Resume)(CMUTIL_Process *proc);
 
    CMBool (*PipeTo)(CMUTIL_Process *proc, CMUTIL_Process *target);
 
    ssize_t (*Write)(CMUTIL_Process *proc, const void *buf, size_t count);
 
    ssize_t (*Read)(CMUTIL_Process *proc, CMUTIL_ByteBuffer *buf, size_t count);
 
    int (*Wait)(CMUTIL_Process *proc, long millis);
 
    void (*Kill)(CMUTIL_Process *proc);
 
    void (*Destroy)(CMUTIL_Process *proc);
 
    ssize_t (*ReadErr)(CMUTIL_Process *proc, CMUTIL_ByteBuffer *buf, size_t count);
};
 
CMUTIL_API CMUTIL_Process *CMUTIL_ProcessCreateEx(
        const char *cwd,
        CMUTIL_Map *env,
        const char *command,
        ...);
 
#define CMUTIL_ProcessCreate(cwd, env, command, ...) \
        CMUTIL_ProcessCreateEx(cwd, env, command, ##__VA_ARGS__, NULL)
 
 
typedef struct CMUTIL_BlockCrypto CMUTIL_BlockCrypto;
struct CMUTIL_BlockCrypto {
    CMUTIL_String *(*Encrypt)(
            CMUTIL_BlockCrypto *crypto,
            CMUTIL_String *plain,
            const uint8_t *key, const uint8_t *iv);
    CMUTIL_String *(*Decrypt)(
            CMUTIL_BlockCrypto *crypto,
            CMUTIL_String *encrypted,
            const uint8_t *key, const uint8_t *iv);
    void (*Destroy)(
            CMUTIL_BlockCrypto *crypto);
};
 
CMUTIL_API CMUTIL_BlockCrypto *CMUTIL_BlockCryptoCreate(
        const char *algo, const char *mode, const char *padding,
        int key_bits);
 
 
typedef struct CMUTIL_RSAKey CMUTIL_RSAKey;
 
typedef CMUTIL_RSAKey CMUTIL_PrivateKey;
 
typedef CMUTIL_RSAKey CMUTIL_PublicKey;
struct CMUTIL_RSAKey {
    CMUTIL_String *(*GetEncoded)(CMUTIL_RSAKey *key);
    void (*Destroy)(CMUTIL_RSAKey *key);
};
 
CMUTIL_API CMUTIL_PrivateKey *CMUTIL_PrivateKeyCreateFromPEM(
        const char *pem, const uint8_t *passphrase);
 
CMUTIL_API CMUTIL_PublicKey *CMUTIL_PublicKeyCreateFromPEM(
        const char *pem);
 
CMUTIL_API CMUTIL_PrivateKey *CMUTIL_PrivateKeyCreateFromFile(
        const char *file_path, const uint8_t *passphrase);
 
CMUTIL_API CMUTIL_PublicKey *CMUTIL_PublicKeyCreateFromFile(
        const char *file_path);
 
typedef struct CMUTIL_RSACrypto CMUTIL_RSACrypto;
struct CMUTIL_RSACrypto {
    CMUTIL_String *(*EncryptWithPublicKey)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *plain,
            CMUTIL_PublicKey *pubKey);
    CMUTIL_String *(*EncryptWithPrivateKey)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *plain,
            CMUTIL_PrivateKey *privKey);
    CMUTIL_String *(*DecryptWithPublicKey)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *encrypted,
            CMUTIL_PublicKey *pubKey);
    CMUTIL_String *(*DecryptWithPrivateKey)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *encrypted,
            CMUTIL_PrivateKey *privKey);
    CMUTIL_String *(*Sign)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *plain,
            CMUTIL_PrivateKey *privKey);
    CMBool (*VerifySignature)(
            CMUTIL_RSACrypto *crypto,
            CMUTIL_String *plain,
            CMUTIL_String *signature,
            CMUTIL_PublicKey *pubKey);
    void (*Destroy)(
            CMUTIL_RSACrypto *crypto);
};
 
CMUTIL_API CMUTIL_RSACrypto *CMUTIL_RSACryptoCreate(void);
 
CMUTIL_API void CMUTIL_CryptoRandom(uint8_t *buf, size_t len);
 
CMUTIL_API CMUTIL_String *CMUTIL_CryptoToBase64(const uint8_t *data, size_t len);
 
CMUTIL_API CMUTIL_String *CMUTIL_CryptoFromBase64(const char *base64);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBCMUTILS_H__