stringlist.h

Go to the documentation of this file.

#pragma once
 
namespace A_UTILS_NS
{

template<class storageT>
class string_list_base
{
    public:
        typedef string_list_base<storageT> _myType;
        typedef std::vector<storageT> tStringList;
        typedef typename tStringList::const_iterator const_iterator;
        typedef typename tStringList::const_reverse_iterator const_reverse_iterator;
        typedef typename tStringList::iterator iterator;
        typedef typename tStringList::reverse_iterator reverse_iterator;

        static const tSize InvalidPos = g_npos;
 
    protected:
        tStringList         m_lstList;
 
    public:
        iterator begin()
        {
            return m_lstList.begin();
        }

        iterator end()
        {
            return m_lstList.end();
        }

        const_iterator begin() const
        {
            return m_lstList.cbegin();
        }

        const_iterator end() const
        {
            return m_lstList.cend();
        }

        const_iterator cbegin() const
        {
            return m_lstList.cbegin();
        }

        const_iterator cend() const
        {
            return m_lstList.cend();
        }

        reverse_iterator rbegin()
        {
            return m_lstList.rbegin();
        }

        reverse_iterator rend()
        {
            return m_lstList.rend();
        }

        const_reverse_iterator crbegin() const
        {
            return m_lstList.crbegin();
        }

        const_reverse_iterator crend() const
        {
            return m_lstList.crend();
        }

        string_list_base()
        {
        }

        string_list_base(const _myType& lstList)
        {
            Copy(lstList);
        }

        string_list_base(_myType&& lstList)
        {
            //@TODO: Could also move
            Copy(lstList);
        }

        string_list_base(const storageT& strList)
        {
            _myType lstList;
 
            tSize nTokenLen = 1;
            tSize nPos = cString::InvalidPos;
            tSize nPosComma = cString::InvalidPos;
            tSize nPosSemicolon = cString::InvalidPos;
            tSize nStartPos;
 
            do
            {
                nStartPos = nPos + 1;
                nPosComma = strList.Find(",", nStartPos);
                nPosSemicolon = strList.Find(";", nStartPos);
 
                if (cString::InvalidPos != nPosComma && cString::InvalidPos != nPosSemicolon)
                {
                    nPosComma < nPosSemicolon ? nPos = nPosComma : nPos = nPosSemicolon;
                }
                else if (cString::InvalidPos != nPosSemicolon)
                {
                    nPos = nPosSemicolon;
                }
                else
                {
                    nPos = nPosComma;
                }
 
                if (nPos != cString::InvalidPos)
                {
                    if (nPos != 0)
                    {
                        lstList.m_lstList.emplace_back(strList.Mid(nStartPos, nPos - nStartPos));
                    }
                    else
                    {
                        lstList.m_lstList.emplace_back(storageT(""));
                    }
                    nPos += nTokenLen - 1;
                }
                else
                {
                    if (nStartPos < strList.GetLength())
                    {
                        lstList.m_lstList.emplace_back(strList.Mid(nStartPos));
                    }
                    else if (strList.EndsWith(",") || strList.EndsWith(";"))
                    {
                        lstList.m_lstList.emplace_back(storageT(""));
                    }
                    break;
                }
            } while (nPos != cString::InvalidPos);
 
            Copy(lstList);
        }
 
        string_list_base(std::initializer_list<storageT> lstStrings)
        {
            for (const auto& itElem : lstStrings)
            {
                Append(itElem);
            }
        }

        string_list_base& operator=(const _myType& lstList)
        {
            Copy(lstList);
            return *this;
        }

        string_list_base& operator=(_myType&& lstList)
        {
            //@TODO: could be moved!!
            Copy(lstList);
            return *this;
        }

        virtual ~string_list_base()
        {
            Clear();
        }

        tVoid Copy(const _myType& lstList)
        {
            Clear();
            m_lstList = lstList.m_lstList;
        }

        tVoid Clear()
        {
            if (m_lstList.size() > 0)
            {
                m_lstList.clear();
            }
        }

        tResult Append(const storageT& strString)
        {
            m_lstList.push_back(strString);
            RETURN_NOERROR;
        }

        tResult Append(const _myType& lstString)
        {
            auto oIt = lstString.cbegin();
            for (;
                 oIt != lstString.cend();
                 oIt++)
            {
                Append(*oIt);
            }
 
            RETURN_NOERROR;
        }

        tResult Add(const storageT& strString)
        {
            if (InvalidPos != Find(strString))
            {
                RETURN_ERROR(ERR_FAILED);
            }
 
            Append(strString);
            RETURN_NOERROR;
        }

        tResult Add(const _myType& lstString)
        {
            tInt nAddedCount = 0;
            for (auto it = lstString.begin();
                it != lstString.end();
                it++)
            {
                if (IS_OK(Add(*it)))
                {
                    nAddedCount++;
                }
            }
 
            if (nAddedCount > 0)
            {
                RETURN_NOERROR;
            }
            else
            {
                RETURN_ERROR(ERR_FAILED);
            }
        }

        tResult Insert(tSize nIdx, const storageT& strString)
        {
            if (nIdx < m_lstList.size())
            {
                m_lstList.insert(m_lstList.begin() + nIdx, strString);
                RETURN_NOERROR;
            }
            else
            {
                RETURN_ERROR(ERR_INVALID_INDEX);
            }
        }

