ucx: comparison src/cx/buffer.h

-:8b0f162ac88e
+:36c0fb2b60b2
 #define UCX_BUFFER_H
 #include "common.h"
 #include "allocator.h"
 #include "string.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
 /**
 * No buffer features enabled (all flags cleared).
 */
 #define CX_BUFFER_DEFAULT 0x00
 * new memory
 * @param capacity the capacity of the buffer
 * @param flags buffer features (see cx_buffer_s.flags)
 * @return zero on success, non-zero if a required allocation failed
 */
-cx_attr_nonnull_arg(1)
+CX_EXTERN CX_NONNULL_ARG(1)
-CX_EXPORT int cxBufferInit(CxBuffer *buffer, const CxAllocator *allocator,
+int cxBufferInit(CxBuffer *buffer, const CxAllocator *allocator,
 void *space, size_t capacity, int flags);
 /**
 * Destroys the buffer contents.
 *
 * If you want to free the memory of the entire buffer, use cxBufferFree().
 *
 * @param buffer the buffer which contents shall be destroyed
 * @see cxBufferInit()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT void cxBufferDestroy(CxBuffer *buffer);
+void cxBufferDestroy(CxBuffer *buffer);
 /**
 * Deallocates the buffer.
 *
 * If the #CX_BUFFER_FREE_CONTENTS feature is enabled, this function also destroys
 * the contents. If you @em only want to destroy the contents, use cxBufferDestroy().
 *
 * @param buffer the buffer to deallocate
 * @see cxBufferCreate()
 */
-CX_EXPORT void cxBufferFree(CxBuffer *buffer);
+CX_EXTERN
+void cxBufferFree(CxBuffer *buffer);
 /**
 * Allocates and initializes a fresh buffer.
 *
 * You may also provide a read-only @p space, in which case
 * new memory
 * @param capacity the capacity of the buffer
 * @param flags buffer features (see cx_buffer_s.flags)
 * @return a pointer to the buffer on success, @c NULL if a required allocation failed
 */
-cx_attr_malloc cx_attr_dealloc(cxBufferFree, 1) cx_attr_nodiscard
+CX_EXTERN CX_MALLOC CX_DEALLOC(cxBufferFree, 1) CX_NODISCARD
-CX_EXPORT CxBuffer *cxBufferCreate(const CxAllocator *allocator, void *space,
+CxBuffer *cxBufferCreate(const CxAllocator *allocator, void *space,
 size_t capacity, int flags);
 /**
 * Shifts the contents of the buffer by the given offset.
 *
 * @retval zero success
 * @retval non-zero if a required auto-extension or copy-on-write fails
 * @see cxBufferShiftLeft()
 * @see cxBufferShiftRight()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferShift(CxBuffer *buffer, off_t shift);
+int cxBufferShift(CxBuffer *buffer, off_t shift);
 /**
 * Shifts the buffer to the right.
 * See cxBufferShift() for details.
 *
 * @param shift the shift offset
 * @retval zero success
 * @retval non-zero if a required auto-extension or copy-on-write fails
 * @see cxBufferShift()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferShiftRight(CxBuffer *buffer, size_t shift);
+int cxBufferShiftRight(CxBuffer *buffer, size_t shift);
 /**
 * Shifts the buffer to the left.
 * See cxBufferShift() for details.
 *
 * @param shift the positive shift offset
 * @retval zero success
 * @retval non-zero if the buffer uses copy-on-write and the allocation fails
 * @see cxBufferShift()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferShiftLeft(CxBuffer *buffer, size_t shift);
+int cxBufferShiftLeft(CxBuffer *buffer, size_t shift);
 /**
 * Moves the position of the buffer.
 *
 * @param whence one of @c SEEK_SET, @c SEEK_CUR or @c SEEK_END
 * @retval zero success
 * @retval non-zero if the position is invalid
 *
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferSeek(CxBuffer *buffer, off_t offset, int whence);
+int cxBufferSeek(CxBuffer *buffer, off_t offset, int whence);
 /**
 * Discards items from the end of the buffer.
 *
 * When the current position points to a byte that gets discarded,
 * @param buffer the buffer
 * @param size the size of one item
 * @param nitems the number of items to discard
 * @return the actual number of discarded items
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cxBufferPop(CxBuffer *buffer, size_t size, size_t nitems);
+size_t cxBufferPop(CxBuffer *buffer, size_t size, size_t nitems);
 /**
 * Clears the buffer by resetting the position and deleting the data.
 *
 * The data is deleted by zeroing it with a call to memset().
 * will not erase the data and behave exactly as cxBufferReset().
 *
 * @param buffer the buffer to be cleared
 * @see cxBufferReset()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT void cxBufferClear(CxBuffer *buffer);
+void cxBufferClear(CxBuffer *buffer);
 /**
 * Resets the buffer by resetting the position and size to zero.
 *
 * The data in the buffer is not deleted. If you need a safe
 * reset of the buffer, use cxBufferClear().
 *
 * @param buffer the buffer to be cleared
 * @see cxBufferClear()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT void cxBufferReset(CxBuffer *buffer);
+void cxBufferReset(CxBuffer *buffer);
 /**
 * Tests, if the buffer position has exceeded the buffer size.
 *
 * @param buffer the buffer to test
 * @retval true if the current buffer position has exceeded the last
 * byte of the buffer's contents
 * @retval false otherwise
 */
-cx_attr_nonnull cx_attr_nodiscard
+CX_EXTERN CX_NONNULL CX_NODISCARD
-CX_EXPORT bool cxBufferEof(const CxBuffer *buffer);
+bool cxBufferEof(const CxBuffer *buffer);
 /**
 * Ensures that the buffer has the required capacity.
 *
 * If the current capacity is not sufficient, the buffer will be extended.
 * @retval zero on success
 * @retval non-zero on allocation failure
 * @see cxBufferShrink()
 * @see cxBufferMinimumCapacity()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferReserve(CxBuffer *buffer, size_t capacity);
+int cxBufferReserve(CxBuffer *buffer, size_t capacity);
 /**
 * Limits the buffer's capacity.
 *
 * If the current capacity is already larger, this function fails and returns
 * @retval zero the limit is applied
 * @retval non-zero the new limit is smaller than the current capacity
 * @see cxBufferReserve()
 * @see cxBufferMinimumCapacity()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferMaximumCapacity(CxBuffer *buffer, size_t capacity);
+int cxBufferMaximumCapacity(CxBuffer *buffer, size_t capacity);
 /**
 * Ensures that the buffer has a minimum capacity.
 *
 * If the current capacity is not sufficient, the buffer will be generously
 * @retval non-zero on allocation failure
 * @see cxBufferMaximumCapacity()
 * @see cxBufferReserve()
 * @see cxBufferShrink()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferMinimumCapacity(CxBuffer *buffer, size_t capacity);
+int cxBufferMinimumCapacity(CxBuffer *buffer, size_t capacity);
 /**
 * Shrinks the capacity of the buffer to fit its current size.
 *
 * If @p reserve is larger than zero, the buffer is shrunk to its size plus
 * @param buffer the buffer
 * @param reserve the number of bytes that shall remain reserved
 * @see cxBufferReserve()
 * @see cxBufferMinimumCapacity()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT void cxBufferShrink(CxBuffer *buffer, size_t reserve);
+void cxBufferShrink(CxBuffer *buffer, size_t reserve);
 /**
 * Writes data to a CxBuffer.
 *
 * If auto-extension is enabled, the buffer's capacity is automatically
 * @param buffer the CxBuffer to write to
 * @return the total count of elements written
 * @see cxBufferAppend()
 * @see cxBufferRead()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cxBufferWrite(const void *ptr, size_t size,
+size_t cxBufferWrite(const void *ptr, size_t size,
 size_t nitems, CxBuffer *buffer);
 /**
 * Appends data to a CxBuffer.
 *
 * @param buffer the CxBuffer to write to
 * @return the total count of elements written
 * @see cxBufferWrite()
 * @see cxBufferRead()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cxBufferAppend(const void *ptr, size_t size,
+size_t cxBufferAppend(const void *ptr, size_t size,
 size_t nitems, CxBuffer *buffer);
 /**
 * Reads data from a CxBuffer.
 *
 * @param buffer the CxBuffer to read from
 * @return the total number of elements read
 * @see cxBufferWrite()
 * @see cxBufferAppend()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cxBufferRead(void *ptr, size_t size,
+size_t cxBufferRead(void *ptr, size_t size,
 size_t nitems, CxBuffer *buffer);
 /**
 * Writes a character to a buffer.
 *
 * @param c the character to write
 * @return the byte that has been written or @c EOF when the end of the
 * stream is reached, and automatic extension is not enabled or not possible
 * @see cxBufferTerminate()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferPut(CxBuffer *buffer, int c);
+int cxBufferPut(CxBuffer *buffer, int c);
 /**
 * Writes a terminating zero to a buffer at the current position.
 *
 * If successful, also sets the size to the current position and shrinks the buffer.
 *
 * @param buffer the buffer to write to
 * @return zero, if the terminator could be written, non-zero otherwise
 * @see cxBufferShrink()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferTerminate(CxBuffer *buffer);
+int cxBufferTerminate(CxBuffer *buffer);
 /**
 * Internal function - do not use.
 *
 * @param buffer the buffer
 * @param str the string
 * @return the number of bytes written
 * @see cxBufferPutString()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cx_buffer_put_string(CxBuffer *buffer, cxstring str);
+size_t cx_buffer_put_string(CxBuffer *buffer, cxstring str);
 /**
 * Writes a string to a buffer with cxBufferWrite().
 *
 * @param buffer (@c CxBuffer*) the buffer
 * @param buffer the buffer
 * @param str the string
 * @return the number of bytes written
 * @see cxBufferPutString()
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT size_t cx_buffer_append_string(CxBuffer *buffer, cxstring str);
+size_t cx_buffer_append_string(CxBuffer *buffer, cxstring str);
 /**
 * Appends a string to a buffer with cxBufferAppend().
 *
 * @param buffer (@c CxBuffer*) the buffer
 * The current position of the buffer is increased after a successful read.
 *
 * @param buffer the buffer to read from
 * @return the character or @c EOF, if the end of the buffer is reached
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT int cxBufferGet(CxBuffer *buffer);
+int cxBufferGet(CxBuffer *buffer);
 /**
 * Gets the data in a buffer as a @c cxstring.
 *
 * @param buffer the buffer
 * @return the data in the buffer interpreted as a @c cxstring
 */
-CX_INLINE cxstring cx_bstr(CxBuffer *buffer) {
+CX_NONNULL CX_INLINE
+cxstring cx_bstr(CxBuffer *buffer) {
 return cx_strn(buffer->space, buffer->size);
 }
 /**
 * Gets the data in a buffer as a @c cxmutstr.
 *
 * @param buffer the buffer
 * @return the data in the buffer interpreted as a @c cxmutstr
 */
-CX_INLINE cxmutstr cx_bstr_m(CxBuffer *buffer) {
+CX_NONNULL CX_INLINE
+cxmutstr cx_bstr_m(CxBuffer *buffer) {
 return cx_mutstrn(buffer->space, buffer->size);
 }
-#ifdef __cplusplus
-}
-#endif
 #endif // UCX_BUFFER_H

Mercurial > hg > ucx / file comparison

comparison: src/cx/buffer.h

src/cx/buffer.h