CStringArray.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * CStringArray.h
 *
 * @author: 2018 - Mikee47 <mike@sillyhouse.net>
 *
 ****/
 
#pragma once
 
#include "WString.h"
#include "stringutil.h"
 
class CStringArray : private String
{
public:
    // Inherit any safe/useful methods
    using String::compareTo;
    using String::equals;
    using String::reserve;
    using String::operator StringIfHelperType;
    using String::operator==;
    using String::operator!=;
    using String::operator<;
    using String::operator>;
    using String::operator<=;
    using String::operator>=;
    using String::c_str;
    using String::endsWith;
    using String::equalsIgnoreCase;
    using String::getBytes;
    using String::length;
    using String::startsWith;
    using String::toCharArray;
    using String::toLowerCase;
    using String::toUpperCase;
 
    CStringArray(const String& str) : String(str)
    {
        init();
    }
 
    CStringArray(const char* cstr = nullptr) : String(cstr)
    {
        init();
    }
 
    CStringArray(const char* cstr, unsigned int length) : String(cstr, length)
    {
        init();
    }
 
    explicit CStringArray(flash_string_t pstr, int length = -1) : String(pstr, length)
    {
        init();
    }
 
    CStringArray(const FlashString& fstr) : String(fstr)
    {
        init();
    }
 
    CStringArray(String&& rval) noexcept : String(std::move(rval))
    {
        init();
    }
 
    CStringArray(StringSumHelper&& rval) noexcept : String(std::move(rval))
    {
        init();
    }
    CStringArray& operator=(const char* cstr)
    {
        String::operator=(cstr);
        init();
        return *this;
    }
 
    String release()
    {
        return std::move(*this);
    }
 
    bool add(const char* str, int length = -1);
 
    bool add(const String& str)
    {
        return add(str.c_str(), str.length());
    }
 
    CStringArray& operator+=(const String& str)
    {
        add(str);
        return *this;
    }
 
    CStringArray& operator+=(const char* cstr)
    {
        add(cstr);
        return *this;
    }
 
    template <typename T> CStringArray& operator+=(const T& value)
    {
        add(String(value));
        return *this;
    }
    int indexOf(const char* str, bool ignoreCase = true) const;
 
    int indexOf(const String& str, bool ignoreCase = true) const
    {
        return indexOf(str.c_str(), ignoreCase);
    }
 
    bool contains(const char* str, bool ignoreCase = true) const
    {
        return indexOf(str, ignoreCase) >= 0;
    }
 
    bool contains(const String& str, bool ignoreCase = true) const
    {
        return indexOf(str, ignoreCase) >= 0;
    }
 
    const char* getValue(unsigned index) const;
 
    const char* operator[](unsigned index) const
    {
        return getValue(index);
    }
 
    const char* front() const
    {
        return cbuffer();
    }
 
    bool pushFront(const char* str);
 
    String popFront();
 
    const char* back() const;
 
    bool pushBack(const char* str)
    {
        return add(str);
    }
 
    String popBack();
 
    void clear()
    {
        *this = nullptr;
        stringCount = 0;
    }
 
    unsigned count() const;
 
    String join(const String& separator = ",") const;
 
    class Iterator
    {
    public:
        Iterator() = default;
        Iterator(const Iterator&) = default;
 
        Iterator(const CStringArray* array, uint16_t offset, uint16_t index)
            : mArray(array), mOffset(offset), mIndex(index)
        {
        }
 
        operator bool() const
        {
            return mArray != nullptr && mOffset < mArray->length();
        }
 
        bool equals(const char* rhs) const
        {
            auto s = str();
            return s == rhs || strcmp(s, rhs) == 0;
        }
 
        bool equalsIgnoreCase(const char* rhs) const
        {
            auto s = str();
            return s == rhs || strcasecmp(str(), rhs) == 0;
        }
 
        bool operator==(const Iterator& rhs) const
        {
            return mArray == rhs.mArray && mOffset == rhs.mOffset;
        }
 
        bool operator!=(const Iterator& rhs) const
        {
            return !operator==(rhs);
        }
 
        bool operator==(const char* rhs) const
        {
            return equals(rhs);
        }
 
        bool operator!=(const char* rhs) const
        {
            return !equals(rhs);
        }
 
        bool equals(const String& rhs) const
        {
            return rhs.equals(str());
        }
 
        bool equalsIgnoreCase(const String& rhs) const
        {
            return rhs.equalsIgnoreCase(str());
        }
 
        bool operator==(const String& rhs) const
        {
            return equals(rhs);
        }
 
        bool operator!=(const String& rhs) const
        {
            return !equals(rhs);
        }
 
        const char* str() const
        {
            if(mArray == nullptr) {
                return "";
            }
 
            return mArray->c_str() + mOffset;
        }
 
        const char* operator*() const
        {
            return str();
        }
 
        uint16_t index() const
        {
            return mIndex;
        }
 
        uint16_t offset() const
        {
            return mOffset;
        }
 
        Iterator& operator++()
        {
            next();
            return *this;
        }
 
        Iterator operator++(int)
        {
            Iterator tmp(*this);
            next();
            return tmp;
        }
 
        void next()
        {
            if(*this) {
                mOffset += strlen(str()) + 1;
                ++mIndex;
            }
        }
 
        using const_iterator = Iterator;
 
    private:
        const CStringArray* mArray = nullptr;
        uint16_t mOffset = 0;
        uint16_t mIndex = 0;
    };
 
    Iterator begin() const
    {
        return Iterator(this, 0, 0);
    }
 
    Iterator end() const
    {
        return Iterator(this, length(), count());
    }
 
private:
    void init();
 
private:
    mutable unsigned stringCount = 0;
};