warcollector.cpp

ftpserver very good sample

        if (*p == 0)
            return 0;
    }
    
    return 0;
#endif
}

template <class charT>
int WarCollector<charT>::Stricmp(const char * right) const
{
    assert(sizeof(type_t) == sizeof(char));
    return ::stricmp((char *)mString.c_str(), right);
}

template <class charT>
int WarCollector<charT>::Stricmp(const wchar_t * right) const
{
    assert(sizeof(type_t) == sizeof(wchar_t));
    
#if defined(HAVE_WCSICMP) || defined(WIN32)
    return ::wcsicmp((wchar_t *)mString.c_str(), right);
#else
    const wchar_t *p = (const wchar_t *)mString.c_str();
    const wchar_t *pp = right;
    for(;; p++, pp++)
    {
        if (((*p & 0xff) == 0) && ((*pp & 0xff) == 0))
        {
            // We can compare case
            if (toupper(*p) != toupper(*pp))
            {
                if (toupper(*p) < toupper(*pp))
                    return -1;
                return 1;
            }
        }
        else
        {
            // We can't compare case!!
            if (*p != *pp)
            {
                if (*p < *pp)
                    return -1;
                return 1;
            }
        }
        
        if (*p == 0)
            return 0;
    }
    
    return 0;
#endif
}

template <class charT>
int WarCollector<charT>::Strcmp(const char * right) const
{
    assert(sizeof(type_t) == sizeof(char));
    return ::strcmp((char *)mString.c_str(), right);
}

template <class charT>
int WarCollector<charT>::Strcmp(const wchar_t * right) const
{
    assert(sizeof(type_t) == sizeof(wchar_t));
#if defined(WIN32) || defined(HAVE_WCSCMP)
    return ::wcscmp((wchar_t *)mString.c_str(), right);
#else
    const wchar_t *p = (const wchar_t *)mString.c_str();
    const wchar_t *pp = right;
    for(;; p++, pp++)
    {
        {
            if (*p != *pp)
            {
                if (*p < *pp)
                    return -1;
                return 1;
            }
        }
        
        if (*p == 0)
            return 0;
    }
    
    return 0;
#endif
}

template <class charT>
int WarCollector<charT>::Strncmp(const wchar_t * right, const size_t length) const
{
    assert(sizeof(type_t) == sizeof(wchar_t));
#if defined(WIN32) || defined(HAVE_WCSNCMP)
    return ::wcsncmp((wchar_t *)mString.c_str(), right, length);
#else
    const wchar_t *p = (const wchar_t *)mString.c_str();
    const wchar_t *pp = right;
    for(size_t index = 0; index < length; index++, p++, pp++)
    {
        {
            if (*p != *pp)
            {
                if (*p < *pp)
                    return -1;
                return 1;
            }
        }
        
        if (*p == 0)
            return 0;
    }
    
    return 0;
#endif
}


/////////////////////////////// PROTECTED  ///////////////////////////////////

/////////////////////////////// PRIVATE    ///////////////////////////////////

/* EXTERNAL REFERENCES */
/** */

