fs/ut/fsStrUt.cpp

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*      [fsStrUt]         / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev.  7         / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    10th Jan 2007     /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [x] stable              /_/ (c) 2006-7 Filip STOKLAS (FipS)         */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~       http://HOLE.4FipS.com/fips_code.php          */
/*                                                                         */
/* This code is free for personal and commercial use. You may redistribute */
/* it by any means. If you use the code for your own projects please give  */
/* me credit. Please send a bug report. Don't alter or remove this header! */
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#include <fs/ut/fsStrUt.h>

// >>> COMMON SUPPORT BLOCK (rev. 6)
#if defined(FS_HAS_FSASSERT)
#   include <fs/sys/fsAssert.h>
#else
#   include <cassert>
#   if !defined(FS_ASSERT)
#       define FS_ASSERT(exp) assert(exp)
#   endif
#   if !defined(FS_ASSERT_MSG)
#       define FS_ASSERT_MSG(exp, msg) assert(exp && msg)
#   endif
#   if !defined(FS_VERIFY)
#       define FS_VERIFY(exp) \
        { bool bExp = !!(exp); assert(bExp && #exp); bExp; }
#   endif
#   if !defined(FS_VERIFY_MSG)
#       define FS_VERIFY_MSG(exp, msg) \
        { bool bExp = !!(exp); assert(bExp && #exp && msg); bExp; }
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char error[(exp) ? 1 : 0]; error; }
#   endif
#endif
#if !defined(FS_VERIFY_RETURN)
#   define FS_VERIFY_RETURN(exp) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<return>"); return; }
#endif
#if !defined(FS_VERIFY_RETURN_VAL)
#   define FS_VERIFY_RETURN_VAL(exp, ret) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<returns:>" #ret); return (ret); }
#endif
// <<< COMMON SUPPORT BLOCK (rev. 6)

#include <string>
#include <vector>
#include <map>
#include <algorithm>

// provide detailed memory tracking information
#if defined(FS_HAS_FSMEMMGR)
#   include <fs/sys/fsMemMgr.h>
#endif
//---------------------------------------------------------------------------
#if (_MSC_VER >= 1400) // MSVC8
#   pragma warning(disable : 4996) // function was marked as deprecated
#endif
//---------------------------------------------------------------------------
using namespace fs::ut::str;
//---------------------------------------------------------------------------
//--- FUNCTIONS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
char * fs::ut::str::Int2Str(int nVal, char *pszStr)
{
    FS_ASSERT(pszStr);

#if defined(UNDER_CE)
    return _itoa(nVal, pszStr, 10);
#else
    return ::itoa(nVal, pszStr, 10);
#endif
}
//---------------------------------------------------------------------------
void fs::ut::str::WStr2Str(const wchar_t *pwszWStr, char *pszStr)
{
    FS_VERIFY_RETURN(pwszWStr && pszStr);

    for(size_t i = 0, n = ::wcslen(pwszWStr) + 1; i < n; ++i)
        pszStr[i] = static_cast<char>(pwszWStr[i]);
}
//---------------------------------------------------------------------------
void fs::ut::str::Str2WStr(const char *pszStr, wchar_t *pwszWStr)
{
    FS_VERIFY_RETURN(pszStr && pwszWStr);

    for(size_t i = 0, n = ::strlen(pszStr) + 1; i < n; ++i)
        pwszWStr[i] = pszStr[i];
}
//---------------------------------------------------------------------------
// --- CLASS StrHldr_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
StrHldr_t::StrHldr_t(const char *pszStr):
m_pszStr(0)
{
    FS_VERIFY_RETURN(pszStr);
    
    const size_t nSize = ::strlen(pszStr) + 1;
    m_pszStr = new char[nSize];
    ::strcpy(m_pszStr, pszStr);
}
//---------------------------------------------------------------------------
StrHldr_t::StrHldr_t(const wchar_t *pwszWStr):
m_pszStr(0)
{
    FS_VERIFY_RETURN(pwszWStr);

    const size_t nSize = ::wcslen(pwszWStr) + 1;
    m_pszStr = new char[nSize];
    WStr2Str(pwszWStr, m_pszStr);
}
//---------------------------------------------------------------------------
StrHldr_t::~StrHldr_t()
{
    delete [] m_pszStr;
}
//---------------------------------------------------------------------------
const char * StrHldr_t::GetStr() const
{
    return m_pszStr;
}
//---------------------------------------------------------------------------
// WStrHldr_t
//---------------------------------------------------------------------------
WStrHldr_t::WStrHldr_t(wchar_t *pwszWStr):
m_pwszWStr(0)
{
    FS_VERIFY_RETURN(pwszWStr);

    const size_t nSize = ::wcslen(pwszWStr) + 1;
    m_pwszWStr = new wchar_t[nSize];
    ::wcscpy(m_pwszWStr, pwszWStr);
}
//---------------------------------------------------------------------------
WStrHldr_t::WStrHldr_t(const char *pszStr):
m_pwszWStr(0)
{
    FS_VERIFY_RETURN(pszStr);

    const size_t nSize = ::strlen(pszStr) + 1;
    m_pwszWStr = new wchar_t[nSize];
    Str2WStr(pszStr, m_pwszWStr);
}
//---------------------------------------------------------------------------
WStrHldr_t::~WStrHldr_t()
{
    delete [] m_pwszWStr;
}
//---------------------------------------------------------------------------
const wchar_t * WStrHldr_t::GetWStr() const
{
    return m_pwszWStr;
}
//---------------------------------------------------------------------------
//--- ANONYMOUS NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
namespace {
//---------------------------------------------------------------------------
//--- CLASS ToknzrImpl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
class ToknzrImpl_t
{
 public:
 
    ToknzrImpl_t(const char *pszText, const char *pszSprs, char chQuote);
    const char * Next();
 
 private:
 
     ToknzrImpl_t(); 
     ToknzrImpl_t(const ToknzrImpl_t &); 
     ToknzrImpl_t & operator = (const ToknzrImpl_t &); 
     
     //---
     
     const char *m_pszText;
     const char *m_pszSprs;
     const char m_chQuote;
     const size_t m_uLen;
     size_t m_uOff;
     std::vector<char> m_Tok;
};
//---------------------------------------------------------------------------
ToknzrImpl_t::ToknzrImpl_t(const char *pszText, const char *pszSprs,
 char chQuote):
m_pszText(pszText),
m_pszSprs(pszSprs),
m_chQuote(chQuote),
m_uLen(pszText ? ::strlen(pszText) : 0),
m_uOff(0)
{
    FS_VERIFY_RETURN(pszText && pszSprs);
}
//---------------------------------------------------------------------------
const char * ToknzrImpl_t::Next()
{
    if(m_uOff >= m_uLen) // nothing more to parse
        return 0;

    // find the beginning of the next token
    // (the first non-separator character - text or left quote)
    const char *pFrom = m_pszText + m_uOff;
    while(pFrom && ::strchr(m_pszSprs, *pFrom)) ++pFrom;
        
    if(!pFrom) // nothing found, there are only separators in the text
    {
        m_uOff = m_uLen; // move to the end, stop parsing
        return 0;
    }
    
    // find the end of current token
    // (right quote, separator or \0)
    const char *pTo = 0;
    if(pFrom < m_pszText + m_uLen)
    {
        if(*pFrom != m_chQuote) // normal token, stop at the next separator
        {
            pTo = pFrom + 1;
            while(pTo && !::strchr(m_pszSprs, *pTo)) ++pTo;
        }
        else // quoted token, stop at the right quote
        {
            pTo = ::strchr(++pFrom, m_chQuote);
        }
    }

    if(pTo) // the end of current token found, copy the token
    {
        const size_t uSize = pTo - pFrom; // doesn't incl. \0
        m_Tok.resize(uSize + 1); // incl. \0
        ::memcpy(&m_Tok[0], pFrom, uSize); // doesn't incl. \0
        m_Tok[uSize] = '\0';
        m_uOff = pTo - m_pszText + 1;
    }
    else // token ending not found, copy the remaining text
    {
        const size_t uSize = m_uLen - m_uOff + 1; // incl. \0
        m_Tok.resize(uSize);
        ::memcpy(&m_Tok[0], pFrom, uSize); // incl. \0
        m_uOff = m_uLen; // move to the end, stop parsing
    }

    FS_ASSERT(!m_Tok.empty());
    return &m_Tok[0];
}
//---------------------------------------------------------------------------
} // anonymous namespace
//---------------------------------------------------------------------------
//--- CLASS Toknzr_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
Toknzr_t::Toknzr_t(const char *pszText, const char *pszSprs, char chQuote):
m_pImpl(new ToknzrImpl_t(pszText, pszSprs, chQuote))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
Toknzr_t::~Toknzr_t()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    delete static_cast<ToknzrImpl_t *>(m_pImpl);
}
//---------------------------------------------------------------------------
const char * Toknzr_t::Next()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<ToknzrImpl_t *>(m_pImpl)->Next();
}
//---------------------------------------------------------------------------
//--- ANONYMOUS NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
namespace {
//---------------------------------------------------------------------------
//--- CLASS CmdLnImpl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
class CmdLnImpl_t
{
 public:
 
    explicit CmdLnImpl_t(const char *pszCmdLn);
    CmdLnImpl_t(int argc, char *argv[]);
    const char * GetVal(const char *pszKey) const;
    int GetNumToks() const;
    const char * GetTok(int nIdx) const;
    int FindTok(const char *pszTok) const;
         
 private:
 
    CmdLnImpl_t(); 
    CmdLnImpl_t(const CmdLnImpl_t &); 
    CmdLnImpl_t & operator = (const CmdLnImpl_t &); 
    
    void MapValsKeys();
    
    //---
    
    typedef std::vector<std::string> TToks;
    TToks m_Toks;
    
    typedef std::pair<std::string, int> TKey2ValPair;
    typedef std::map<std::string, int> TKey2ValMap;
    TKey2ValMap m_Key2ValMap; 
};
//---------------------------------------------------------------------------
CmdLnImpl_t::CmdLnImpl_t(const char *pszCmdLn)
{
    FS_VERIFY_RETURN(pszCmdLn);

    Toknzr_t Toknzr(pszCmdLn, " ");
    for(const char *pszTok = Toknzr.Next(); pszTok; pszTok = Toknzr.Next())
    {
        FS_ASSERT(pszTok);
        m_Toks.push_back(pszTok);
    }

    MapValsKeys();
}
//---------------------------------------------------------------------------
CmdLnImpl_t::CmdLnImpl_t(int argc, char *argv[])
{
    FS_VERIFY_RETURN(argc > 0 && argv);

    for(int i = 0; i < argc; ++i)
    {
        FS_ASSERT(argv[i]);
        m_Toks.push_back(argv[i]);
    }
    
    MapValsKeys();
}
//---------------------------------------------------------------------------
void CmdLnImpl_t::MapValsKeys()
{
    std::string strCurKey;
    
    for(int i = 0, n = static_cast<int>(m_Toks.size()); i < n; ++i)
    {
        // key: check the key format
        if(m_Toks[i].size() > 1 && m_Toks[i][0] == '-')
        {
            strCurKey = m_Toks[i].c_str() + 1;
        }
        // value: assign the value to the current key
        else if(!strCurKey.empty())
        {
            m_Key2ValMap.insert(TKey2ValPair(strCurKey, i));
            strCurKey.clear();
        }
    }
}
//---------------------------------------------------------------------------
const char * CmdLnImpl_t::GetVal(const char *pszKey) const
{
    FS_VERIFY_RETURN_VAL(pszKey, 0);
    
    const TKey2ValMap::const_iterator it = m_Key2ValMap.find(pszKey);
    return it != m_Key2ValMap.end() ? m_Toks[(*it).second].c_str() : 0;
}
//---------------------------------------------------------------------------
int CmdLnImpl_t::GetNumToks() const
{
    return static_cast<int>(m_Toks.size());
}
//---------------------------------------------------------------------------
const char * CmdLnImpl_t::GetTok(int nIdx) const
{
    FS_VERIFY_RETURN_VAL(nIdx >= 0 && nIdx < GetNumToks(), 0);
    
    return m_Toks[nIdx].c_str();
}
//---------------------------------------------------------------------------
int CmdLnImpl_t::FindTok(const char *pszTok) const
{
    FS_VERIFY_RETURN_VAL(pszTok, -1);
    
    const TToks::const_iterator it =
     std::find(m_Toks.begin(), m_Toks.end(), pszTok);
     
    return it != m_Toks.end() ? static_cast<int>(it - m_Toks.begin()) : -1;
}
//---------------------------------------------------------------------------
} // anonymous namespace
//---------------------------------------------------------------------------
//--- CLASS CmdLn_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
CmdLn_t::CmdLn_t(const char *pszCmdLn):
m_pImpl(new CmdLnImpl_t(pszCmdLn))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
CmdLn_t::CmdLn_t(int argc, char *argv[]):
m_pImpl(new CmdLnImpl_t(argc, argv))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
CmdLn_t::~CmdLn_t()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    delete static_cast<CmdLnImpl_t *>(m_pImpl);
}
//---------------------------------------------------------------------------
const char * CmdLn_t::GetVal(const char *pszKey) const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<CmdLnImpl_t *>(m_pImpl)->GetVal(pszKey);
}
//---------------------------------------------------------------------------
int CmdLn_t::GetNumToks() const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<CmdLnImpl_t *>(m_pImpl)->GetNumToks();
}
//---------------------------------------------------------------------------
const char * CmdLn_t::GetTok(int nIdx) const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<CmdLnImpl_t *>(m_pImpl)->GetTok(nIdx);
}
//---------------------------------------------------------------------------
int CmdLn_t::FindTok(const char *pszTok) const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<CmdLnImpl_t *>(m_pImpl)->FindTok(pszTok);
}
//---------------------------------------------------------------------------

---

FipS' Code (Thu Feb 15 22:43:35 2007) - (c) Filip STOKLAS (FipS) - [ www ] [ Guest Book ]