warcollector.cpp

ftpserver very good sample

#include "StdAfx.h"
#include <strstream>

#include "WarCollector.h"   // class implemented

/////////////////////////////// PUBLIC ///////////////////////////////////////

WAR_CPPT_IMPL WarCollector<char>;
WAR_CPPT_IMPL WarCollector<wchar_t>;

WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_int32_t val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_int32_t val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_int64_t& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_int64_t& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_uint16_t val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_uint16_t val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_uint32_t val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_uint32_t val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_uint64_t& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_uint64_t& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const WarCollector<char>& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const WarCollector<wchar_t>& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const WarCollector<char>& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const WarCollector<wchar_t>& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_endl_e& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_endl_e& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const WarError& val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const WarError& val);
WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const war_int16_t val);
WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const war_int16_t val);

#if defined(NEED_TYPE_TEMPLATE) || defined(_MSC_VER)
    WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const int val);
    WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const int val);
    WAR_CPPTF_IMPL WarCollector<char>& operator << (WarCollector<char>& c, const unsigned val);
    WAR_CPPTF_IMPL WarCollector<wchar_t>& operator << (WarCollector<wchar_t>& c, const unsigned val);
#endif

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_int32_t val)
{
    return c.AddInt32(val);
}

#if defined(NEED_TYPE_TEMPLATE) || defined(_MSC_VER)
template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const int val)
{
    return c.AddInt32(val);
}
#endif

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_int64_t& val)
{
    return c.AddInt64(val);
}

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_uint16_t val)
{
    return c.AddInt32u(val);
}

#if defined(NEED_TYPE_TEMPLATE) || defined(_MSC_VER)
template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const unsigned val)
{
    return c.AddInt32u(val);
}
#endif

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_uint32_t val)
{
    return c.AddInt32u(val);
}

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_uint64_t& val)
{
    return c.AddInt64u(val);
}

template <class charT, class collT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                                  const WarCollector<collT>& val)
{
    c << val.GetValue();
    return c;
}

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_endl_e& val)
{
    return c.AddEndln(val);
}

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const WarError& val)
{
    return c.AddError(val);
}

template <class charT>
WarCollector<charT>& operator << (WarCollector<charT>& c, 
                           const war_int16_t val)
{
    return c.AddInt16(val);
}

//============================= LIFECYCLE ====================================

template <class charT>
WarCollector<charT>::WarCollector<charT>(const SecurityModeE securityMode)
: mSecurityMode(securityMode)
{}

template <class charT>
WarCollector<charT>::~WarCollector<charT>(void)
{
    Reset();
}

//============================= OPERATORS ====================================

template <class charT>
WarCollector<charT>& WarCollector<charT>::operator=(std::string& from)
{
    Reset();
    return *this << from;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::operator=(war_ccstr_t from)
{
    Reset();
    return *this << from;
}

template <class charT>
bool WarCollector<charT>::operator == (const charT *strName)
{
    return mString == std::basic_string<charT>(strName);
}


//============================= OPERATIONS ===================================

template <class charT>
void WarCollector<charT>::ExpandNewline() 
{
#ifdef WIN32
    charT *newbuf = (charT *)alloca(mString.size() * 2 * sizeof(charT));
    const charT *p = mString.c_str();
    charT *pp = newbuf;
    bool have_nl = false;
    
    while(*p)
    {
        if (*p == '\n')
        {
            have_nl = true;
            *pp++ = '\r';
        }
        *pp++ = *p++;
    }
    
    if (have_nl)
    {
        *pp = 0;
        Reset();
        mString = newbuf;
    }
#endif // WIN32
}

template <class charT>
void WarCollector<charT>::Reset()
{
    if (MustErase() && !mString.empty())
    {
        memset(&mString[0], 
            0, 
            mString.size() * sizeof(charT));
    }
    mString.erase();
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddEndln(const war_endl_e& from) 
{
    Add((char)from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddError(const WarError& from) 
{
    *this << from.Explain();
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddEnumValue1(int enumValue)
throw(WarException)
{
    WarThrow(WarError(WAR_ERR_NOT_IMPLEMENTED), NULL);
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddEnumValue2(int enumValue)
throw(WarException)
{
    WarThrow(WarError(WAR_ERR_NOT_IMPLEMENTED), NULL);
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddEnumValue3(int enumValue)
throw(WarException)
{
    WarThrow(WarError(WAR_ERR_NOT_IMPLEMENTED), NULL);
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddEnumValue4(int enumValue)
throw(WarException)
{
    WarThrow(WarError(WAR_ERR_NOT_IMPLEMENTED), NULL);
}


//============================= ACCESS      ===================================

template <class charT>
const std::basic_string<charT>& WarCollector<charT>::GetValue() const 
{
    return mString;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::Add(const std::basic_string<charT>& from)
{
     mString += from;
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::Add(const charT * from)
{
    if (from && *from)
        mString += from;
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::Add(const charT from)
{
    mString += from;
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt16(const war_int16_t& from)
{
    WarItoa(mString, from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt32(const war_int32_t& from)
{
    WarItoa(mString, from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt64(const war_int64_t& from)
{
    WarItoa(mString, from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt16u(const war_uint16_t& from)
{
    WarItoa(mString, from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt32u(const war_uint32_t& from)
{
    WarItoa(mString, from);
    return *this;
}

template <class charT>
WarCollector<charT>& WarCollector<charT>::AddInt64u(const war_uint64_t& from)
{
    WarItoa(mString, from);
    return *this;
}


//============================= INQUIRY    ===================================

template <class charT>
bool WarCollector<charT>::MustErase() const
{
    return mSecurityMode > SM_NONE;
}

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

template <class charT>
int WarCollector<charT>::Strnicmp(const wchar_t * right, size_t length) const
{
    assert(sizeof(type_t) == sizeof(wchar_t));
#ifdef HAVE_WCSNICMP
    return ::wcsnicmp((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 & 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;
            }
        }