        tResult Delete(tSize nIdx)
        {
            if (nIdx < m_lstList.size())
            {
                m_lstList.erase(m_lstList.begin() + nIdx);
            }
            else
            {
                RETURN_ERROR(ERR_INVALID_INDEX);
            }
            return ERR_NOERROR;
        }

        static tBool fnSortLexically(const storageT& strFirst, const storageT& strSecond)
        {
            if (0 > strFirst.CompareNoCase(strSecond))
            {
                return tTrue;
            }
            else
            {
                return tFalse;
            }
        }

        tVoid Sort(tBool bIgnoreCase = tFalse)
        {
            if (!bIgnoreCase)
            {
                std::sort(m_lstList.begin(), m_lstList.end());
            }
            else
            {
                std::sort(m_lstList.begin(), m_lstList.end(), fnSortLexically);
            }
        }

        tSize GetItemCount() const
        {
            return m_lstList.size();
        }

        const storageT& Get(tSize nIdx, const storageT& strDefault = "") const
        {
            if (nIdx < GetItemCount())
            {
                const storageT& strRet = m_lstList[nIdx];
                return strRet;
            }
            return strDefault;
        }

        tResult Set(tSize nIdx, const storageT& strValue)
        {
            if (InvalidPos == nIdx)
            {
                return ERR_INVALID_ARG;
            }
            else if (nIdx < GetItemCount())
            {
                m_lstList[nIdx] = strValue;
            }
            else
            {
                m_lstList.push_back(strValue);
            }
            RETURN_NOERROR;
        }

        tSize Find(const storageT& strString) const
        {
            const_iterator it = std::find(cbegin(), cend(), strString);
            if (it != cend())
            {
                return std::distance(cbegin(), it);
            }
            else
            {
                return InvalidPos;
            }
        }

        tSize Match(const storageT& strPattern) const
        {
            tSize nMatchType = 0; // exact
            tSize nStart = 0;
            tSize nLen = strPattern.GetLength();
 
            if (!strPattern.IsEmpty())
            {
                const tChar* ptr = strPattern.GetPtr();
                if (*ptr == '*')
                {
                    nMatchType |= 1;
                    nStart = 1;
                    nLen--;
                }
 
                if (*(ptr + strPattern.GetLength() - 1) == '*')
                {
                    nMatchType |= 2;
                    nLen--;
                }
            }
 
            if (nMatchType == 0)
            {
                return Find(strPattern);
            }
 
            storageT strSubStr = strPattern.Mid(nStart, nLen);
 
            storageT strItem;
            tSize l_nIdx = 0;
            typename tStringList::const_iterator l_poI;
            for (l_poI = m_lstList.begin(); l_poI != m_lstList.end(); ++l_poI)
            {
                if (nMatchType == 1)
                {
                    // search for "*text"
                    strItem = (*l_poI).Right(nLen);
                    if (strItem.IsEqual(strSubStr))
                    {
                        return l_nIdx;
                    }
                }
                else if (nMatchType == 2)
                {
                    // search for "text*"
                    strItem = (*l_poI).Left(nLen);
                    if (strItem.IsEqual(strSubStr))
                    {
                        return l_nIdx;
                    }
                }
                else if (nMatchType == 3)
                {
                    // search for "*text*"
                    strItem = (*l_poI).Mid(nStart, nLen);
                    if (strItem.Find(strSubStr) != cString::InvalidPos)
                    {
                        return l_nIdx;
                    }
                }
 
                l_nIdx++;
            }
            return InvalidPos;
        }

        tSize FindNoCase(const storageT& strString) const
        {
            //@TODO: could also use std::find_if
            tSize l_nIdx = 0;
            typename tStringList::const_iterator l_poI;
            for (l_poI = m_lstList.begin(); l_poI != m_lstList.end(); ++l_poI)
            {
                if (strString.CompareNoCase(*l_poI) == 0)
                {
                    return l_nIdx;
                }
                l_nIdx++;
            }
            return InvalidPos;
        }

        storageT Join(const storageT& strSeparator) const
        {
            storageT l_strString;
            tBool bFirst = tTrue;
 
            typename tStringList::const_iterator l_poI;
            for (l_poI = m_lstList.begin(); l_poI != m_lstList.end(); ++l_poI)
            {
                if (!bFirst)
                {
                    l_strString.Append(strSeparator);
                }
                else
                {
                    bFirst = false;
                }
 
                l_strString.Append(*l_poI);
            }
 
            return l_strString;
        }

        tBool IsEmpty() const
        {
            return m_lstList.empty();
        }

        storageT& operator[](tSize nIdx)
        {
            return m_lstList[nIdx];
        }

        const storageT& operator[](tSize nIdx) const
        {
            return m_lstList[nIdx];
        }
 
        bool operator==(const _myType& oList) const
        {
            if (oList.GetItemCount() == GetItemCount())
            {
                _myType::const_iterator itRHS = oList.cbegin();
                for (_myType::const_iterator itLHS = cbegin(); itLHS != cend();)
                {
                    if (*itRHS != *itLHS)
                    {
                        return tFalse;
                    }
                    itRHS++;
                    itLHS++;
                }
                return tTrue;
            }
            else
            {
                return tFalse;
            }
        }
};
 
using cStringList = string_list_base<cString>;
 
} // namespace A_UTILS_NS