aboutsummaryrefslogtreecommitdiff
path: root/cores
diff options
context:
space:
mode:
Diffstat (limited to 'cores')
-rw-r--r--cores/arduino/WString.cpp396
-rw-r--r--cores/arduino/WString.h119
2 files changed, 515 insertions, 0 deletions
diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
new file mode 100644
index 0000000..667a304
--- /dev/null
+++ b/cores/arduino/WString.cpp
@@ -0,0 +1,396 @@
+/*
+ WString.cpp - String library for Wiring & Arduino
+ Copyright (c) 2009-10 Hernando Barragan. All rights reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include <stdlib.h>
+#include "WProgram.h"
+#include "WString.h"
+
+
+String::String( const char *value )
+{
+ if ( value == NULL )
+ value = "";
+ getBuffer( _length = strlen( value ) );
+ strcpy( _buffer, value );
+}
+
+String::String( const String &value )
+{
+ getBuffer( _length = value._length );
+ strcpy( _buffer, value._buffer );
+}
+
+String::String( const char value )
+{
+ _length = 1;
+ getBuffer(1);
+ _buffer[0] = value;
+ _buffer[1] = 0;
+}
+
+String::String( const unsigned char value )
+{
+ _length = 1;
+ getBuffer(1);
+ _buffer[0] = value;
+ _buffer[1] = 0;
+}
+
+String::String( const int value, const int base )
+{
+ char buf[33];
+ itoa((signed long)value, buf, base);
+ getBuffer( _length = strlen(buf) );
+ strcpy( _buffer, buf );
+}
+
+String::String( const unsigned int value, const int base )
+{
+ char buf[33];
+ ultoa((unsigned long)value, buf, base);
+ getBuffer( _length = strlen(buf) );
+ strcpy( _buffer, buf );
+}
+
+String::String( const long value, const int base )
+{
+ char buf[33];
+ ltoa(value, buf, base);
+ getBuffer( _length = strlen(buf) );
+ strcpy( _buffer, buf );
+}
+
+String::String( const unsigned long value, const int base )
+{
+ char buf[33];
+ ultoa(value, buf, 10);
+ getBuffer( _length = strlen(buf) );
+ strcpy( _buffer, buf );
+}
+
+char String::charAt( unsigned int loc ) const
+{
+ return operator[]( loc );
+}
+
+void String::setCharAt( unsigned int loc, const char aChar )
+{
+ if(_length > loc) {
+ _buffer[loc] = aChar;
+ }
+}
+
+int String::compareTo( const String &s2 ) const
+{
+ return strcmp( _buffer, s2._buffer );
+}
+
+const String & String::concat( const String &s2 )
+{
+ return (*this) += s2;
+}
+
+const String & String::operator=( const String &rhs )
+{
+ if ( this == &rhs )
+ return *this;
+
+ if ( rhs._length > _length )
+ {
+ delete [] _buffer;
+ getBuffer( rhs._length );
+ }
+ _length = rhs._length;
+ strcpy( _buffer, rhs._buffer );
+ return *this;
+}
+
+const String & String::operator+=( const char aChar )
+{
+ if ( _length == _capacity )
+ doubleBuffer();
+
+ _buffer[ _length++ ] = aChar;
+ _buffer[ _length ] = '\0';
+ return *this;
+}
+
+const String & String::operator+=( const String &other )
+{
+ _length += other._length;
+ if ( _length > _capacity )
+ {
+ char *temp = _buffer;
+ getBuffer( _length );
+ strcpy( _buffer, temp );
+ delete [] temp;
+ }
+ strcat( _buffer, other._buffer );
+ return *this;
+}
+
+
+int String::operator==( const String &rhs ) const
+{
+ return ( _length == rhs._length && strcmp( _buffer, rhs._buffer ) == 0 );
+}
+
+int String::operator!=( const String &rhs ) const
+{
+ return ( _length != rhs.length() || strcmp( _buffer, rhs.toCharArray() ) != 0 );
+}
+
+int String::operator<( const String &rhs ) const
+{
+ return strcmp( _buffer, rhs._buffer ) < 0;
+}
+
+int String::operator>( const String &rhs ) const
+{
+ return strcmp( _buffer, rhs._buffer ) > 0;
+}
+
+int String::operator<=( const String &rhs ) const
+{
+ return strcmp( _buffer, rhs._buffer ) <= 0;
+}
+
+int String::operator>=( const String & rhs ) const
+{
+ return strcmp( _buffer, rhs._buffer ) >= 0;
+}
+
+char & String::operator[]( unsigned int index )
+{
+ // need to check for valid index, to do later
+ return _buffer[ index ];
+}
+
+char String::operator[]( unsigned int index ) const
+{
+ // need to check for valid index, to do later
+ return _buffer[ index ];
+}
+
+boolean String::endsWith( const String &s2 ) const
+{
+ if ( _length < s2._length )
+ return 0;
+
+ return strcmp( &_buffer[ _length - s2._length], s2.toCharArray() ) == 0;
+}
+
+boolean String::equals( const String &s2 ) const
+{
+ return ( _length == s2._length && strcmp( _buffer,s2._buffer ) == 0 );
+}
+
+boolean String::equalsIgnoreCase( const String &s2 ) const
+{
+ if ( this == &s2 )
+ return true; //1;
+ else if ( _length != s2._length )
+ return false; //0;
+
+ return strcmp(toLowerCase().toCharArray(), s2.toLowerCase().toCharArray()) == 0;
+}
+
+String String::replace( char findChar, char replaceChar )
+{
+ String theReturn = _buffer;
+ char* temp = theReturn._buffer;
+ while( (temp = strchr( temp, findChar )) != 0 )
+ *temp = replaceChar;
+
+ return theReturn;
+}
+
+String String::replace( const String& match, const String& replace )
+{
+ String temp = _buffer, newString;
+
+ int loc;
+ while ( (loc = temp.indexOf( match )) != -1 )
+ {
+ newString += temp.substring( 0, loc );
+ newString += replace;
+ temp = temp.substring( loc + match._length );
+ }
+ newString += temp;
+ return newString;
+}
+
+int String::indexOf( char temp ) const
+{
+ return indexOf( temp, 0 );
+}
+
+int String::indexOf( char ch, unsigned int fromIndex ) const
+{
+ if ( fromIndex >= _length )
+ return -1;
+
+ const char* temp = strchr( &_buffer[fromIndex], ch );
+ if ( temp == NULL )
+ return -1;
+
+ return temp - _buffer;
+}
+
+int String::indexOf( const String &s2 ) const
+{
+ return indexOf( s2, 0 );
+}
+
+int String::indexOf( const String &s2, unsigned int fromIndex ) const
+{
+ if ( fromIndex >= _length )
+ return -1;
+
+ const char *theFind = strstr( &_buffer[ fromIndex ], s2.toCharArray() );
+
+ if ( theFind == NULL )
+ return -1;
+
+ return theFind - _buffer; // pointer subtraction
+}
+
+int String::lastIndexOf( char theChar ) const
+{
+ return lastIndexOf( theChar, _length - 1 );
+}
+
+int String::lastIndexOf( char ch, unsigned int fromIndex ) const
+{
+ if ( fromIndex >= _length )
+ return -1;
+
+ char tempchar = _buffer[fromIndex + 1];
+ _buffer[fromIndex + 1] = '\0';
+ char* temp = strrchr( _buffer, ch );
+ _buffer[fromIndex + 1] = tempchar;
+
+ if ( temp == NULL )
+ return -1;
+
+ return temp - _buffer;
+}
+
+int String::lastIndexOf( const String &s2 ) const
+{
+ return lastIndexOf( s2, _length - s2._length );
+}
+
+int String::lastIndexOf( const String &s2, unsigned int fromIndex ) const
+{
+ // check for empty strings
+ if ( s2._length == 0 || s2._length - 1 > fromIndex || fromIndex >= _length )
+ return -1;
+
+ // matching first character
+ char temp = s2[ 0 ];
+
+ for ( int i = fromIndex; i >= 0; i-- )
+ {
+ if ( _buffer[ i ] == temp && (*this).substring( i, i + s2._length ).equals( s2 ) )
+ return i;
+ }
+ return -1;
+}
+
+boolean String::startsWith( const String &s2 ) const
+{
+ if ( _length < s2._length )
+ return 0;
+
+ return startsWith( s2, 0 );
+}
+
+boolean String::startsWith( const String &s2, unsigned int offset ) const
+{
+ if ( offset > _length - s2._length )
+ return 0;
+
+ return strncmp( &_buffer[offset], s2.toCharArray(), s2._length ) == 0;
+}
+
+String String::substring( unsigned int left ) const
+{
+ return substring( left, _length );
+}
+
+String String::substring( unsigned int left, unsigned int right ) const
+{
+ if ( left > right )
+ {
+ int temp = right;
+ right = left;
+ left = temp;
+ }
+
+ if ( right > _length )
+ {
+ right = _length;
+ }
+
+ char temp = _buffer[ right ]; // save the replaced character
+ _buffer[ right ] = '\0';
+ String outPut = ( _buffer + left ); // pointer arithmetic
+ _buffer[ right ] = temp; //restore character
+ return outPut;
+}
+
+String String::toLowerCase() const
+{
+ String temp = _buffer;
+
+ for ( unsigned int i = 0; i < _length; i++ )
+ temp._buffer[ i ] = (char)tolower( temp._buffer[ i ] );
+ return temp;
+}
+
+String String::toUpperCase() const
+{
+ String temp = _buffer;
+
+ for ( unsigned int i = 0; i < _length; i++ )
+ temp._buffer[ i ] = (char)toupper( temp._buffer[ i ] );
+ return temp;
+}
+
+String String::trim() const
+{
+ String temp = _buffer;
+ unsigned int i,j;
+
+ for ( i = 0; i < _length; i++ )
+ {
+ if ( !isspace(_buffer[i]) )
+ break;
+ }
+
+ for ( j = temp._length - 1; j > i; j-- )
+ {
+ if ( !isspace(_buffer[j]) )
+ break;
+ }
+
+ return temp.substring( i, j + 1);
+}
+
diff --git a/cores/arduino/WString.h b/cores/arduino/WString.h
new file mode 100644
index 0000000..c93d493
--- /dev/null
+++ b/cores/arduino/WString.h
@@ -0,0 +1,119 @@
+/*
+ WString.h - String library for Wiring & Arduino
+ Copyright (c) 2009-10 Hernando Barragan. All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef String_h
+#define String_h
+
+#include "WProgram.h"
+#include <string.h>
+#include <ctype.h>
+
+class String
+{
+ public:
+ // constructors
+ String( const char *value = "" );
+ String( const String &value );
+ explicit String( const char );
+ explicit String( const unsigned char );
+ explicit String( const int, const int base=10);
+ explicit String( const unsigned int, const int base=10 );
+ explicit String( const long, const int base=10 );
+ explicit String( const unsigned long, const int base=10 );
+ virtual ~String() { delete [] _buffer; }
+
+ // operators
+ const String & operator = ( const String &rhs );
+ const String & operator +=( const String &rhs );
+ const String & operator +=( const char );
+ int operator ==( const String &rhs ) const;
+ int operator !=( const String &rhs ) const;
+ int operator < ( const String &rhs ) const;
+ int operator > ( const String &rhs ) const;
+ int operator <=( const String &rhs ) const;
+ int operator >=( const String &rhs ) const;
+ char operator []( unsigned int index ) const;
+ char& operator []( unsigned int index );
+// operator const char *() const { return _buffer; }
+
+ // general methods
+ char charAt( unsigned int index ) const;
+ int compareTo( const String &anotherString ) const;
+ boolean endsWith( const String &suffix ) const;
+ boolean equals( const String &anObject ) const;
+ boolean equalsIgnoreCase( const String &anotherString ) const;
+ int indexOf( char ch ) const;
+ int indexOf( char ch, unsigned int fromIndex ) const;
+ int indexOf( const String &str ) const;
+ int indexOf( const String &str, unsigned int fromIndex ) const;
+ int lastIndexOf( char ch ) const;
+ int lastIndexOf( char ch, unsigned int fromIndex ) const;
+ int lastIndexOf( const String &str ) const;
+ int lastIndexOf( const String &str, unsigned int fromIndex ) const;
+ const unsigned int length( ) const { return _length; }
+ void setCharAt(unsigned int index, const char ch);
+ boolean startsWith( const String &prefix ) const;
+ boolean startsWith( const String &prefix, unsigned int toffset ) const;
+ String substring( unsigned int beginIndex ) const;
+ String substring( unsigned int beginIndex, unsigned int endIndex ) const;
+ String toLowerCase( ) const;
+ String toUpperCase( ) const;
+ String trim( ) const;
+ const byte *getBytes() const { return (byte*)_buffer; }
+ const char* toCharArray() const { return _buffer; }
+ const String& concat( const String &str );
+ String replace( char oldChar, char newChar );
+ String replace( const String& match, const String& replace );
+ friend String operator + ( String lhs, const String &rhs );
+
+ protected:
+ char *_buffer; // the actual char array
+ unsigned int _capacity; // the array length
+ unsigned int _length; // the String length
+
+ void getBuffer(unsigned int maxStrLen);
+ void doubleBuffer( );
+
+ private:
+
+};
+
+// allocate buffer space
+inline void String::getBuffer(unsigned int maxStrLen)
+{
+ _capacity = maxStrLen;
+ _buffer = new char[_capacity + 1];
+}
+
+// double the buffer size
+inline void String::doubleBuffer( )
+{
+ char *temp = _buffer;
+ getBuffer( ++_capacity * 2 );
+ strcpy( _buffer, temp );
+ delete [] temp;
+}
+
+inline String operator+( String lhs, const String &rhs )
+{
+ return lhs += rhs;
+}
+
+
+#endif
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2024-11-22 13:59:52 +0000