BufPrint.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Embedded Web-Server 
 ****************************************************************************
 *            HEADER
 *
 *   $Id: BufPrint.h 5839 2026-07-29 13:27:22Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2008 - 2026
 *
 *   This software is copyrighted by and is the sole property of Real
 *   Time Logic LLC.  All rights, title, ownership, or other interests in
 *   the software remain the property of Real Time Logic LLC.  This
 *   software may only be used in accordance with the terms and
 *   conditions stipulated in the corresponding license agreement under
 *   which the software has been supplied.  Any unauthorized use,
 *   duplication, transmission, distribution, or disclosure of this
 *   software is expressly forbidden.
 *                                                                        
 *   This Copyright notice may not be removed or modified without prior
 *   written consent of Real Time Logic LLC.
 *                                                                         
 *   Real Time Logic LLC. reserves the right to modify this software
 *   without notice.
 *
 *               http://www.realtimelogic.com
 ****************************************************************************
 *
 */
 
#ifndef __BufPrint_h
#define __BufPrint_h
 
#include <TargConfig.h>
 
#ifndef BA_API
#define BA_API
#endif
 
#include <stdarg.h>
#include <string.h>
 
struct BufPrint;
 
#ifdef __cplusplus
extern "C" {
#endif
 
BA_API int basprintf(char* buf, const char* fmt, ...);
 
BA_API int basnprintf(char* buf, int len, const char* fmt, ...);
 
#ifdef __cplusplus
#undef printf
}
#endif 
 
typedef int (*BufPrint_Flush)(struct BufPrint* o, int sizeRequired);
 
typedef struct BufPrint
{
#ifdef __cplusplus
 
      BufPrint(void* userData=0, BufPrint_Flush flush=0);
 
   BufPrint(char* buf,int size,void* userData=0,BufPrint_Flush flush=0);
 
      void* getUserData();
 
      int vprintf(const char* fmt, va_list argList);
 
      int printf(const char* fmt, ...);
 
      int baputc(int c);
 
      int write(const void* data, int len);
 
      int write(const char* buf);
 
 
   void setBuf(char* buf, int size);
 
 
      char* getBuf();
 
      U32 getBufSize();
 
 
      void erase();
 
      int flush();
 
      int b64Encode(const void* data, S32 slen);
 
   int b64urlEncode(const void* source, S32 slen, bool padding);
 
      int jsonString(const char* str, size_t len);
#endif
      BufPrint_Flush flushCB;
      void *userData;
      char* buf;
      int cursor;
      int bufSize;
}BufPrint;
 
#define BufPrint_putcMacro(o, c) do { \
   if((o)->cursor == (o)->bufSize) \
   { \
      if((o)->flushCB(o, 1)) \
         return -1; \
   } \
   (o)->buf[(o)->cursor++] = c; \
} while(0)
 
#ifdef __cplusplus
extern "C" {
#endif
#define BufPrint_getUserData(o) (o)->userData
#define BufPrint_erase(o) (o)->cursor=0
#define BufPrint_getBuf(o) (o)->buf
#define BufPrint_setBuf(o, b, size) (o)->buf=b,(o)->bufSize=size,(o)->cursor=0
#define BufPrint_getBufSize(o) (o)->cursor
BA_API void BufPrint_constructor(
   BufPrint* o,void* userData,BufPrint_Flush flush);
BA_API void BufPrint_constructor2(
   BufPrint* o, char* buf,int size,void* userData,BufPrint_Flush flush);
#define BufPrint_destructor(o)
BA_API int BufPrint_vprintf(BufPrint* o, const char* fmt, va_list argList);
BA_API int BufPrint_printf(BufPrint* o, const char* fmt, ...);
BA_API int BufPrint_write(BufPrint* o, const void* data, int len);
BA_API int BufPrint_putc(BufPrint* o, int c);
BA_API int BufPrint_flush(BufPrint* o);
#define BufPrint_write2(o, data) BufPrint_write(o, data, -1)
BA_API int BufPrint_b64Encode(BufPrint* o, const void* source, S32 slen);
BA_API int BufPrint_b64urlEncode(
   BufPrint* o, const void* source, S32 slen, BaBool padding);
 
BA_API int BufPrint_jsonString(BufPrint* o, const char* str, size_t len);
#ifdef __cplusplus
}
inline void* BufPrint::getUserData() {
   return BufPrint_getUserData(this);
}
inline BufPrint::BufPrint(void* userData, BufPrint_Flush flush) {
   BufPrint_constructor(this, userData,flush); }
inline BufPrint::BufPrint(
   char* buf,int size,void* userData,BufPrint_Flush flush) {
   BufPrint_constructor2(this,buf,size,userData,flush); }
inline int BufPrint::vprintf(const char* fmt, va_list argList) {
   return BufPrint_vprintf(this, fmt, argList); }
inline int BufPrint::printf(const char* fmt, ...) {
   int retv; va_list varg;
   va_start(varg, fmt);
   retv = BufPrint_vprintf(this, fmt, varg);
   va_end(varg);
   return retv;
}
inline char* BufPrint::getBuf() {
   return BufPrint_getBuf(this); }
inline void BufPrint::setBuf(char* buffer, int size) {
   BufPrint_setBuf(this, buffer, size); }
inline U32 BufPrint::getBufSize() {
   return BufPrint_getBufSize(this); }
inline void BufPrint::erase() {
   BufPrint_erase(this); }
inline int BufPrint::baputc(int c) {
   return BufPrint_putc(this, c); }
inline int BufPrint::write(const void* data, int len) {
   return BufPrint_write(this, data, len); }
inline int BufPrint::write(const char* data) {
   return BufPrint_write2(this, data); }
inline int BufPrint::flush() {
   return BufPrint_flush(this);
}
inline int BufPrint::b64Encode(const void* source, S32 slen){
   return BufPrint_b64Encode(this, source, slen);
}
inline int BufPrint::b64urlEncode(const void* source, S32 slen, bool padding){
   return BufPrint_b64urlEncode(this, source, slen, padding?TRUE:FALSE);
}
inline int BufPrint::jsonString(const char* str, size_t len){
   return BufPrint_jsonString(this, str, len);
}
#endif
 /* end of BufPrint */
 
 
#endif