BUFFER_T Struct Reference

#include <__STRING.h>

Public Member Functions
CHAR_T *	data ()
long	addRef ()
long	release ()

Static Public Member Functions
static void	destroy (BUFFER_T *_buf)
static BUFFER_T *	create (size_t _len)
static BUFFER_T *	create_e (size_t _len)
static void	extend (BUFFER_T *&_buf, size_t _len)
static void	shrink (BUFFER_T *&_buf)
static void	write (BUFFER_T *&_buf, const CHAR_T *_str, size_t _len)
static void	write (BUFFER_T *&_buf, CHAR_T _ch)
static int	vformat (BUFFER_T *&_buf, const CHAR_T *_format, va_list _arglist)

Public Attributes
volatile long	__refCount
size_t	__allocLength
size_t	__dataLength

Detailed Description

Definition at line 30 of file __STRING.h.

Member Function Documentation

addRef()

long BUFFER_T::addRef

(

)

Definition at line 96 of file __STRING.cpp.

{
    long n = Thread::incrementAndGet(__refCount);
    return n;
}

create()

BUFFER_T * BUFFER_T::create ( size_t _len )

static

Definition at line 149 of file __STRING.cpp.

{
    BUFFER_T* buf = (BUFFER_T*)
        malloc(sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
    if (buf) {
        buf->__refCount = 1;
        buf->__allocLength = _len;
        buf->__dataLength = 0;
        buf->data()[buf->__dataLength] = _T('\0');
    }
    /*
    else {
        throw BadAllocException
    }
    */
    return buf;
}

create_e()

BUFFER_T * BUFFER_T::create_e ( size_t _len )

static

Definition at line 168 of file __STRING.cpp.

{
    return BUFFER_T::create(__extended_length(_len));
}

data()

CHAR_T * BUFFER_T::data ( )

inline

Definition at line 36 of file __STRING.h.

{ return (CHAR_T*)(this + 1); }

destroy()

void BUFFER_T::destroy ( BUFFER_T * _buf )

static

Definition at line 141 of file __STRING.cpp.

{
    free(_buf);
}

extend()

void BUFFER_T::extend ( BUFFER_T *& _buf, size_t _len )

static

Definition at line 173 of file __STRING.cpp.

{
    __DCL_ASSERT_PARAM(_buf != NULL);
    __DCL_ASSERT_PARAM(_buf->__allocLength < _len);
 
    _len = __extended_length(_len);
 
    BUFFER_T* buf = (BUFFER_T*)
        realloc(_buf, sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
    // buf와 _buf는 같지 않을 수 있다.
    if (buf) {
        _buf = buf;
        _buf->__allocLength = _len;
    }
    /*
    else {
        throw BadAllocException
    }
    */
}

release()

long BUFFER_T::release

(

)

Definition at line 102 of file __STRING.cpp.

{    
    __DCL_ASSERT_PARAM(__refCount > 0);    // __DCL_ASSERT_VALID(this);
    long n = Thread::decrementAndGet(__refCount);
    if (n == 0)
        BUFFER_T::destroy(this);
    return n;
}

shrink()

void BUFFER_T::shrink ( BUFFER_T *& _buf )

static

Definition at line 195 of file __STRING.cpp.

{
    __DCL_ASSERT_PARAM(_buf != NULL);
    if (_buf->__dataLength < _buf->__allocLength) {
        size_t _len = _buf->__dataLength;
        BUFFER_T* buf = (BUFFER_T*)
            realloc(_buf, sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
        if (buf) {
            _buf = buf;
            _buf->__allocLength = _len;
            _buf->data()[_buf->__dataLength] = _T('\0');
        }
        else {
            // throw new BadAllocException
        }
    }
}

vformat()

int BUFFER_T::vformat ( BUFFER_T *& _buf, const CHAR_T * _format, va_list _arglist )

static

Definition at line 230 of file __STRING.cpp.

{
    __DCL_ASSERT_PARAM(_format != NULL);
 
#if defined(__DCL_COMPILE_UNICODE__) && defined(_MSC_VER)
    String format;
    if (STRSTR(_format, L"%s")) {
        __DCL_TRACE3(L"Warning!! vformat _format [%ls] included [%ls]. replaced to [%ls]\n",
            _format, L"%s", L"%hs");
        format.assign(_format);
        format = format.replace(L"%s", L"%hs");
        _format = format;
    }
#endif
 
#define __EXTENDED_MAX  1024 * 1024
#define __EXTEND_MIN    32
    int n = 0;
    size_t extend =  __MAX(_buf->__allocLength - _buf->__dataLength, __EXTEND_MIN);
    size_t extended = _buf->__dataLength + extend;
    while (extended < __EXTENDED_MAX) {
        if (_buf->__allocLength < extended) {
            BUFFER_T::extend(_buf, extended);
        }
 
        va_list arglist;
        va_copy(arglist, _arglist);
        n = VSNPRINTF(
            _buf->data() + _buf->__dataLength,
            _buf->__allocLength - _buf->__dataLength,
            _format,
            arglist
        );
        va_end(arglist);
 
        // 버퍼가 부족한 경우, MSVC는 -1을 반환한다.
        // GNUC는 버퍼의 size로 문자열이 잘려지고, 만들어진 문자의 개수를 반환한다.
        // GNUC의 경우 arg 중 하나라도 문자열의 길이가 버퍼보다 길면 -1을 반환한다.
        if (0 <= n && (size_t)n <= (_buf->__allocLength - _buf->__dataLength)) {
            _buf->__dataLength += n;
            _buf->data()[_buf->__dataLength] = _T('\0');
            return n;
        }
 
        extend *= 2;
        if (n > 0) {
            extend = __MAX(extend, n);
        }        
        extended += extend;
        __DCL_TRACE2(__T("VSNPRINTF Failed(%d) extend[%zd] and Retry\n"), n, extend);
    }
    // throw new BadAllocException;
 
    // EXTEND_MAX 10MB 만큼 버퍼를 할당했음에도 불구하고 VSNPRINTF를 실패했다.
    __DCL_TRACE2(__T("Warning!! VSNPRINTF Failed(%d) extend[%zd]\n"), n, extend);
    return n;
}

write() [1/2]

void BUFFER_T::write ( BUFFER_T *& _buf, CHAR_T _ch )

static

Definition at line 225 of file __STRING.cpp.

{
    write(_buf, &_ch, 1);
}

write() [2/2]

void BUFFER_T::write ( BUFFER_T *& _buf, const CHAR_T * _str, size_t _len )

static

Definition at line 214 of file __STRING.cpp.

{
    size_t avail = _buf->__allocLength - _buf->__dataLength;
    if (avail < _len) {
        BUFFER_T::extend(_buf, _buf->__allocLength + _len);
    }
    memcpy(_buf->data() + _buf->__dataLength, _p, _len * sizeof(CHAR_T));
    _buf->__dataLength += _len;
    _buf->data()[_buf->__dataLength] = _T('\0');
}

Member Data Documentation

__allocLength

size_t BUFFER_T::__allocLength

Definition at line 33 of file __STRING.h.

__dataLength

size_t BUFFER_T::__dataLength

Definition at line 34 of file __STRING.h.

__refCount

volatile long BUFFER_T::__refCount

Definition at line 32 of file __STRING.h.

---

The documentation for this struct was generated from the following files:

• __STRING.h
• __STRING.cpp