arduino_ci 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1553aff5cd187c7db5ea325fd2ee878914fae57692d70042f1ceb0a6cd184f18
-  data.tar.gz: 8c948d1eec2967ee364fc2fa983bed1746dc1204089d2ea0f355ab27b0aa97f6
+  metadata.gz: 81bed39a97b584fc45ff028f60c9eeb50e24e929123e3af0ca9e6db48ffc5d1a
+  data.tar.gz: 4ee99e35584eaa5db713d80149b1ce7bead47f8e3ac74d1016e82fdb11f1b1c0
 SHA512:
-  metadata.gz: 43bbc201c5d38e8852a71e3a0b4da85400d764fc2e4b248e0fd14f6d79c1111c4bc778aecdc7e49bea8c7c73e4417b28f4ae9d3e5c3ba4814768929bf5ae2c7b
-  data.tar.gz: '069ce22a67dc335c5b1d97bdecc91476bf8f6484740b9acfd063e4c2741db0cfa808c5b5599dce970721f2d808825ebf0297857e88fe7a75bfa2611a4cda23bf'
+  metadata.gz: 64286125ad20ef12fda79a938d29f44d20751db0716144149a660afb350da73f08ef0b1d0494b1d472cac6d50d2cbdc48ce1e4697736f509fbc036adbb724ac1
+  data.tar.gz: 40620b0806a64191b00c84bdf86f546dd131a5cafdda8cc6da23e9cbd64235f88fa2b7aa9d580d5c05cb47da3f93dd0961f86a18dff344d68de7b7f428a673be

data/README.md

