String.hpp

Go to the documentation of this file.

/****
 * String.hpp - Defines the String class and associated macros for efficient flash memory string access.
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the FlashString Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 * @author: 2018 - Mikee47 <mike@sillyhouse.net>
 *
 ****/
 
#pragma once
 
#include "Object.hpp"
#include "StringPrinter.hpp"
 
// Wiring String - this file is included from WString.h so define required types only
class String;
class __FlashStringHelper;
typedef const __FlashStringHelper* flash_string_t;
 
#define FS_PTR(str)                                                                                                    \
    (__extension__({                                                                                                   \
        static FSTR_VOLATILE DEFINE_FSTR_DATA(FSTR_DATA_NAME(tmp), str);                                               \
        const_cast<const FSTR::String*>(&FSTR_DATA_NAME(tmp).object);                                                  \
    }))
 
#define FS(str) (*FS_PTR(str))
 
#define DECLARE_FSTR(name) DECLARE_FSTR_OBJECT(name, FSTR::String)
 
#define DEFINE_FSTR(name, str)                                                                                         \
    static DEFINE_FSTR_DATA(FSTR_DATA_NAME(name), str);                                                                \
    DEFINE_FSTR_REF(name)
 
#define DEFINE_FSTR_LOCAL(name, str)                                                                                   \
    static DEFINE_FSTR_DATA(FSTR_DATA_NAME(name), str);                                                                \
    DEFINE_FSTR_REF_LOCAL(name)
 
#define DEFINE_FSTR_DATA(name, str)                                                                                    \
    constexpr const struct {                                                                                           \
        FSTR::String object;                                                                                           \
        char data[ALIGNUP4(sizeof(str))];                                                                              \
    } FSTR_PACKED name PROGMEM = {{sizeof(str) - 1}, str};                                                             \
    FSTR_CHECK_STRUCT(name);
 
#define LOAD_FSTR(name, fstr)                                                                                          \
    char name[(fstr).size()] FSTR_ALIGNED;                                                                             \
    memcpy_aligned(name, (fstr).data(), (fstr).length());                                                              \
    name[(fstr).length()] = '\0';
 
#define FSTR_ARRAY(name, str)                                                                                          \
    static DEFINE_FSTR_DATA(FSTR_DATA_NAME(name), str);                                                                \
    LOAD_FSTR(name, FSTR_DATA_NAME(name).object)
 
#define IMPORT_FSTR(name, file) IMPORT_FSTR_OBJECT(name, FSTR::String, file)
 
#define IMPORT_FSTR_LOCAL(name, file) IMPORT_FSTR_OBJECT_LOCAL(name, FSTR::String, file)
 
#define FSTR_TABLE(name) const FSTR::String* const name[] PROGMEM
 
namespace FSTR
{
typedef ::String WString;
 
class String : public Object<String, char>
{
public:
    size_t size() const
    {
        return ALIGNUP4(Object::length() + 1);
    }
 
    flash_string_t data() const
    {
        return reinterpret_cast<flash_string_t>(Object::data());
    }
 
    bool equals(const char* cstr, size_t len, bool ignoreCase = false) const;
 
    bool equalsIgnoreCase(const char* cstr, size_t len) const
    {
        return equals(cstr, len, true);
    }
 
    bool equals(const char* cstr, bool ignoreCase = false) const;
 
    template <typename T> bool equalsIgnoreCase(const T& str) const
    {
        return equals(str, true);
    }
 
    bool operator==(const char* cstr) const
    {
        return equals(cstr);
    }
 
    bool operator!=(const char* cstr) const
    {
        return !equals(cstr);
    }
 
    bool equals(const String& str, bool ignoreCase = false) const;
 
    bool operator==(const String& str) const
    {
        return equals(str);
    }
 
    bool operator!=(const String& str) const
    {
        return !equals(str);
    }
 
    /* WString support */
 
    operator WString() const;
 
    bool equals(const WString& str, bool ignoreCase = false) const;
 
    bool operator==(const WString& str) const
    {
        return equals(str);
    }
 
    bool operator!=(const WString& str) const
    {
        return !equals(str);
    }
 
    /* Arduino Print support */
 
    StringPrinter printer() const
    {
        return StringPrinter(*this);
    }
 
    size_t printTo(Print& p) const
    {
        return printer().printTo(p);
    }
} FSTR_PACKED;
 
} // namespace FSTR