Subversion Repositories spk

#include "WStringList.h"
#include "spkdef.h"

namespace Utils {
        WStringList::WStringList()
        {
                _lList = new CList<WStringNode>();
        }

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

        void WStringList::pushBack(const WString &str, const WString &data)
        {
                WStringNode *strNode = new WStringNode;
                strNode->str = str;
                strNode->data = data;
                _lList->push_back(strNode);
        }

        void WStringList::popFront()
        {
                if (!_lList->empty())
                {
                        delete _lList->front();
                        _lList->removeAt(0);
                }
        }
        void WStringList::popBack()
        {
                if (!_lList->empty())
                {
                        delete _lList->back();
                        _lList->pop_back();
                }
        }
        void WStringList::pushBack(const WString &str)
        {
                pushBack(str, L"");
        }

        void WStringList::pushFront(const WString &str, const WString &data)
        {
                WStringNode* strNode = new WStringNode;
                strNode->str = str;
                strNode->data = data;
                _lList->push_front(strNode);
        }
        void WStringList::pushFront(const WString &str)
        {
                pushFront(str, L"");
        }

        void WStringList::insertAt(int at, const WString& str, const WString& data)
        {
                WStringNode *strNode = new WStringNode;
                strNode->str = str;
                strNode->data = data;
                _lList->insertAt(at, strNode);
        }
        void WStringList::insertAt(int at, const WString& str)
        {
                insertAt(at, str, L"");
        }

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

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

                CLEANSPLIT(strs, max);
        }

        Utils::WString WStringList::firstString()
        {
                WStringNode *node = _lList->first();
                if ( node ) return node->str;
                return Utils::WString::Null();
        }

        Utils::WString WStringList::nextString()
        {
                WStringNode *node = _lList->next();
                if ( node ) return node->str;
                return Utils::WString::Null();
        }

        Utils::WStringNode *WStringList::first()
        {
                return _lList->first();
        }

        Utils::WStringNode *WStringList::next()
        {
                return _lList->next();
        }

        WStringListIterator WStringList::begin() const
        {
                return _lList->begin();
        }

        WStringListIterator WStringList::end() const
        {
                return _lList->end();
        }

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

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

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

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

                return WString::Null();
        }

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

                return WString::Null();
        }

        int WStringList::findStringAndData(const Utils::WString& str, const Utils::WString& data, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<WStringNode>::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 WStringList::findPos(const Utils::WString& str, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<WStringNode>::iterator itr = _lList->begin(); itr != _lList->end(); itr++, pos++) {
                        if ((*itr)->str.Compare(str, !bIgnoreCase))
                                return static_cast<int>(pos);
                }

                return -1;
        }

        bool WStringList::containsStringAndData(const Utils::WString& str, const Utils::WString& data, bool bIgnoreCase) const
        {
                size_t pos = 0;
                for (CList<WStringNode>::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 WStringList::containsData(const Utils::WString &data, bool bIgnoreCase) const
        {
                for (CList<WStringNode>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->data.Compare(data, !bIgnoreCase))
                                return true;
                }

                return false;
        }

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

                return false;
        }

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

                return false;
        }

        void WStringList::removeAt(int at)
        {
                if (!_lList->empty())
                {
                        auto var = _lList->get(at);
                        if (var)
                                delete var;
                        _lList->removeAt(at);
                }
        }

        WStringListIterator WStringList::remove(WStringListIterator itr)
        {
                return _lList->remove(itr);
        }
        bool WStringList::remove(const Utils::WString &str, bool single)
        {
                bool removed = false;

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


                return removed;
        }




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

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

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

        Utils::WStringNode* WStringList::operator[](int num)
        {
                return _lList->get(num);
        }
        const Utils::WStringNode* WStringList::operator[](const WString& str) const
        {
                for (CList<WStringNode>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->str.Compare(str, true))
                                return *itr;
                }

                return nullptr;
        }
        Utils::WStringNode* WStringList::operator[](const WString& str)
        {
                for (CList<WStringNode>::iterator itr = _lList->begin(); itr != _lList->end(); itr++) {
                        if ((*itr)->str.Compare(str, true))
                                return *itr;
                }

                return nullptr;
        }
}