Updated proxy system. Now it is not restricted on types of input.

Author: Chris--A

hardware/arduino/avr/libraries/EEPROM/src/EEPROM.h

@@ -35,12 +35,12 @@
 
 struct EERef{
 
-    EERef( const int index )
-        : index( index )                 {}
+    template< typename T > EERef( T *ptr ) : index( (int) ptr ) {}
+    EERef( const int index ) : index( index )                   {}
 
     //Access/read members.
     uint8_t operator*() const            { return eeprom_read_byte( (uint8_t*) index ); }
-    operator const uint8_t() const       { return **this; }
+    operator uint8_t() const             { return **this; }
 
     //Assignment/write members.
     EERef &operator=( const EERef &ref ) { return *this = *ref; }
@@ -86,15 +86,18 @@ struct EERef{
 
 struct EEPtr{
 
-    EEPtr( const int index )
-        : index( index )                {}
+    template< typename T > EEPtr( T *ptr ) : index( (int) ptr ) {}    
+    EEPtr( const int index ) : index( index )                   {}
 
-    operator const int() const          { return index; }
+    operator int() const                { return index; }
     EEPtr &operator=( int in )          { return index = in, *this; }
+	EERef operator[]( int idx )         { return index + idx; }
 
     //Iterator functionality.
     bool operator!=( const EEPtr &ptr ) { return index != ptr.index; }
-    EERef operator*()                   { return index; }
+
+    //Dreference & member access.
+	EERef operator*()                   { return index; }
 
     /** Prefix & Postfix increment/decrement **/
     EEPtr& operator++()                 { return ++index, *this; }
@@ -115,31 +118,29 @@ struct EEPtr{
 
 struct EEPROMClass{
 
-    //Basic user access methods.
-    EERef operator[]( const int idx )    { return idx; }
-    uint8_t read( int idx )              { return EERef( idx ); }
-    void write( int idx, uint8_t val )   { (EERef( idx )) = val; }
-    void update( int idx, uint8_t val )  { EERef( idx ).update( val ); }
+    //Basic user access methods.	
+    EERef operator[]( EERef ref )         { return ref; }
+    EERef read( EERef ref )               { return ref; }
+    void write( EERef ref, uint8_t val )  { ref = val; }
+    void update( EERef ref, uint8_t val ) { ref.update( val ); }	
 
     //STL and C++11 iteration capability.
     EEPtr begin()                        { return 0x00; }
     EEPtr end()                          { return length(); } //Standards requires this to be the item after the last valid entry. The returned pointer is invalid.
     uint16_t length()                    { return E2END + 1; }
 
     //Functionality to 'get' and 'put' objects to and from EEPROM.
-    template< typename T > T &get( int idx, T &t ){
-        EEPtr e = idx;
-        uint8_t *ptr = (uint8_t*) &t;
-        for( int count = sizeof(T) ; count ; --count, ++e )  *ptr++ = *e;
-        return t;
-    }
+	template< typename T > T &get( EEPtr ptr, T &t ){
+		uint8_t *dest = (uint8_t*) &t;
+		for( int count = sizeof(T) ; count ; --count, ++ptr ) *dest++ = *ptr;
+		return t;
+	}
 
-    template< typename T > const T &put( int idx, const T &t ){
-        EEPtr e = idx;
-        const uint8_t *ptr = (const uint8_t*) &t;
-        for( int count = sizeof(T) ; count ; --count, ++e )  (*e).update( *ptr++ );
-        return t;
-    }
+	template< typename T > const T &put( EEPtr ptr, const T &t ){
+		const uint8_t *src = (const uint8_t*) &t;
+		for( int count = sizeof(T) ; count ; --count, ++ptr ) (*ptr).update( *src++ );
+		return t;
+	}	
 };
 
 static EEPROMClass EEPROM;