WarCollector<char>& operator << (WarCollector<char>& c, 
                                 const struct in_addr& val)
{
    const unsigned char *pbytes = (const unsigned char *)&val;
    
    return c << (war_uint32_t)pbytes[0] << '.' 
        << (war_uint32_t)pbytes[1] << '.' 
        << (war_uint32_t)pbytes[2] << '.' 
        << (war_uint32_t)pbytes[3];
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                           const char val)
{
    if (c.MustErase() && !c.mString.empty())
    {
        size_t str_len = c.mString.size();
        size_t len = str_len + 1 + 1;
        char *buf = (char *)alloca(len);
        memcpy(buf, c.mString.c_str(), str_len);
        buf[str_len] = val;
        buf[len -1] = 0;
        c.Reset();
        c.mString = buf;
        memset(buf, 0, len);
    }
    else
        c.mString += val;

    return c;
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           const wchar_t val)
{
    if (c.MustErase() && !c.mString.empty())
    {
        size_t str_len = c.mString.size();
        size_t len = str_len + 1 + 1;
        wchar_t *buf = (wchar_t *)alloca(len * sizeof(wchar_t));
        memcpy(buf, c.mString.c_str(), str_len * sizeof(wchar_t));
        buf[str_len] = val;
        buf[len -1] = 0;
        c.Reset();
        c.mString = buf;
        memset(buf, 0, len * sizeof(wchar_t));
    }
    else
        c.mString += val;
    return c;
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                           const wchar_t val)
{
    char ch = 0;

#if HAVE_VCRTOMB
    mbstate_t state;
    memset(&state, 0, sizeof(state));
    if (mbsinit(&state))
        WarThrow(WarSystemError(), "mbsinit()");

    if (::wcrtomb(&ch, val, &state) != 1)
        WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
#else
    if (::wctomb(&ch, val) != 1)
        WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
#endif
    return c << ch;
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           const char val)
{
    wchar_t wc = 0;

#if HAVE_MBRTOWC
    mbstate_t state;
    memset(&state, 0, sizeof(state));
    if (mbsinit(&state))
        WarThrow(WarSystemError(), "mbsinit()");

    if (::mbrtowc(&wc, &val, 1, &state) != 1)
        WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
#else
    if (::mbtowc(&wc, &val, 1) != 1)
        WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
#endif
    return c << wc;
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                           const war_ccstr_t val)
{
    if (val && *val)
    {
        if (c.MustErase() && !c.mString.empty())
        {
            size_t str_len = c.mString.size();
            size_t new_str_len = strlen(val);
            size_t len = str_len + new_str_len + 1;
            char *buf = (char *)alloca(len * sizeof(char));
            memcpy(buf, c.mString.c_str(), str_len * sizeof(char));
            memcpy(buf + str_len, val, new_str_len * sizeof(char));
            buf[len -1] = 0;
            c.Reset();
            c.mString = buf;
            memset(buf, 0, len * sizeof(wchar_t));
        }
        else
            c.mString += val;
    }
    return c;
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                                 war_cwstr_t val)
{
    if (val && *val)
    {
        size_t buflen = ::wcstombs(NULL, val, 0);
        int result = 0;
        if (buflen)
        {
            std::vector<char> buf(buflen +1);
            char *pbuf = (char *)&buf[0];
#if HAVE_WCSRTOMBS
            mbstate_t state;
            memset(&state, 0, sizeof(state));
            if (mbsinit(&state))
                WarThrow(WarSystemError(), "mbsinit()");
            if ((result = ::wcsrtombs(pbuf, &val, buflen +1, &state)) > 0)
                c << pbuf;
#else
            if ((result = ::wcstombs(pbuf, val, buflen +1)) > 0)
                c << pbuf;
#endif
            if (c.MustErase())
                memset(&buf[0], 0, buf.size());
        }

        if (!result)
            WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
    }
    return c;
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           war_ccstr_t val)
{
    if (val && *val)
    {
        size_t buflen = ::mbstowcs(NULL, val, 0);
        int result = 0;
        if (buflen)
        {
            std::vector<wchar_t> buf(buflen +1);
            wchar_t *pbuf = (wchar_t *)&buf[0];

#if HAVE_MBSRTOWCS
            mbstate_t state;
            memset(&state, 0, sizeof(state));
            if (mbsinit(&state))
                WarThrow(WarSystemError(), "mbsinit()");

            if ((result = ::mbsrtowcs(pbuf, &val, buflen +1, &state)) > 0)
                c << pbuf;
#else
            if ((result = ::mbstowcs(pbuf, val, buflen +1)) > 0)
                c << pbuf;
#endif
            if (c.MustErase())
                memset(&buf[0], 0, buf.size() * sizeof(wchar_t));
        }

        if (!result)
            WarThrow(WarError(WAR_CHRCNV_NO_CONVERSION), NULL);
    }
    return c;
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           const war_cwstr_t val)
{
    if (val && *val)
    {
        if (c.MustErase() && !c.mString.empty())
        {
            size_t str_len = c.mString.size();
            size_t new_str_len = wcslen(val);
            size_t len = str_len + new_str_len + 1;
            wchar_t *buf = (wchar_t *)alloca(len * sizeof(wchar_t));
            memcpy(buf, c.mString.c_str(), str_len * sizeof(wchar_t));
            memcpy(buf + str_len, val, new_str_len * sizeof(wchar_t));
            buf[len -1] = 0;
            c.Reset();
            c.mString = buf;
            memset(buf, 0, len * sizeof(wchar_t));
        }
        else
            c.mString += val;
    }
    return c;
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                           const std::string& val)
{
    if (c.MustErase() && !c.mString.empty())
        return c << val.c_str();

    c.mString += val;
    return c;
}

WarCollector<char>& operator << (WarCollector<char>& c, 
                           const std::wstring& val)
{
    return c << val.c_str();
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           const std::string& val)
{
    return c << val.c_str();
}

WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, 
                           const std::wstring& val)
{
    if (c.MustErase() && !c.mString.empty())
        return c << val.c_str();

    c.mString += val;
    return c;
}