|
|
mdz_ansi Overviewmdz_ansi - very lightweight, versatile and speedy C library for handling single-byte (ASCII/ANSI) strings. Source code of library is highly-portable, conforms to ANSI C 89/90 Standard. Builds for Win32/Win64, Linux, FreeBSD, Android, macOS are available. Please refer to mdz_ansi Wiki for API details. mdz_ansi Advantages 1. High portability: the whole code conforms to ANSI C 89/90 Standard. Multithreading/asynchronous part is POSIX compatible (under UNIX/Linux). 2. Little dependencies: basically, mdz_ansi functions are only dependent on standard C-library memory-management/access functions. Multithreading part is dependent on POSIX pthreads API (under UNIX/Linux) and old process control/synchronization API (from Windows 2000). It means you can use library in your code without any further dependencies except standard platform libraries/APIs. 3. Fast: comparison tables are coming soon... 4. Flexibilty: nearly all functions contain not only "left position" but also "right position" parameters to limit processed area from right. "ANSI" ansi contains more functions than according STL, boost or glib analogs have. 5. Extended error-checking: all functions preserve internal error-code pointing the problem. It is possible to use strict error-checking (when all preserved error-codes should be MDZ_ERROR_NONE) or "relaxed"-checking - when only returned mdz_false will indicate error. 6. Extended control: library functions do only explicit operations. It means for example, when "insert" function is called - it will return error if there is not enough capacity in string. No implicit reservations will be made. 7. Attached usage: string should not necessarily use dynamically-allocated memory - which may be not available on your embedded system (or if malloc()/free() are forbidden to use in you safety-critical software). Just attach string/data to your statically-allocated memory and use all string functionality. 8. Cache-friendly: it is possible to keep controlling and data parts together in memory using "embedded part". 9. Asynchronous execution: almost all functions can be executed asynchronously.
mdz_ansi API ReferenceAsynchronous executionMany functions of mdz_ansi accept parameters for asynchronous execution.
The only relevant parameter is: - struct mdz_asyncData* pAsyncData - pointer to shared async data for asynchronous call, or NULL if call should be synchronous Fields of struct mdz_asyncData* are following: | Type | Parameter | Description |
|---|
void* | m_pString | Pointer to string instance | mdz_bool | m_bFinished | mdz_true if the call is completely finished. Otherwise mdz_false (if interrupted/cancelled) | size_t | m_nResult | Result of call. Invalid if call is not completely finished (m_bFinished is mdz_false) | void* | m_pData | Additional data returned by call (if any). Invalid if call is not completely finished (m_bFinished is mdz_false) | mdz_bool | m_bCancel | Should be set by client in mdz_true during call execution, to cancel the call. Otherwise mdz_false | pthread_t / HANDLE | m_hThread | Handle to thread on which the call is executed. May be used by client for wait operations |
mdz_ansi is dynamically-sized contiguous single-byte string, containing ASCII (0..127) and "ANSI" (128 - 255) characters.
Capacity - how many bytes of memory is reserved.
Size - how many characters are actually residing in a string, excluding terminating 0.
"reserve" functions allocate/reallocate memory dynamically using malloc()/realloc().
"attach" functionality allows attaching contiguous block of memory to string, for using string functions on it.
Library init functions:mdz_ansi_init
mdz_ansi_init_attached
mdz_ansi_uninitInit and destroy functions:mdz_ansi_create
mdz_ansi_create_attached
mdz_ansi_destroy
mdz_ansi_clear
mdz_ansi_attachDataReserve capacity functions:mdz_ansi_reserve
mdz_ansi_reserveAndInit_async
mdz_ansi_capacity
mdz_ansi_size
mdz_ansi_resize
mdz_ansi_offsetFromStart
mdz_ansi_isAttachedData
mdz_ansi_embedSizeInsert/remove functions:mdz_ansi_insert_async
mdz_ansi_insertDoubleZerowed_async
mdz_ansi_removeFrom_async
mdz_ansi_remove_async
mdz_ansi_trimLeft_async
mdz_ansi_trimRight_async
mdz_ansi_trim_asyncFind functions:mdz_ansi_findSingle_async
mdz_ansi_find_async
mdz_ansi_firstOf_async
mdz_ansi_firstNotOf_async
mdz_ansi_rfindSingle_async
mdz_ansi_rfind_async
mdz_ansi_lastOf_async
mdz_ansi_lastNotOf_asyncMiscellaneous functions:mdz_ansi_compare_async
mdz_ansi_replace_async
mdz_ansi_count_async
mdz_ansi_copySubAnsi_async
mdz_ansi_copySubAnsiFrom_async
Initializes ansi library. This function should be called before any other function of the library.mdz_bool mdz_ansi_init(const uint32_t* pFirstNameHash, const uint32_t* pLastNameHash, const uint32_t* pEmailHash, const uint32_t* pLicenseHash);| Parameter | Description |
|---|
pFirstNameHash | user first name hash code | pLastNameHash | user last name hash code | pEmailHash | user e-mail hash code | pLicenseHash | license hash code |
| Return | Description |
|---|
| mdz_true | if the initialization has succeed, otherwise false |
mdz_ansi Reference
Initializes ansi library. This function should be caled before any other function of the library.
Memory for license data starts at position pStart. Size of internal initialization structure is returned in pSize.mdz_bool mdz_ansi_init_attached(const uint32_t* pFirstNameHash, const uint32_t* pLastNameHash, const uint32_t* pEmailHash, const uint32_t* pLicenseHash, const char* pStart, size_t nAreaSize, size_t* pOutSize);| Parameter | Description |
|---|
pFirstNameHash | user first name hash code | pLastNameHash | user last name hash code | pEmailHash | user e-mail hash code | pLicenseHash | license hash code | pStart | memory start position of license data | nAreaSize | size of available memory from pStart in bytes. Should be large enough for license data (> 500 bytes) | pOutSize | actual size of placed license data in bytes |
| Return | Description |
|---|
| mdz_true | if the initialization has succeed, otherwise false |
mdz_ansi Reference
Un-initializes ansi library and frees corresponding memory allocations.void mdz_ansi_uninit(void);mdz_ansi Reference
Create empty string with Capacity and Size 0.struct mdz_Ansi* mdz_ansi_create(size_t nEmbedSize);| Parameter | Description |
|---|
nEmbedSize | size of "embedded part" of string. There is no "embedded part" if 0 |
| Return | Description |
|---|
NULL | if library is not initialized with mdz_ansi_init() | NULL | if memory allocation failed | | Result | pointer to string for use in other mdz_ansi functions |
mdz_ansi Reference
Create empty string with Capacity and Size 0. Memory for mdz_Ansi structure starts at position pStart. Size of internal ansi structure (it is usually bigger than mdz_Ansi) is returned in pSize.struct mdz_Ansi* mdz_ansi_create_attached(const void* pStart, size_t nAreaSizeBytes, size_t* pOutSize);| Parameter | Description |
|---|
pStart | memory start position of mdz_Ansi structure | nAreaSizeBytes | size of available memory from pStart in bytes. Should be large enough for internal Ansi structure | pOutSize | returned actual size of placed internal ansi structure in bytes, may be NULL if not needed |
| Return | Description |
|---|
NULL | if library is not initialized with mdz_ansi_init() | NULL | if pStart == NULL or pSize == NULL | NULL | if size in nSize is smaller than size of internal ansi structure | | Result | pointer to string for use in other mdz_Ansi functions. Normally it equals to pStart |
mdz_ansi Reference
Destroy string including underlying data. After destroying, pointer to string is set to NULL.
If string is attached using mdz_ansi_createAttached(), free() will not be called.
If string data is attached using mdz_ansi_attachData(), m_pData will not be destroyed.void mdz_ansi_destroy(struct mdz_Ansi** const ppAnsi);| Parameter | Description |
|---|
ppAnsi | pointer to pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
mdz_ansi Reference
Clear m_pData of string with setting Size in 0.void mdz_ansi_clear(struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() |
mdz_ansi Reference
Attach pre-allocated data to string, assigning pcData to m_pData. If attached, m_pData will not be destroyed in mdz_ansi_destroy()mdz_bool mdz_ansi_attachData(struct mdz_Ansi* pAnsi, const char* pData, size_t nOffsetFromStart, size_t nCapacity, enum mdz_attach_type enAttachType);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | pData | pointer to pre-allocated data to attach | nOffsetFromStart | position in pre-allocated data to attach from. Can be > 0 | nCapacity | full capacity of pre-allocated data in items | enAttachType | type of attachment. 0 is expected at position pData[nOffsetFromStart] if MDZ_ATTACH_ZEROSIZE. 0 is expected at position pData[nCapacity - 1] if MDZ_ATTACH_SIZE_TERMINATOR |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if pData == NULL (MDZ_ERROR_DATA), or nOffsetFromStart >= nCapacity (MDZ_ERROR_OFFSET) | | mdz_false | if enAttachType is MDZ_ATTACH_ZEROSIZE or MDZ_ATTACH_SIZE_TERMINATOR but 0 is not found at expected position (MDZ_ERROR_ATTACH_TERMINATOR) | | mdz_true | operation succeeded |
mdz_ansi Reference
Reserve nNewCapacity items for string. String Size does not change. Reservation is not made if m_pData is attached using mdz_ansi_attachData()mdz_bool mdz_ansi_reserve(struct mdz_Ansi* pAnsi, size_t nNewCapacity);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nNewCapacity | new capacity in items to reserve |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if memory allocation failed (MDZ_ERROR_ALLOCATION) | | mdz_false | if nNewCapacity > Capacity and m_pData is attached using mdz_ansi_attachData() (MDZ_ERROR_ATTACHED) | | mdz_true | if nNewCapacity <= Capacity (MDZ_ERROR_CAPACITY) | | mdz_true | reservation succeeded |
mdz_ansi Reference
Reserve nNewCapacity items for string and initializes all items in cItem. May be called only on empty string (with Size == 0). After call, string Size equals to Capacity-1.
Reservation is not made if m_pData is attached using mdz_ansi_attachData() and nNewCapacity > Capacitymdz_bool mdz_ansi_reserveAndInit_async(struct mdz_Ansi* pAnsi, size_t nNewCapacity, char cItem, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_reserveAndInit(pAnsi, nNewCapacity, cItem);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nNewCapacity | capacity to reserve in items | cItem | item for string initialization | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if memory allocation failed (MDZ_ERROR_ALLOCATION) | | mdz_false | if Size > 0 (MDZ_ERROR_NONEMPTY) | | mdz_false | if nNewCapacity > Capacity and m_pData is attached using mdz_ansi_attachData() (MDZ_ERROR_ATTACHED) | | mdz_true | if nNewCapacity <= Capacity (MDZ_ERROR_CAPACITY), initialization succeeded | | mdz_true | reservation and initialization succeeded |
mdz_ansi Reference
Return string Capacity in items.size_t mdz_ansi_capacity(const struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Capacity | otherwise |
mdz_ansi Reference
Return string Size in items.size_t mdz_ansi_size(const struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | otherwise |
mdz_ansi Reference
Set string Size. Size must be < Capacity (because of terminating 0)mdz_bool mdz_ansi_resize(struct mdz_Ansi* pAnsi, size_t nNewSize);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nNewSize | new Size to set string in |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if nNewSize >= Capacity (MDZ_ERROR_CAPACITY). String Size is not changed | | mdz_true | if succeeded |
mdz_ansi Reference
Return string OffsetFromStart in items.size_t mdz_ansi_offsetFromStart(const struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | | OffsetFromStart | otherwise |
mdz_ansi Reference
Return if string data is attached.mdz_bool mdz_ansi_isAttachedData(const struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if string data is not attached | | mdz_true | if string data is attached |
mdz_ansi Reference
Return string "embedded part" Size in items.size_t mdz_ansi_embedSize(const struct mdz_Ansi* pAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | | Result | "embedded part" Size otherwise |
mdz_ansi Reference
Insert nCount items in string. String m_pData and pItems cannot overlap, if reservation is allowed. Size grows on nCount.mdz_bool mdz_ansi_insert_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, const char* pcItems, size_t nCount, mdz_bool bReserve, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_insert(pAnsi, nLeftPos, pcItems, nCount, bReserve);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based position to insert. If nLeftPos == Size or -1, items are appended. nLeftPos > Size is not allowed | pcItems | items to insert | nCount | number of items to insert or 0 if pcItems until 0-terminator should be used | bReserve | if mdz_true reserve capacity when there is not enough space for insertion, otherwise mdz_false | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if bReserve == mdz_true and memory allocation failed (MDZ_ERROR_ALLOCATION) | | mdz_false | if bReserve == mdz_true and there is not enough capacity for inserted data, but m_pData is attached using mdz_ansi_attachData() (MDZ_ERROR_ATTACHED) | | mdz_false | if bReserve == mdz_false and there is not enough free Capacity in the string (MDZ_ERROR_CAPACITY) | | mdz_true | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > Size (MDZ_ERROR_BIGLEFT), or nCount is too big (MDZ_ERROR_BIGCOUNT). No insertion is made | | mdz_true | insertion succeeded |
mdz_ansi Reference
Insert items in string until double-zerowed terminator ("\0\0"). String m_pData and pItems cannot overlap, if reservation is allowed. Size grows on inserted string length.mdz_bool mdz_ansi_insertDoubleZerowed_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, const char* pcItems, mdz_bool bReserve, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_insertDoubleZerowed(pAnsi, nLeftPos, pcItems, bReserve);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based position to insert. If nLeftPos == Size or -1, items are appended. nLeftPos > Size is not allowed | pcItems | items to insert | bReserve | if mdz_true reserve capacity when there is not enough space for insertion, otherwise mdz_false | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if bReserve == mdz_true and memory allocation failed (MDZ_ERROR_ALLOCATION) | | mdz_false | if bReserve == mdz_true and there is not enough capacity for inserted data, but m_pData is attached using mdz_ansi_attachData() (MDZ_ERROR_ATTACHED) | | mdz_false | if bReserve == mdz_false and there is not enough free Capacity in the string (MDZ_ERROR_CAPACITY) | | mdz_true | if pcItems == NULL (MDZ_ERROR_ITEMS), or pcItems length id 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > Size (MDZ_ERROR_BIGLEFT), or pcItems is too long (MDZ_ERROR_BIGCOUNT). No insertion is made | | mdz_true | insertion succeeded |
mdz_ansi Reference
Find first occurrence of cItem in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_findSingle_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, char cItem, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_findSingle(pAnsi, nLeftPos, nRightPos, cItem);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to search from left. Use 0 to search from the beginning of string | nRightPos | 0-based end position to search up to. Use Size-1 or -1 to search till the end of string | cItem | character to find | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find first occurrence of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_find_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, enum mdz_find_method enFindMethod, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_find(pAnsi, nLeftPos, nRightPos, pcItems, nCount, enFindMethod);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to search from left. Use 0 to search from the beginning of string | nRightPos | 0-based end position to search up to. Use Size-1 or -1 to search till the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | enFindMethod | find method to use. See details in mdz_find_method description | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT), or nCount is too big (MDZ_ERROR_BIGCOUNT), or invalid enFindMethod (MDZ_ERROR_FINDMETHOD). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find first occurrence of any item of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_firstOf_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_firstOf(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to search from left. Use 0 to search from the beginning of string | nRightPos | 0-based end position to search up to. Use Size-1 or -1 to search till the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find first non-occurrence of any item of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_firstNotOf_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_firstNotOf(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to search from left. Use 0 to search from the beginning of string | nRightPos | 0-based end position to search up to. Use Size-1 or -1 to serch till the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if non-occurence is not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find last occurrence of cItem in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_rfindSingle_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, char cItem, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_rfindSingle(pAnsi, nLeftPos, nRightPos, cItem);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based end position to find up to. Use 0 to search till the beginning of string | nRightPos | 0-based start position to find from right. Use Size-1 or -1 to serch from the end of string | cItem | character to find | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find last occurrence of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_rfind_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, enum mdz_find_method enFindMethod, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_rfind(pAnsi, nLeftPos, nRightPos, pcItems, nCount, enFindMethod);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based end position to find up to. Use 0 to search till the beginning of string | nRightPos | 0-based start position to find from right. Use Size-1 or -1 to serch from the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | enFindMethod | find method to use. See details in mdz_find_method description | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT), or nCount is too big (MDZ_ERROR_BIGCOUNT), or invalid enFindMethod (MDZ_ERROR_FINDMETHOD). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find last occurrence of any item of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_lastOf_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_lastOf(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based end position to search up to. Use 0 to search till the beginning of string | nRightPos | 0-based start position to search from right. Use Size-1 or -1 to serch from the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if item(s) not found | | Result | 0-based position of first match |
mdz_ansi Reference
Find last non-occurrence of any item of pcItems in string. Returns 0-based position of match (if found), or string Size if not found, or SIZE_MAX if error.size_t mdz_ansi_lastNotOf_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_lastNotOf(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based end position to search up to. Use 0 to search till the beginning of string | nRightPos | 0-based start position to search from right. Use Size-1 or -1 to serch from the end of string | pcItems | pointer to items to find | nCount | number of items to find or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | Size | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No search is made | Size | if non-occurence is not found | | Result | 0-based position of first match |
mdz_ansi Reference
Remove nCount item(s) starting from 0-based nLeftPos position. After the operation, Capacity doesn't change, Size decreases on nCount.mdz_bool mdz_ansi_removeFrom_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_removeFrom(pAnsi, nLeftPos, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to remove item(s) from. Use 0 to remove from the beginning of string | nCount | number of item(s) to remove or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_true | if nCount == 0 (MDZ_ERROR_ZEROCOUNT), or nCount is too big (MDZ_ERROR_BIGCOUNT), or nLeftPos + nCount > Size (MDZ_ERROR_BIGLEFT). No removes are made | | mdz_true | operation succeeded |
mdz_ansi Reference
Remove all ocurrences of nCount item(s) matching to pcItems, residing between nLeftPos and nRightPos. After remove(s) Capacity doesn't change, Size decreases on nCount of removed items.mdz_bool mdz_ansi_remove_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_remove(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to remove item(s) from. Use 0 to search from the beginning of string | nRightPos | 0-based end position to remove item(s) up to. Use Size-1 or -1 to serch till the end of string | pcItems | pointer to items to remove | nCount | number of item(s) to remove or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_true | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT), or nCount is too big (MDZ_ERROR_BIGCOUNT). No removes are made | | mdz_true | operation succeeded |
mdz_ansi Reference
Remove items which are contained in pcItems from left, until first non-contained in pcItems item is reached.mdz_bool mdz_ansi_trimLeft_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_trimLeft(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to trim item(s) from left. Use 0 to trim from the beginning of string | nRightPos | 0-based end position to trim item(s) up to. Use Size-1 or -1 to trim till the end of string | pcItems | pointer to items to remove | nCount | number of items to remove or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_true | if string is empty (MDZ_ERROR_EMPTY), or pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No trims are made | | mdz_true | operation succeeded |
mdz_ansi Reference
Remove items which are contained in pcItems from right, until first non-contained in pcItems item is reached.mdz_bool mdz_ansi_trimRight_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_trimRight(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based end position to trim item(s) up to. Use 0 to trim till the beginning of string | nRightPos | 0-based start position to trim item(s) from right. Use Size-1 or -1 to trim from the end of string | pcItems | pointer to items to remove | nCount | number of items to remove or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_true | if string is empty (MDZ_ERROR_EMPTY), or pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No removes are made | | mdz_true | operation succeeded |
mdz_ansi Reference
Remove items which are contained in pcItems from left and from right, until first non-contained in pcItems item is reached.mdz_bool mdz_ansi_trim_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_trim(pAnsi, nLeftPos, nRightPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to trim item(s) from left. Use 0 to trim from the beginning of string | nRightPos | 0-based start position to trim item(s) from right. Use Size-1 or -1 to trim from the end of string | pcItems | pointer to items to remove | nCount | number of items to remove or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_true | if string is empty (MDZ_ERROR_EMPTY), or pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No removes are made | | mdz_true | operation succeeded, otherwise mdz_false |
mdz_ansi Reference
Compare content of string with pcItems.enum mdz_compare_result mdz_ansi_compare_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, const char* pcItems, size_t nCount, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_compare(pAnsi, nLeftPos, pcItems, nCount);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to compare from. Use 0 to compare from the beginning of string | pcItems | pointer to items to compare | nCount | number of items to compare or 0 if pcItems until 0-terminator should be used | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
MDZ_COMPARE_ERROR | if pAnsi == NULL | MDZ_COMPARE_NONEQUAL | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos >= Size (MDZ_ERROR_BIGLEFT), or nCount is too big (MDZ_ERROR_BIGCOUNT). No comparison is made | MDZ_COMPARE_EQUAL or MDZ_COMPARE_NONEQUAL | Result of comparison |
mdz_ansi Reference
Replace every occurence of pcItemsBefore with pcItemsAfter. There should be enough Capacity for replacing data.mdz_bool mdz_ansi_replace_async(struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItemsBefore, size_t nCountBefore, const char* pcItemsAfter, size_t nCountAfter, mdz_bool bReserve, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_replace(pAnsi, nLeftPos, nRightPos, pcItemsBefore, nCountBefore, pcItemsAfter, nCountAfter, bReserve);| Parameter | Description |
|---|
pAnsi | pointer to astring returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to search for replace from. Use 0 to search from the beginning of string | nRightPos | 0-based end position to search for replace up to. Use Size-1 or -1 to seach till the end of string | pcItemsBefore | pointer to items to replace | nCountBefore | number of items to replace or 0 if pcItems until 0-terminator should be used | pcItemsAfter | pointer to items to replace with | nCountAfter | number of items to replace with or 0 if pcItems until 0-terminator should be used | bReserve | if mdz_true reserve capacity when there is not enough space for replacement, otherwise mdz_false | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
| mdz_false | if pAnsi == NULL | | mdz_false | if bReserve == mdz_true and there is not enough capacity for inserted data, but m_pData is attached using mdz_ansi_attachData() (MDZ_ERROR_ATTACHED) | | mdz_false | if bReserve == mdz_false and there is not enough free Capacity in the string (MDZ_ERROR_CAPACITY) | | mdz_true | if pcItemsBefore == NULL (MDZ_ERROR_ITEMS), or nCountBefore == 0 and pcItemsBefore[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT), or nCountBefore is too big (MDZ_ERROR_BIGCOUNT). No replacements are made | | mdz_true | operation succeeded |
mdz_ansi Reference
Counts number of pcItems substring occurences in string.size_t mdz_ansi_count_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcItems, size_t nCount, enum mdz_find_method enFindMethod, mdz_bool bAllowOverlapped, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_count(pAnsi, nLeftPos, nRightPos, pcItems, nCount, enFindMethod, bAllowOverlapped);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to count from. Use 0 to count from the beginning of string | nRightPos | 0-based end position to count up to. Use Size-1 or -1 to count till the end of string | pcItems | items/substring to count | nCount | Size of substring to count or 0 if pcItems until 0-terminator should be used | enFindMethod | find method to use. See details in mdz_find_method description | bAllowOverlapped | mdz_true if overlapped substrings should be counted, otherwise mdz_false | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL | | 0 | if pcItems == NULL (MDZ_ERROR_ITEMS), or nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT), or nCount is too big (MDZ_ERROR_BIGCOUNT), or invalid enFindMethod (MDZ_ERROR_FINDMETHOD). No counting is made | | Result | 0-based count of substring occurences. 0 if not found |
mdz_ansi Reference
Fills pSubAnsi with items from pAnsi, starting from nLeftPos and ending with one of pSeparators or nRightPos.size_t mdz_ansi_copySubAnsi_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nRightPos, const char* pcSeparators, size_t nSeparatorsCount, struct mdz_Ansi* pSubAnsi, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_copySubAnsi(pAnsi, nLeftPos, nRightPos, pcSeparators, nSeparatorsCount, pSubAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to get items from. Use 0 to start from the beginning of string | nRightPos | 0-based end position to get items up to. Use Size-1 or -1 to proceed till the end of string | pcSeparators | separators to get items up to | nSeparatorsCount | number of separators or 0 if pcSeparators until 0-terminator should be used | pSubAnsi | pointer to string where items should be copied. Data in pSubAnsi will be re-reserved to appropriate size if necessary | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL, or pSubAnsi == NULL (MDZ_ERROR_SUBCONTAINER), or reallocation of m_pData in pSubAnsi was necessary but failed (MDZ_ERROR_ALLOCATION) | Size | if pcSeparators == NULL (MDZ_ERROR_ITEMS), or nSeparatorsCount == 0 (MDZ_ERROR_ZEROCOUNT), or nLeftPos > nRightPos (MDZ_ERROR_BIGLEFT), or nRightPos >= Size (MDZ_ERROR_BIGRIGHT). No copying is made | | Result | 0-based position after separator if found, or Size if not found |
mdz_ansi Reference
Fills pSubAnsi with items from pAnsi, starting from nLeftPos and containing nCount items.size_t mdz_ansi_copySubAnsiFrom_async(const struct mdz_Ansi* pAnsi, size_t nLeftPos, size_t nCount, struct mdz_Ansi* pSubAnsi, struct mdz_asyncData* pAsyncData);Synchronous version:
mdz_ansi_copySubAnsiFrom(pAnsi, nLeftPos, nCount, pSubAnsi);| Parameter | Description |
|---|
pAnsi | pointer to string returned by mdz_ansi_create() or mdz_ansi_create_attached() | nLeftPos | 0-based start position to get items from. Use 0 to start from the beginning of string | nCount | number of items to copy or 0 if pcItems until 0-terminator should be used | pSubAnsi | pointer to string where items should be copied. Data in pSubAnsi will be re-reserved to appropriate size if necessary | pAsyncData | pointer to shared async data for asynchronous call, or NULL if call should be synchronous |
| Return | Description |
|---|
SIZE_MAX | if pAnsi == NULL, or pSubAnsi == NULL (MDZ_ERROR_SUBCONTAINER), or reallocation of m_pData in pSubAnsi was necessary but failed (MDZ_ERROR_ALLOCATION) | Size | if nCount == 0 and pcItems[0] == 0 (MDZ_ERROR_ZEROCOUNT), or nCount is too big (MDZ_ERROR_BIGCOUNT), or nLeftPos + nCount > Size (MDZ_ERROR_BIGLEFT). No copying is made | | Result | 0-based position after copied data, or Size if copied until the end of pAnsi |
mdz_ansi Reference
|
| 