Updated IPAddress class to the latest version

cores/arduino/IPAddress.cpp

 /*
-  Copyright (c) 2014 Arduino.  All right reserved.
+  IPAddress.cpp - Base class that provides IPAddress
+  Copyright (c) 2011 Adrian McEwen.  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
@@ -8,8 +9,8 @@
 
   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.
+  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
@@ -21,42 +22,42 @@
 
 IPAddress::IPAddress()
 {
-    memset(_address, 0, sizeof(_address));
+    _address.dword = 0;
 }
 
 IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
 {
-    _address[0] = first_octet;
-    _address[1] = second_octet;
-    _address[2] = third_octet;
-    _address[3] = fourth_octet;
+    _address.bytes[0] = first_octet;
+    _address.bytes[1] = second_octet;
+    _address.bytes[2] = third_octet;
+    _address.bytes[3] = fourth_octet;
 }
 
 IPAddress::IPAddress(uint32_t address)
 {
-    memcpy(_address, &address, sizeof(_address));
+    _address.dword = address;
 }
 
 IPAddress::IPAddress(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
 }
 
 IPAddress& IPAddress::operator=(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
     return *this;
 }
 
 IPAddress& IPAddress::operator=(uint32_t address)
 {
-    memcpy(_address, (const uint8_t *)&address, sizeof(_address));
+    _address.dword = address;
     return *this;
 }
 
 bool IPAddress::operator==(const uint8_t* addr) const
 {
-    return memcmp(addr, _address, sizeof(_address)) == 0;
+    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
 }
 
 size_t IPAddress::printTo(Print& p) const
@@ -64,10 +65,10 @@ size_t IPAddress::printTo(Print& p) const
     size_t n = 0;
     for (int i =0; i < 3; i++)
     {
-        n += p.print(_address[i], DEC);
+        n += p.print(_address.bytes[i], DEC);
         n += p.print('.');
     }
-    n += p.print(_address[3], DEC);
+    n += p.print(_address.bytes[3], DEC);
     return n;
 }
 

cores/arduino/IPAddress.h

 /*
-  Copyright (c) 2014 Arduino.  All right reserved.
+  IPAddress.h - Base class that provides IPAddress
+  Copyright (c) 2011 Adrian McEwen.  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
@@ -8,8 +9,8 @@
 
   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.
+  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
@@ -19,18 +20,23 @@
 #ifndef IPAddress_h
 #define IPAddress_h
 
+#include <stdint.h>
 #include <Printable.h>
 
 // A class to make it easier to handle and pass around IP addresses
 
 class IPAddress : public Printable {
 private:
-    uint8_t _address[4];  // IPv4 address
+    union {
+	uint8_t bytes[4];  // IPv4 address
+	uint32_t dword;
+    } _address;
+
     // Access the raw byte array containing the address.  Because this returns a pointer
     // to the internal structure rather than a copy of the address this function should only
     // be used when you know that the usage of the returned uint8_t* will be transient and not
     // stored.
-    uint8_t* raw_address() { return _address; };
+    uint8_t* raw_address() { return _address.bytes; };
 
 public:
     // Constructors
@@ -41,13 +47,13 @@ public:
 
     // Overloaded cast operator to allow IPAddress objects to be used where a pointer
     // to a four-byte uint8_t array is expected
-    operator uint32_t() const { return *((uint32_t*)_address+0); };
-    bool operator==(const IPAddress& addr) const { return (*((uint32_t*)_address)) == (*((uint32_t*)addr._address)); };
+    operator uint32_t() const { return _address.dword; };
+    bool operator==(const IPAddress& addr) const { return _address.dword == addr._address.dword; };
     bool operator==(const uint8_t* addr) const;
 
     // Overloaded index operator to allow getting and setting individual octets of the address
-    uint8_t operator[](int index) const { return _address[index]; };
-    uint8_t& operator[](int index) { return _address[index]; };
+    uint8_t operator[](int index) const { return _address.bytes[index]; };
+    uint8_t& operator[](int index) { return _address.bytes[index]; };
 
     // Overloaded copy operators to allow initialisation of IPAddress objects from other types
     IPAddress& operator=(const uint8_t *address);