Subversion Repositories spk

#include "StringList.h"
#include "spkdef.h"

namespace Utils {
        CStringList::CStringList()
        {
                _lList = new CList<SStringList>();
        }

        CStringList::~CStringList()
        {
                delete _lList;
        }

        void CStringList::pushBack(const String &str, const String &data)
        {
                SStringList *strNode = new SStringList;
                strNode->str = str;
                strNode->data = data;
                _lList->push_back(strNode);
        }

        void CStringList::popBack()
        {
                if (!_lList->empty())
                {
                        delete _lList->back();
                        _lList->pop_back();
                }
        }
        void CStringList::pushBack(const String &str)
        {
                pushBack(str, "");
        }

        void CStringList::pushFront(const String &str, const String &data)
        {
                SStringList *strNode = new SStringList;
                strNode->str = str;
                strNode->data = data;
                _lList->push_front(strNode);
        }
        void CStringList::pushFront(const String &str)
        {
                pushFront(str, "");
        }

        void CStringList::insertAt(int at, const String& str, const String& data)
        {
                SStringList* strNode = new SStringList;
                strNode->str = str;
                strNode->data = data;
                _lList->insertAt(at, strNode);
        }
        void CStringList::insertAt(int at, const String& str)
        {
                insertAt(at, str, "");
        }

        void CStringList::clear()
        {
                _lList->clear();
        }

        void CStringList::tokenise(const String &str, const String &token)
        {
                int max = 0;
                Utils::String *strs = str.tokenise(token, &max);
                for ( int i = 0; i < max; i++ ) {
                        this->pushBack(strs[i], Utils::String::Null());
                }

                CLEANSPLIT(strs, max);
        }

        Utils::String CStringList::firstString()
        {
                SStringList *node = _lList->first();
                if ( node ) return node->str;
                return Utils::String::Null();
        }

        Utils::String CStringList::nextString()
        {
                SStringList *node = _lList->next();
                if ( node ) return node->str;
                return Utils::String::Null();
        }

        Utils::SStringList *CStringList::first()
        {
                return _lList->first();
        }

        Utils::SStringList *CStringList::next()
        {
                return _lList->next();
        }

        CStringListIterator CStringList::begin() const
        {
                return _lList->begin();
        }

        CStringListIterator CStringList::end() const
        {
                return _lList->end();
        }

        Utils::String CStringList::front() const
        {
                auto front = _lList->front();
                if (front)
                        return front->str;
                return Utils::String::Null();
        }

        Utils::String CStringList::back() const
        {
                auto front = _lList->back();
                if (front)
                        return front->str;
                return Utils::String::Null();
        }

        Utils::SStringList *CStringList::get(int i) const
        {
                return _lList->get(i);
        }

        Utils::String CStringList::findData(const Utils::String &data, bool bIgnoreCase) const
        {
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->data.Compare(data, !bIgnoreCase))
                                return (*itr)->str;
                }

                return String::Null();
        }

        Utils::String CStringList::findString(const Utils::String &str, bool bIgnoreCase) const
        {
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                                return (*itr)->data;
                }

                return String::Null();
        }

        int CStringList::findStringAndData(const Utils::String& str, const Utils::String& data, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++, pos++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                        {
                                if ((*itr)->data.Compare(data, !bIgnoreCase))
                                        return static_cast<int>(pos);
                        }
                }

                return -1;
        }

        int CStringList::findPos(const Utils::String& str, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++, pos++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                                return static_cast<int>(pos);
                }

                return -1;
        }

        bool CStringList::containsStringAndData(const Utils::String& str, const Utils::String& data, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++, pos++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                        {
                                if ((*itr)->data.Compare(data, !bIgnoreCase))
                                        return true;
                        }
                }

                return false;
        }

        bool CStringList::containsData(const Utils::String &data, bool bIgnoreCase) const
        {
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->data.Compare(data, !bIgnoreCase))
                                return true;
                }

                return false;
        }

        bool CStringList::changeData(const Utils::String &str, const Utils::String &data, bool bIgnoreCase)
        {
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                        {
                                (*itr)->data = data;
                                return true;
                        }
                }

                return false;
        }

        bool CStringList::contains(const Utils::String &str, bool bIgnoreCase) const
        {
                for (CList<SStringList>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                                return true;
                }

                return false;
        }

        void CStringList::removeAt(int at)
        {
                _lList->removeAt(at);
        }

        CStringListIterator CStringList::remove(CStringListIterator itr)
        {
                return _lList->remove(itr);
        }
        bool CStringList::remove(const Utils::String &str, bool single)
        {
                bool removed = false;

                CList<Utils::SStringList>::iterator itr = _lList->begin();
                while (itr != _lList->end())
                {
                        Utils::SStringList *node = *itr;
                        if (node->str == str)
                        {
                                itr = _lList->remove(itr);
                                if (single)
                                        break;
                        }
                        else
                                ++itr;
                }


                return removed;
        }




        size_t CStringList::size() const
        {
                return _lList->size();
        }

        bool CStringList::empty() const
        {
                return _lList->empty();
        }

        const Utils::SStringList* CStringList::operator[](int num) const
        {
                return _lList->get(num);
        }

}