Improvements from arduino-esp32 repo

Added printTo().  Added index operators and type converters.  See test project here: https://github.com/mrengineer7777/MA_Test.  No further changes expected.

Author: mrengineer7777

Diff for: api/MacAddress.cpp

@@ -1,5 +1,6 @@
+#include <MacAddress.h>
 #include <stdio.h>
-#include "MacAddress.h"
+#include <Print.h>
 
 //Default constructor, blank mac address.
 MacAddress::MacAddress() {
@@ -14,6 +15,15 @@ MacAddress::MacAddress(const uint8_t *macbytearray) {
     memcpy(_mac.bytes, macbytearray, sizeof(_mac.bytes));
 }
 
+MacAddress::MacAddress(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6) {
+    _mac.bytes[0] = b1;
+    _mac.bytes[1] = b2;
+    _mac.bytes[2] = b3;
+    _mac.bytes[3] = b4;
+    _mac.bytes[4] = b5;
+    _mac.bytes[5] = b6;
+}
+
 //Parse user entered string into MAC address
 bool MacAddress::fromCStr(const char *buf) {
   char cs[18];
@@ -63,33 +73,74 @@ uint64_t MacAddress::Value() {
     return _mac.val;
 }
 
-//Implicit conversion object to number [same as .Value()]
-MacAddress::operator uint64_t() const
-{
-    return _mac.val;
+//Allow getting individual octets of the address. e.g. uint8_t b0 = ma[0];
+uint8_t MacAddress::operator[](int index) const {
+    index = EnforceIndexBounds(index);
+    return _mac.bytes[index];
 }
 
-//Overloaded copy operators to allow initialisation of MacAddress objects from other types
-MacAddress& MacAddress::operator=(const uint8_t *mac)
-{
-    memcpy(_mac.bytes, mac, sizeof(_mac.bytes));
+//Allow setting individual octets of the address. e.g. ma[2] = 255;
+uint8_t& MacAddress::operator[](int index) {
+    index = EnforceIndexBounds(index);
+    return _mac.bytes[index];
+}
+
+//Overloaded copy operator: init MacAddress object from byte array
+MacAddress& MacAddress::operator=(const uint8_t *macbytearray) {
+    memcpy(_mac.bytes, macbytearray, sizeof(_mac.bytes));
     return *this;
 }
 
-MacAddress& MacAddress::operator=(uint64_t macval)
-{
+//Overloaded copy operator: init MacAddress object from uint64_t
+MacAddress& MacAddress::operator=(uint64_t macval) {
     _mac.val = macval;
     return *this;
 }
 
 //Compare class to byte array
-bool MacAddress::operator==(const uint8_t *mac) const
-{
-    return !memcmp(_mac.bytes, mac, sizeof(_mac.bytes));
+bool MacAddress::operator==(const uint8_t *macbytearray) const {
+    return !memcmp(_mac.bytes, macbytearray, sizeof(_mac.bytes));
 }
 
 //Allow comparing value of two classes
-bool MacAddress::operator==(const MacAddress& mac2) const
-{
+bool MacAddress::operator==(const MacAddress& mac2) const {
     return _mac.val == mac2._mac.val;
 }
+
+//Type converter object to uint64_t [same as .Value()]
+MacAddress::operator uint64_t() const {
+    return _mac.val;
+}
+
+//Type converter object to read only pointer to mac bytes. e.g. const uint8_t *ip_8 = ma;
+MacAddress::operator const uint8_t*() const {
+    return _mac.bytes;
+}
+
+//Type converter object to read only pointer to mac value. e.g. const uint32_t *ip_64 = ma;
+MacAddress::operator const uint64_t*() const {
+    return &_mac.val;
+}
+
+size_t MacAddress::printTo(Print& p) const
+{
+    size_t n = 0;
+    for(int i = 0; i < 6; i++) {
+        if(i){
+            n += p.print(':');
+        }
+        n += p.printf("%02X", _mac.bytes[i]);
+    }
+    return n;
+}
+
+//Bounds checking
+int MacAddress::EnforceIndexBounds(int i) const {
+    if(i < 0) {
+        return 0;
+    }
+    if(i >= sizeof(_mac.bytes)) {
+        return sizeof(_mac.bytes)-1;
+    }
+    return i;
+}

Diff for: api/MacAddress.h

@@ -19,12 +19,11 @@
 #define MacAddress_h
 
 #include <stdint.h>
-#include "String.h"
-
-namespace arduino {
+#include <WString.h>
+#include <Printable.h>
 
 // A class to make it easier to handle and pass around 6-byte BSSID and MAC addresses.
-class MacAddress {
+class MacAddress : public Printable {
 private:
     union {
         struct {
@@ -38,6 +37,7 @@ class MacAddress {
     MacAddress();
     MacAddress(uint64_t mac);
     MacAddress(const uint8_t *macbytearray);
+    MacAddress(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6);
     virtual ~MacAddress() {}
     bool fromCStr(const char *buf);
     bool fromString(const String &macstr);
@@ -46,14 +46,28 @@ class MacAddress {
     String toString() const;
     uint64_t Value();
 
-    operator uint64_t() const;
-    MacAddress& operator=(const uint8_t *mac);
+    uint8_t operator[](int index) const;
+    uint8_t& operator[](int index);
+    MacAddress& operator=(const uint8_t *macbytearray);
     MacAddress& operator=(uint64_t macval);
-    bool operator==(const uint8_t *mac) const;
+    bool operator==(const uint8_t *macbytearray) const;
     bool operator==(const MacAddress& mac2) const;
-};
+    operator uint64_t() const;
+    operator const uint8_t*() const;
+    operator const uint64_t*() const;
 
-}
-using arduino::MacAddress;
+    virtual size_t printTo(Print& p) const;
+
+    // future use in Arduino Networking 
+    friend class EthernetClass;
+    friend class UDP;
+    friend class Client;
+    friend class Server;
+    friend class DhcpClass;
+    friend class DNSClient;
+
+private:
+    int EnforceIndexBounds(int i) const;
+};
 
 #endif

Diff for: api/MacAddress8.cpp

@@ -1,5 +1,6 @@
+#include <MacAddress8.h>
 #include <stdio.h>
-#include "MacAddress8.h"
+#include <Print.h>
 
 //Default constructor, blank mac address.
 MacAddress8::MacAddress8() {
@@ -14,6 +15,17 @@ MacAddress8::MacAddress8(const uint8_t *macbytearray) {
     memcpy(_mac.bytes, macbytearray, sizeof(_mac.bytes));
 }
 
+MacAddress8::MacAddress8(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7, uint8_t b8) {
+    _mac.bytes[0] = b1;
+    _mac.bytes[1] = b2;
+    _mac.bytes[2] = b3;
+    _mac.bytes[3] = b4;
+    _mac.bytes[4] = b5;
+    _mac.bytes[5] = b6;
+    _mac.bytes[6] = b7;
+    _mac.bytes[7] = b8;
+}
+
 //Parse user entered string into MAC address
 bool MacAddress8::fromCStr(const char *buf) {
   char cs[24];
@@ -63,33 +75,73 @@ uint64_t MacAddress8::Value() {
     return _mac.val;
 }
 
-//Implicit conversion object to number [same as .Value()]
-MacAddress8::operator uint64_t() const
-{
-    return _mac.val;
+uint8_t MacAddress8::operator[](int index) const {
+    index = EnforceIndexBounds(index);
+    return _mac.bytes[index];
 }
 
-//Overloaded copy operators to allow initialisation of MacAddress objects from other types
-MacAddress8& MacAddress8::operator=(const uint8_t *mac)
-{
-    memcpy(_mac.bytes, mac, sizeof(_mac.bytes));
+//Allow setting individual octets of the address. e.g. ma[2] = 255;
+uint8_t& MacAddress8::operator[](int index) {
+    index = EnforceIndexBounds(index);
+    return _mac.bytes[index];
+}
+
+//Overloaded copy operator: init MacAddress object from byte array
+MacAddress8& MacAddress8::operator=(const uint8_t *macbytearray) {
+    memcpy(_mac.bytes, macbytearray, sizeof(_mac.bytes));
     return *this;
 }
 
-MacAddress8& MacAddress8::operator=(uint64_t macval)
-{
+//Overloaded copy operator: init MacAddress object from uint64_t
+MacAddress8& MacAddress8::operator=(uint64_t macval) {
     _mac.val = macval;
     return *this;
 }
 
 //Compare class to byte array
-bool MacAddress8::operator==(const uint8_t *mac) const
-{
-    return !memcmp(_mac.bytes, mac, sizeof(_mac.bytes));
+bool MacAddress8::operator==(const uint8_t *macbytearray) const {
+    return !memcmp(_mac.bytes, macbytearray, sizeof(_mac.bytes));
 }
 
 //Allow comparing value of two classes
-bool MacAddress8::operator==(const MacAddress8& mac2) const
-{
+bool MacAddress8::operator==(const MacAddress8& mac2) const {
     return _mac.val == mac2._mac.val;
 }
+
+//Type converter object to uint64_t [same as .Value()]
+MacAddress8::operator uint64_t() const {
+    return _mac.val;
+}
+
+//Type converter object to read only pointer to mac bytes. e.g. const uint8_t *ip_8 = ma;
+MacAddress8::operator const uint8_t*() const {
+    return _mac.bytes;
+}
+
+//Type converter object to read only pointer to mac value. e.g. const uint32_t *ip_64 = ma;
+MacAddress8::operator const uint64_t*() const {
+    return &_mac.val;
+}
+
+size_t MacAddress8::printTo(Print& p) const
+{
+    size_t n = 0;
+    for(int i = 0; i < 8; i++) {
+        if(i){
+            n += p.print(':');
+        }
+        n += p.printf("%02X", _mac.bytes[i]);
+    }
+    return n;
+}
+
+//Bounds checking
+int MacAddress8::EnforceIndexBounds(int i) const {
+    if(i < 0) {
+        return 0;
+    }
+    if(i >= sizeof(_mac.bytes)) {
+        return sizeof(_mac.bytes)-1;
+    }
+    return i;
+}

Diff for: api/MacAddress8.h

@@ -19,12 +19,11 @@
 #define MacAddress8_h
 
 #include <stdint.h>
-#include "String.h"
-
-namespace arduino {
+#include <WString.h>
+#include <Printable.h>
 
 // A class to make it easier to handle and pass around 8-byte EUI-64(used for IEEE 802.15.4) addresses. See <esp_mac.h>.
-class MacAddress8 {
+class MacAddress8 : public Printable {
 private:
     union {
         uint8_t bytes[8];
@@ -35,22 +34,37 @@ class MacAddress8 {
     MacAddress8();
     MacAddress8(uint64_t mac);
     MacAddress8(const uint8_t *macbytearray);
+    MacAddress8(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7, uint8_t b8);
     virtual ~MacAddress8() {}
     bool fromCStr(const char *buf);
     bool fromString(const String &macstr);
     void toBytes(uint8_t *buf);
-    int toCStr(char *buf);
+    int  toCStr(char *buf);
     String toString() const;
     uint64_t Value();
 
-    operator uint64_t() const;
-    MacAddress8& operator=(const uint8_t *mac);
+    uint8_t operator[](int index) const;
+    uint8_t& operator[](int index);
+    MacAddress8& operator=(const uint8_t *macbytearray);
     MacAddress8& operator=(uint64_t macval);
-    bool operator==(const uint8_t *mac) const;
+    bool operator==(const uint8_t *macbytearray) const;
     bool operator==(const MacAddress8& mac2) const;
-};
+    operator uint64_t() const;
+    operator const uint8_t*() const;
+    operator const uint64_t*() const;
 
-}
-using arduino::MacAddress8;
+    virtual size_t printTo(Print& p) const;
+
+    // future use in Arduino Networking 
+    friend class EthernetClass;
+    friend class UDP;
+    friend class Client;
+    friend class Server;
+    friend class DhcpClass;
+    friend class DNSClient;
+
+private:
+    int EnforceIndexBounds(int i) const;
+};
 
 #endif