@@ -1,6 +1,6 @@
 [![Gem Version](https://badge.fury.io/rb/arduino_ci.svg)](https://rubygems.org/gems/arduino_ci)
 [![Build Status](https://travis-ci.org/ifreecarve/arduino_ci.svg)](https://travis-ci.org/ifreecarve/arduino_ci)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.5)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.6)
 
 # ArduinoCI Ruby gem (`arduino_ci`)
 

data/cpp/arduino/Arduino.h

@@ -59,14 +59,6 @@ typedef unsigned int word;
 
 
 
-/*
-unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
-unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
-
-void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
-uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
-
-*/
 
 // Get the bit location within the hardware port of the given virtual pin.
 // This comes from the pins_*.c file for the active board configuration.
@@ -74,40 +66,6 @@ uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
 #define analogInPinToBit(P) (P)
 #define digitalPinToInterrupt(P) (P)
 
-/*
-// On the ATmega1280, the addresses of some of the port registers are
-// greater than 255, so we can't store them in uint8_t's.
-extern const uint16_t PROGMEM port_to_mode_PGM[];
-extern const uint16_t PROGMEM port_to_input_PGM[];
-extern const uint16_t PROGMEM port_to_output_PGM[];
-
-extern const uint8_t PROGMEM digital_pin_to_port_PGM[];
-// extern const uint8_t PROGMEM digital_pin_to_bit_PGM[];
-extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[];
-extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
-
-// Get the bit location within the hardware port of the given virtual pin.
-// This comes from the pins_*.c file for the active board configuration.
-//
-// These perform slightly better as macros compared to inline functions
-//
-#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) )
-#define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) )
-#define digitalPinToTimer(P) ( pgm_read_byte( digital_pin_to_timer_PGM + (P) ) )
-#define analogInPinToBit(P) (P)
-#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )
-#define portInputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_input_PGM + (P))) )
-#define portModeRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_mode_PGM + (P))) )
-
-*/
-
-
-/* TODO
-#include "WString.h"
-#include "HardwareSerial.h"
-#include "USBAPI.h"
-*/
-
 // uint16_t makeWord(uint16_t w);
 // uint16_t makeWord(byte h, byte l);
 inline unsigned int makeWord(unsigned int w) { return w; }
@@ -115,41 +73,6 @@ inline unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8)
 
 #define word(...) makeWord(__VA_ARGS__)
 
-unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
-unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
-
-void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
-void noTone(uint8_t _pin);
-
-
-// BIG TODO ON THIS ONE
-// $ find . | grep pins_
-// ./arduino-1.8.5/hardware/arduino/avr/variants/circuitplay32u4/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/eightanaloginputs/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/ethernet/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/gemma/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/leonardo/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/mega/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/micro/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/robot_control/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/robot_motor/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/standard/pins_arduino.h
-// ./arduino-1.8.5/hardware/arduino/avr/variants/yun/pins_arduino.h
-// #include "pins_arduino.h"
-
 
 
-/*
-
-
-// Communication
-serial
-stream
-
-// USB
-Keyboard
-Mouse
-
-*/
-
 

data/cpp/arduino/ArduinoDefines.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <avr/pgmspace.h>
+
 #define HIGH 0x1
 #define LOW  0x0
 

data/cpp/arduino/PinHistory.h

@@ -86,7 +86,7 @@ class PinHistory : public ObservableDataStream {
     // this sets the value of the pin authoritatively
     // so if there was a queue, dump it.
     // the actual "set" operation doesn't happen until the next read
-    const T &operator=(const T& i) {
+    T operator=(const T& i) {
       qIn.clear();
       qOut.push(i);
       advertiseBit(qOut.back()); // not valid for all possible types but whatever

data/cpp/arduino/Print.h

@@ -32,7 +32,6 @@ class Print
     virtual size_t write(uint8_t) = 0;
     size_t write(const char *str) { return str == NULL ? 0 : write((const uint8_t *)str, String(str).length()); }
 
-    size_t write(const __FlashStringHelper *str) { return write((const char *)str); }
 
     virtual size_t write(const uint8_t *buffer, size_t size) {
       size_t n;
@@ -41,28 +40,30 @@ class Print
     }
     size_t write(const char *buffer, size_t size) { return write((const uint8_t *)buffer, size); }
 
-    size_t print(const String &s)             { return write(s.c_str(), s.length()); }
-    size_t print(const char* str)             { return print(String(str)); }
-    size_t print(char c)                      { return print(String(c)); }
-    size_t print(unsigned char b, int base)   { return print(String(b, base)); }
-    size_t print(int n, int base)             { return print(String(n, base)); }
-    size_t print(unsigned int n, int base)    { return print(String(n, base)); }
-    size_t print(long n, int base)            { return print(String(n, base)); }
-    size_t print(unsigned long n, int base)   { return print(String(n, base)); }
-    size_t print(double n, int digits)        { return print(String(n, digits)); }
-    size_t print(const Printable& x)          { return x.printTo(*this); }
+    size_t print(const String &s)                { return write(s.c_str(), s.length()); }
+    size_t print(const __FlashStringHelper *str) { return print(reinterpret_cast<PGM_P>(str)); }
+    size_t print(const char* str)                { return print(String(str)); }
+    size_t print(char c)                         { return print(String(c)); }
+    size_t print(unsigned char b, int base)      { return print(String(b, base)); }
+    size_t print(int n, int base)                { return print(String(n, base)); }
+    size_t print(unsigned int n, int base)       { return print(String(n, base)); }
+    size_t print(long n, int base)               { return print(String(n, base)); }
+    size_t print(unsigned long n, int base)      { return print(String(n, base)); }
+    size_t print(double n, int digits)           { return print(String(n, digits)); }
+    size_t print(const Printable& x)             { return x.printTo(*this); }
 
-    size_t println(void)                        { return print("\r\n"); }
-    size_t println(const String &s)             { return print(s) + println(); }
-    size_t println(const char* c)               { return println(String(c)); }
-    size_t println(char c)                      { return println(String(c)); }
-    size_t println(unsigned char b, int base)   { return println(String(b, base)); }
-    size_t println(int num, int base)           { return println(String(num, base)); }
-    size_t println(unsigned int num, int base)  { return println(String(num, base)); }
-    size_t println(long num, int base)          { return println(String(num, base)); }
-    size_t println(unsigned long num, int base) { return println(String(num, base)); }
-    size_t println(double num, int digits)      { return println(String(num, digits)); }
-    size_t println(const Printable& x)          { return print(x) + println(); }
+    size_t println(void)                           { return print("\r\n"); }
+    size_t println(const String &s)                { return print(s) + println(); }
+    size_t println(const __FlashStringHelper *str) { return println(reinterpret_cast<PGM_P>(str)); }
+    size_t println(const char* c)                  { return println(String(c)); }
+    size_t println(char c)                         { return println(String(c)); }
+    size_t println(unsigned char b, int base)      { return println(String(b, base)); }
+    size_t println(int num, int base)              { return println(String(num, base)); }
+    size_t println(unsigned int num, int base)     { return println(String(num, base)); }
+    size_t println(long num, int base)             { return println(String(num, base)); }
+    size_t println(unsigned long num, int base)    { return println(String(num, base)); }
+    size_t println(double num, int digits)         { return println(String(num, digits)); }
+    size_t println(const Printable& x)             { return print(x) + println(); }
 
     virtual void flush() { }
 

data/cpp/arduino/SoftwareSerial.h

@@ -10,16 +10,19 @@ class SoftwareSerial : public Stream
   private:
     int mPinIn;
     int mPinOut;
-    bool mInverse;
     bool mIsListening;
     GodmodeState* mState;
     unsigned long mOffset; // bits to offset stream
     bool bigEndian;
 
   public:
-    SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic = false) {
+    // @TODO this is public for now to avoid a compiler warning
+    bool mInvertLogic; // @TODO not sure how to implement yet
+
+    SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool invertLogic = false) {
       mPinIn = receivePin;
       mPinOut = transmitPin;
+      mIsListening = invertLogic;
       mIsListening = false;
       mOffset = 0; // godmode starts with 1 bit in the queue
       mState = GODMODE();

data/cpp/arduino/WString.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <stdlib.h>
-#include <string>
+#include <string.h>
 #include <algorithm>
 #include <iostream>
 #include "AvrMath.h"
@@ -9,24 +9,16 @@
 
 typedef std::string string;
 
-//typedef const char __FlashStringHelper;
 class __FlashStringHelper;
 #define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
 
 // Compatibility with string class
 class String: public string
 {
-  public:
-
-    // allow "string s; if (s) {}"
-    // http://www.artima.com/cppsource/safebool.html
-    typedef void (String::*TTDNSCstring)() const;
-    void ttdnsc() const {}
-    operator TTDNSCstring() const  { return &String::ttdnsc; }
-
   private:
-    static const char* digit(int val) {
-      static const char* bank = "0123456789ABCDEF";
+    static const char *digit(int val)
+    {
+      static const char *bank = "0123456789ABCDEF";
       return bank + val;
     }
 
@@ -44,122 +36,126 @@ class String: public string
 
     static string dtoas(double val, int decimalPlaces) {
       double r = 0.5 * pow(0.1, decimalPlaces); // make sure that integer truncation will properly round
-      if (::isnan(val)) return "nan";
-      if (::isinf(val)) return "inf";
+      if (std::isnan(val)) return "nan";
+      if (std::isinf(val)) return "inf";
       val += val > 0 ? r : -r;
       if (val > 4294967040.0) return "ovf";
       if (val <-4294967040.0) return "ovf";
       return mytoas(val, 10) + "." + mytoa(abs(val - (long)val) * pow(10, decimalPlaces), 10);
     }
 
-public:
-  ~String(void) {}
-  String(const __FlashStringHelper *str): string((const char *)str) {}
-  String(const char *cstr = ""): string(cstr) {}
-  String(const string &str): string(str) {}
-  String(const String &str): string(str) {}
-  explicit String(char c): string(1, c) {}
-
-  explicit String(unsigned char val, unsigned char base=10): string(mytoa(val, base)) {}
-  explicit String(int val,           unsigned char base=10): string(mytoas(val, base)) {}
-  explicit String(unsigned int val , unsigned char base=10): string(mytoa(val, base)) {}
-  explicit String(long val,          unsigned char base=10): string(mytoas(val, base)) {}
-  explicit String(unsigned long val, unsigned char base=10): string(mytoa(val, base)) {}
-
-  explicit String(float val,  unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
-  explicit String(double val, unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
-
-  String & operator = (const String &rhs) { assign(rhs); return *this; }
-  String & operator = (const string &rhs) { assign(rhs); return *this; }
-  String & operator = (const char *cstr)  { assign(cstr); return *this; }
-  String & operator = (const char c)      { assign(1, c); return *this; }
-
-  unsigned char concat(const __FlashStringHelper *str) { append((const char *)str); return 1; }
-  unsigned char concat(const String &str) { append(str); return 1; }
-  unsigned char concat(const char *cstr)  { append(cstr); return 1; }
-  unsigned char concat(char c)            { append(1, c); return 1; }
-  unsigned char concat(unsigned char c)   { append(1, c); return 1; }
-  unsigned char concat(int num)           { append(String(num)); return 1; }
-  unsigned char concat(unsigned int num)  { append(String(num)); return 1; }
-  unsigned char concat(long num)          { append(String(num)); return 1; }
-  unsigned char concat(unsigned long num) { append(String(num)); return 1; }
-  unsigned char concat(float num)         { append(String(num)); return 1; }
-  unsigned char concat(double num)        { append(String(num)); return 1; }
-
-  String & operator += (const __FlashStringHelper *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 += (char c)            { concat(c);    return *this; }
-  String & operator += (unsigned char num) { concat(num);  return *this; }
-  String & operator += (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 += (unsigned long num) { concat(num);  return *this; }
-  String & operator += (float num)         { concat(num);  return *this; }
-  String & operator += (double num)        { concat(num);  return *this; }
-
-
-  int compareTo(const String &s) const { return compare(s); }
-  unsigned char equals(const String &s) const { return compareTo(s) == 0; }
-	unsigned char equals(const char *cstr) const { return compareTo(String(cstr)) == 0; }
-  unsigned char equal(const String &s) const { return equals(s); }
-	unsigned char equal(const char *cstr) const { return equals(cstr); }
-  unsigned char equalsIgnoreCase(const String &s) const {
-    String a = String(*this);
-    String b = String(s);
-    a.toUpperCase();
-    b.toUpperCase();
-    return a.compare(b) == 0;
-  }
-
-  unsigned char startsWith(const String &prefix) const { return find(prefix) == 0; }
-  unsigned char startsWith(const String &prefix, unsigned int offset) const { return find(prefix, offset) == offset; }
-  unsigned char endsWith(const String &suffix) const { return rfind(suffix) == length() - suffix.length(); }
-
-  char charAt(unsigned int index) const {	return operator[](index); }
-  void setCharAt(unsigned int index, char c) { (*this)[index] = c; }
-
-  void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const { copy((char*)buf, bufsize, index); }
-  void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
-    { getBytes((unsigned char *)buf, bufsize, index); }
-
-  int indexOf( char ch ) const                                   { return find(ch); }
-  int indexOf( char ch, unsigned int fromIndex ) const           { return find(ch, fromIndex); }
-  int indexOf( const String &str ) const                         { return find(str); }
-  int indexOf( const String &str, unsigned int fromIndex ) const { return find(str, fromIndex); }
-  int lastIndexOf( char ch ) const                                   { return rfind(ch); }
-  int lastIndexOf( char ch, unsigned int fromIndex ) const           { return rfind(ch, fromIndex); }
-  int lastIndexOf( const String &str ) const                         { return rfind(str); }
-  int lastIndexOf( const String &str, unsigned int fromIndex ) const { return rfind(str, fromIndex); }
-  String substring( unsigned int beginIndex ) const { return String(substr(beginIndex)); }
-  String substring( unsigned int beginIndex, unsigned int endIndex ) const { return String(substr(beginIndex, endIndex)); }
-
-  void replace(const String& target, const String& repl) {
-    int i = 0;
-    while ((i = find(target, i)) != npos) {
-      assign(substr(0, i) + repl + substr(i + target.length()));
-      i += repl.length();
+  public:
+    ~String(void) {}
+    String(const __FlashStringHelper *str): string((const char *)str) {}
+    String(const char *cstr = ""): string(cstr) {}
+    String(const string &str): string(str) {}
+    String(const String &str): string(str) {}
+    explicit String(char c): string(1, c) {}
+
+    explicit String(unsigned char val, unsigned char base=10): string(mytoa(val, base)) {}
+    explicit String(int val,           unsigned char base=10): string(mytoas(val, base)) {}
+    explicit String(unsigned int val , unsigned char base=10): string(mytoa(val, base)) {}
+    explicit String(long val,          unsigned char base=10): string(mytoas(val, base)) {}
+    explicit String(unsigned long val, unsigned char base=10): string(mytoa(val, base)) {}
+
+    explicit String(float val,  unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
+    explicit String(double val, unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
+
+      operator bool() const {
+        return true;
+      }
+
+    String & operator = (const String &rhs) { assign(rhs); return *this; }
+    String & operator = (const string &rhs) { assign(rhs); return *this; }
+    String & operator = (const char *cstr)  { assign(cstr); return *this; }
+    String & operator = (const char c)      { assign(1, c); return *this; }
+
+    unsigned char concat(const __FlashStringHelper *str) { append((const char *)str); return 1; }
+    unsigned char concat(const String &str) { append(str); return 1; }
+    unsigned char concat(const char *cstr)  { append(cstr); return 1; }
+    unsigned char concat(char c)            { append(1, c); return 1; }
+    unsigned char concat(unsigned char c)   { append(1, c); return 1; }
+    unsigned char concat(int num)           { append(String(num)); return 1; }
+    unsigned char concat(unsigned int num)  { append(String(num)); return 1; }
+    unsigned char concat(long num)          { append(String(num)); return 1; }
+    unsigned char concat(unsigned long num) { append(String(num)); return 1; }
+    unsigned char concat(float num)         { append(String(num)); return 1; }
+    unsigned char concat(double num)        { append(String(num)); return 1; }
+
+    String & operator += (const __FlashStringHelper *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 += (char c)            { concat(c);    return *this; }
+    String & operator += (unsigned char num) { concat(num);  return *this; }
+    String & operator += (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 += (unsigned long num) { concat(num);  return *this; }
+    String & operator += (float num)         { concat(num);  return *this; }
+    String & operator += (double num)        { concat(num);  return *this; }
+
+
+    int compareTo(const String &s) const { return compare(s); }
+    unsigned char equals(const String &s) const { return compareTo(s) == 0; }
+    unsigned char equals(const char *cstr) const { return compareTo(String(cstr)) == 0; }
+    unsigned char equal(const String &s) const { return equals(s); }
+    unsigned char equal(const char *cstr) const { return equals(cstr); }
+    unsigned char equalsIgnoreCase(const String &s) const {
+      String a = String(*this);
+      String b = String(s);
+      a.toUpperCase();
+      b.toUpperCase();
+      return a.compare(b) == 0;
     }
-  }
-  void replace(char target, char repl) {
-    replace(String(target), String(repl));
-  }
-  void remove(unsigned int index) { assign(substr(0, index)); }
-  void remove(unsigned int index, unsigned int count) { assign(substr(0, index) + substr(min(length(), index + count), count)); }
-  void toLowerCase(void) { std::transform(begin(), end(), begin(), ::tolower); }
-  void toUpperCase(void) { std::transform(begin(), end(), begin(), ::toupper); }
-
-  void trim(void) {
-    int b;
-    int e;
-    for (b = 0; b < length() && isSpace(charAt(b)); ++b);
-    for (e = length() - 1; e > b && isSpace(charAt(e)); --e);
-    assign(substr(b, e - b + 1));
-  }
-
-  long toInt(void) const      { return std::stol(*this); }
-  float toFloat(void) const   { return std::stof(*this); }
-  double toDouble(void) const { return std::stod(*this); }
+
+    unsigned char startsWith(const String &prefix) const { return find(prefix) == 0; }
+    unsigned char startsWith(const String &prefix, unsigned int offset) const { return find(prefix, offset) == offset; }
+    unsigned char endsWith(const String &suffix) const { return rfind(suffix) == length() - suffix.length(); }
+
+    char charAt(unsigned int index) const {	return operator[](index); }
+    void setCharAt(unsigned int index, char c) { (*this)[index] = c; }
+
+    void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const { copy((char*)buf, bufsize, index); }
+    void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
+      { getBytes((unsigned char *)buf, bufsize, index); }
+
+    int indexOf( char ch ) const                                   { return find(ch); }
+    int indexOf( char ch, unsigned int fromIndex ) const           { return find(ch, fromIndex); }
+    int indexOf( const String &str ) const                         { return find(str); }
+    int indexOf( const String &str, unsigned int fromIndex ) const { return find(str, fromIndex); }
+    int lastIndexOf( char ch ) const                                   { return rfind(ch); }
+    int lastIndexOf( char ch, unsigned int fromIndex ) const           { return rfind(ch, fromIndex); }
+    int lastIndexOf( const String &str ) const                         { return rfind(str); }
+    int lastIndexOf( const String &str, unsigned int fromIndex ) const { return rfind(str, fromIndex); }
+    String substring( unsigned int beginIndex ) const { return String(substr(beginIndex)); }
+    String substring( unsigned int beginIndex, unsigned int endIndex ) const { return String(substr(beginIndex, endIndex)); }
+
+    void replace(const String& target, const String& repl) {
+      int i = 0;
+      while ((i = find(target, i)) != npos) {
+        assign(substr(0, i) + repl + substr(i + target.length()));
+        i += repl.length();
+      }
+    }
+    void replace(char target, char repl) {
+      replace(String(target), String(repl));
+    }
+    void remove(unsigned int index) { assign(substr(0, index)); }
+    void remove(unsigned int index, unsigned int count) { assign(substr(0, index) + substr(min(length(), index + count), count)); }
+    void toLowerCase(void) { std::transform(begin(), end(), begin(), ::tolower); }
+    void toUpperCase(void) { std::transform(begin(), end(), begin(), ::toupper); }
+
+    void trim(void) {
+      int b;
+      int e;
+      for (b = 0; b < length() && isSpace(charAt(b)); ++b);
+      for (e = length() - 1; e > b && isSpace(charAt(e)); --e);
+      assign(substr(b, e - b + 1));
+    }
+
+    long toInt(void) const      { return std::stol(*this); }
+    float toFloat(void) const   { return std::stof(*this); }
+    double toDouble(void) const { return std::stod(*this); }
 
 };