-29 Removals
+19 Additions
/*/*
WString.h - String library for Wiring & Arduino WString.h - String library for Wiring & Arduino
...mostly rewritten by Paul Stoffregen... ...mostly rewritten by Paul Stoffregen...
Copyright (c) 2009-10 Hernando Barragan. All right reserved. Copyright (c) 2009-10 Hernando Barragan. All right reserved.
Copyright 2011, Paul Stoffregen, paul@pjrc.com Copyright 2011, Paul Stoffregen, paul@pjrc.com
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/*/
#ifndef String_class_h#ifndef String_class_h
#define String_class_h#define String_class_h
#ifdef __cplusplus#ifdef __cplusplus
#include <stdlib.h>#include <stdlib.h>
#include <string.h>#include <string.h>
#include <ctype.h>#include <ctype.h>
#include <avr/pgmspace.h>#include <avr/pgmspace.h>
// When compiling programs with this class, the following gcc parameters// When compiling programs with this class, the following gcc parameters
// dramatically increase performance and memory (RAM) efficiency, typically// dramatically increase performance and memory (RAM) efficiency, typically
// with little or no increase in code size.// with little or no increase in code size.
// -felide-constructors// -felide-constructors
// -std=c++0x// -std=c++0x
class __FlashStringHelper;class __FlashStringHelper;
#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
// An inherited class for holding the result of a concatenation. These// An inherited class for holding the result of a concatenation. These
// result objects are assumed to be writable by subsequent concatenations.// result objects are assumed to be writable by subsequent concatenations.
class StringSumHelper;class StringSumHelper;
// The string class// The string class
class Stringclass String
{{
// use a function pointer to allow for "if (s)" without the // use a function pointer to allow for "if (s)" without the
// complications of an operator bool(). for more information, see: // complications of an operator bool(). for more information, see:
// http://www.artima.com/cppsource/safebool.html // http://www.artima.com/cppsource/safebool.html
typedef void (String::*StringIfHelperType)() const; typedef void (String::*StringIfHelperType)() const;
void StringIfHelper() const {} void StringIfHelper() const {}
public:public:
// constructors // constructors
// creates a copy of the initial value. // creates a copy of the initial value.
// if the initial value is null or invalid, or if memory allocation // if the initial value is null or invalid, or if memory allocation
// fails, the string will be marked as invalid (i.e. "if (s)" will // fails, the string will be marked as invalid (i.e. "if (s)" will
// be false). // be false).
String(const char *cstr = ""); String(const char *cstr = "");
String(const String &str); String(const String &str);
String(const __FlashStringHelper *str);
#ifdef __GXX_EXPERIMENTAL_CXX0X__ #ifdef __GXX_EXPERIMENTAL_CXX0X__
String(String &&rval); String(String &&rval);
String(StringSumHelper &&rval); String(StringSumHelper &&rval);
#endif #endif
explicit String(char c); explicit String(char c);
explicit String(unsigned char, unsigned char base=10); explicit String(unsigned char, unsigned char base=10);
explicit String(int, unsigned char base=10); explicit String(int, unsigned char base=10);
explicit String(unsigned int, unsigned char base=10); explicit String(unsigned int, unsigned char base=10);
explicit String(long, unsigned char base=10); explicit String(long, unsigned char base=10);
explicit String(unsigned long, unsigned char base=10); explicit String(unsigned long, unsigned char base=10);
explicit String(float, unsigned char decimalPlaces=2);
explicit String(double, unsigned char decimalPlaces=2);
~String(void); ~String(void);
// memory management // memory management
// return true on success, false on failure (in which case, the string // return true on success, false on failure (in which case, the string
// is left unchanged). reserve(0), if successful, will validate an // is left unchanged). reserve(0), if successful, will validate an
// invalid string (i.e., "if (s)" will be true afterwards) // invalid string (i.e., "if (s)" will be true afterwards)
unsigned char reserve(unsigned int size); unsigned char reserve(unsigned int size);
inline unsigned int length(void) const {return len;} inline unsigned int length(void) const {return len;}
// creates a copy of the assigned value. if the value is null or // creates a copy of the assigned value. if the value is null or
// invalid, or if the memory allocation fails, the string will be // invalid, or if the memory allocation fails, the string will be
// marked as invalid ("if (s)" will be false). // marked as invalid ("if (s)" will be false).
String & operator = (const String &rhs); String & operator = (const String &rhs);
String & operator = (const char *cstr); String & operator = (const char *cstr);
String & operator = (const __FlashStringHelper *str);
#ifdef __GXX_EXPERIMENTAL_CXX0X__ #ifdef __GXX_EXPERIMENTAL_CXX0X__
String & operator = (String &&rval); String & operator = (String &&rval);
String & operator = (StringSumHelper &&rval); String & operator = (StringSumHelper &&rval);
#endif #endif
// concatenate (works w/ built-in types) // concatenate (works w/ built-in types)
// returns true on success, false on failure (in which case, the string // returns true on success, false on failure (in which case, the string
// is left unchanged). if the argument is null or invalid, the // is left unchanged). if the argument is null or invalid, the
// concatenation is considered unsucessful. // concatenation is considered unsucessful.
unsigned char concat(const String &str); unsigned char concat(const String &str);
unsigned char concat(const char *cstr); unsigned char concat(const char *cstr);
unsigned char concat(char c); unsigned char concat(char c);
unsigned char concat(unsigned char c); unsigned char concat(unsigned char c);
unsigned char concat(int num); unsigned char concat(int num);
unsigned char concat(unsigned int num); unsigned char concat(unsigned int num);
unsigned char concat(long num); unsigned char concat(long num);
unsigned char concat(unsigned long num); unsigned char concat(unsigned long num);
unsigned char concat(float num);
unsigned char concat(double num);
unsigned char concat(const __FlashStringHelper * str);
// if there's not enough memory for the concatenated value, the string // if there's not enough memory for the concatenated value, the string
// will be left unchanged (but this isn't signalled in any way) // will be left unchanged (but this isn't signalled in any way)
String & operator += (const String &rhs) {concat(rhs); return (*this);} String & operator += (const String &rhs) {concat(rhs); return (*this);}
String & operator += (const char *cstr) {concat(cstr); return (*this);} String & operator += (const char *cstr) {concat(cstr); return (*this);}
String & operator += (char c) {concat(c); return (*this);} String & operator += (char c) {concat(c); return (*this);}
String & operator += (unsigned char num) {concat(num); return (*this);} String & operator += (unsigned char num) {concat(num); return (*this);}
String & operator += (int num) {concat(num); return (*this);} String & operator += (int num) {concat(num); return (*this);}
String & operator += (unsigned int num) {concat(num); return (*this);} String & operator += (unsigned int num) {concat(num); return (*this);}
String & operator += (long num) {concat(num); return (*this);} String & operator += (long num) {concat(num); return (*this);}
String & operator += (unsigned long num) {concat(num); return (*this);} String & operator += (unsigned long num) {concat(num); return (*this);}
String & operator += (float num) {concat(num); return (*this);}
String & operator += (double num) {concat(num); return (*this);}
String & operator += (const __FlashStringHelper *str){concat(str); return (*this);}
// Implement StringAdditionOperator per Arduino docs... String + __
String operator + (const String &rhs) {return String(*this) += rhs;}
String operator + (const char *cstr) {return String(*this) += cstr;}
String operator + (char c) {return String(*this) += c;}
String operator + (unsigned char num) {return String(*this) += num;}
String operator + (int num) {return String(*this) += num;}
String operator + (unsigned int num) {return String(*this) += num;}
String operator + (long num) {return String(*this) += num;}
String operator + (unsigned long num) {return String(*this) += num;}
#if 0
friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs); friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs);
friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr); friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr);
friend StringSumHelper & operator + (const StringSumHelper &lhs, char c); friend StringSumHelper & operator + (const StringSumHelper &lhs, char c);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num); friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, int num); friend StringSumHelper & operator + (const StringSumHelper &lhs, int num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num); friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, long num); friend StringSumHelper & operator + (const StringSumHelper &lhs, long num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num); friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, float num);#endif
friend StringSumHelper & operator + (const StringSumHelper &lhs, double num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs);
// comparison (only works w/ Strings and "strings") // comparison (only works w/ Strings and "strings")
operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; } operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; }
int compareTo(const String &s) const; int compareTo(const String &s) const;
unsigned char equals(const String &s) const; unsigned char equals(const String &s) const;
unsigned char equals(const char *cstr) const; unsigned char equals(const char *cstr) const;
unsigned char operator == (const String &rhs) const {return equals(rhs);} unsigned char operator == (const String &rhs) const {return equals(rhs);}
unsigned char operator == (const char *cstr) const {return equals(cstr);} unsigned char operator == (const char *cstr) const {return equals(cstr);}
unsigned char operator != (const String &rhs) const {return !equals(rhs);} unsigned char operator != (const String &rhs) const {return !equals(rhs);}
unsigned char operator != (const char *cstr) const {return !equals(cstr);} unsigned char operator != (const char *cstr) const {return !equals(cstr);}
unsigned char operator < (const String &rhs) const; unsigned char operator < (const String &rhs) const;
unsigned char operator > (const String &rhs) const; unsigned char operator > (const String &rhs) const;
unsigned char operator <= (const String &rhs) const; unsigned char operator <= (const String &rhs) const;
unsigned char operator >= (const String &rhs) const; unsigned char operator >= (const String &rhs) const;
unsigned char equalsIgnoreCase(const String &s) const; unsigned char equalsIgnoreCase(const String &s) const;
unsigned char startsWith( const String &prefix) const; unsigned char startsWith( const String &prefix) const;
unsigned char startsWith(const String &prefix, unsigned int offset) const; unsigned char startsWith(const String &prefix, unsigned int offset) const;
unsigned char endsWith(const String &suffix) const; unsigned char endsWith(const String &suffix) const;
// character acccess // character acccess
char charAt(unsigned int index) const; char charAt(unsigned int index) const;
void setCharAt(unsigned int index, char c); void setCharAt(unsigned int index, char c);
char operator [] (unsigned int index) const; char operator [] (unsigned int index) const;
char& operator [] (unsigned int index); char& operator [] (unsigned int index);
void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const; void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const;
void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
{getBytes((unsigned char *)buf, bufsize, index);} {getBytes((unsigned char *)buf, bufsize, index);}
const char * c_str() const { return buffer; }
// search // search
int indexOf( char ch ) const; int indexOf( char ch ) const;
int indexOf( char ch, unsigned int fromIndex ) const; int indexOf( char ch, unsigned int fromIndex ) const;
int indexOf( const String &str ) const; int indexOf( const String &str ) const;
int indexOf( const String &str, unsigned int fromIndex ) const; int indexOf( const String &str, unsigned int fromIndex ) const;
int lastIndexOf( char ch ) const; int lastIndexOf( char ch ) const;
int lastIndexOf( char ch, unsigned int fromIndex ) const; int lastIndexOf( char ch, unsigned int fromIndex ) const;
int lastIndexOf( const String &str ) const; int lastIndexOf( const String &str ) const;
int lastIndexOf( const String &str, unsigned int fromIndex ) const; int lastIndexOf( const String &str, unsigned int fromIndex ) const;
String substring( unsigned int beginIndex ) const { return substring(beginIndex, len); }; String substring( unsigned int beginIndex ) const { return substring(beginIndex, len); };
String substring( unsigned int beginIndex, unsigned int endIndex ) const; String substring( unsigned int beginIndex, unsigned int endIndex ) const;
// modification // modification
void replace(char find, char replace); void replace(char find, char replace);
void replace(const String& find, const String& replace); void replace(const String& find, const String& replace);
void remove(unsigned int index);
void remove(unsigned int index, unsigned int count);
void toLowerCase(void); void toLowerCase(void);
void toUpperCase(void); void toUpperCase(void);
void trim(void); void trim(void);
// parsing/conversion // parsing/conversion
long toInt(void) const; long toInt(void) const;
float toFloat(void) const; char * getCSpec(int base, bool issigned, bool islong);
protected:
char *buffer; // the actual char array char *buffer; // the actual char array
unsigned int capacity; // the array length minus one (for the '\0') unsigned int capacity; // the array length minus one (for the '\0')
unsigned int len; // the String length (not counting the '\0') unsigned int len; // the String length (not counting the '\0')
protected: unsigned char flags; // unused, for future features
void init(void); void init(void);
void invalidate(void); void invalidate(void);
unsigned char changeBuffer(unsigned int maxStrLen); unsigned char changeBuffer(unsigned int maxStrLen);
unsigned char concat(const char *cstr, unsigned int length); unsigned char concat(const char *cstr, unsigned int length);
// copy and move // copy and move
String & copy(const char *cstr, unsigned int length); String & copy(const char *cstr, unsigned int length);
String & copy(const __FlashStringHelper *pstr, unsigned int length);
#ifdef __GXX_EXPERIMENTAL_CXX0X__ #ifdef __GXX_EXPERIMENTAL_CXX0X__
void move(String &rhs); void move(String &rhs);
#endif #endif
};};
class StringSumHelper : public Stringclass StringSumHelper : public String
{{
public:public:
StringSumHelper(const String &s) : String(s) {} StringSumHelper(const String &s) : String(s) {}
StringSumHelper(const char *p) : String(p) {} StringSumHelper(const char *p) : String(p) {}
StringSumHelper(char c) : String(c) {} StringSumHelper(char c) : String(c) {}
StringSumHelper(unsigned char num) : String(num) {} StringSumHelper(unsigned char num) : String(num) {}
StringSumHelper(int num) : String(num) {} StringSumHelper(int num) : String(num) {}
StringSumHelper(unsigned int num) : String(num) {} StringSumHelper(unsigned int num) : String(num) {}
StringSumHelper(long num) : String(num) {} StringSumHelper(long num) : String(num) {}
StringSumHelper(unsigned long num) : String(num) {} StringSumHelper(unsigned long num) : String(num) {}
StringSumHelper(float num) : String(num) {}
StringSumHelper(double num) : String(num) {}
};};
#endif // __cplusplus#endif // __cplusplus
#endif // String_class_h#endif // String_class_h
Editor
Original Text
Changed Text