Fixed some issues with Endian::change_endian triggered in OSX.

include/endianness.h

@@ -33,10 +33,16 @@
 #include <stdint.h>
 #include "arch.h"
 
-#ifdef BSD
-    #include <sys/endian.h>
-    #define TINS_IS_LITTLE_ENDIAN (_BYTE_ORDER == _LITTLE_ENDIAN)
-    #define TINS_IS_BIG_ENDIAN (_BYTE_ORDER == _BIG_ENDIAN)
+#if defined(BSD)
+    #if defined(__APPLE__)
+        #include <sys/types.h>
+        #define TINS_IS_LITTLE_ENDIAN (BYTE_ORDER == LITTLE_ENDIAN)
+        #define TINS_IS_BIG_ENDIAN (BYTE_ORDER == BIG_ENDIAN)
+    #else
+        #include <sys/endian.h>
+        #define TINS_IS_LITTLE_ENDIAN (_BYTE_ORDER == _LITTLE_ENDIAN)
+        #define TINS_IS_BIG_ENDIAN (_BYTE_ORDER == _BIG_ENDIAN)
+    #endif
 #elif !defined(WIN32)
     #include <endian.h>
     #define TINS_IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
@@ -52,7 +58,7 @@ namespace Endian {
      *
      * \param data The data to convert.
      */
-    inline uint16_t change_endian(uint16_t data) {
+    inline uint16_t do_change_endian(uint16_t data) {
         return ((data & 0xff00) >> 8)  | ((data & 0x00ff) << 8);
     }
     
@@ -61,7 +67,7 @@ namespace Endian {
      *
      * \param data The data to convert.
      */
-    inline uint32_t change_endian(uint32_t data) {
+    inline uint32_t do_change_endian(uint32_t data) {
         return (((data & 0xff000000) >> 24) | ((data & 0x00ff0000) >> 8)  |
                 ((data & 0x0000ff00) << 8)  | ((data & 0x000000ff) << 24));
     }
@@ -71,9 +77,56 @@ namespace Endian {
      *
      * \param data The data to convert.
      */
-     inline uint64_t change_endian(uint64_t data) {
-        return (((uint64_t)(change_endian((uint32_t)((data << 32) >> 32))) << 32) |
-                (change_endian(((uint32_t)(data >> 32)))));
+     inline uint64_t do_change_endian(uint64_t data) {
+        return (((uint64_t)(do_change_endian((uint32_t)((data << 32) >> 32))) << 32) |
+                (do_change_endian(((uint32_t)(data >> 32)))));
+     }
+     
+    /**
+     * \cond
+     */
+    
+    // Helpers to convert
+    template<typename T>
+    struct conversion_dispatch_helper {
+        static T dispatch(T data) {
+            return do_change_endian(data);
+        }
+    };
+    
+    
+    template<size_t>
+    struct conversion_dispatcher;
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint16_t)> 
+    : public conversion_dispatch_helper<uint16_t> 
+    { };
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint32_t)> 
+    : public conversion_dispatch_helper<uint32_t> 
+    { };
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint64_t)> 
+    : public conversion_dispatch_helper<uint64_t> 
+    { };
+    
+    /**
+     * \endcond
+     */
+    
+    /**
+     * \brief Changes an integral value's endianess.
+     * 
+     * This dispatchs to the corresponding function.
+     *
+     * \param data The data to convert.
+     */ 
+     template<typename T>
+     inline T change_endian(T data) {
+         return conversion_dispatcher<sizeof(T)>::dispatch(data);
      }
     
     #if TINS_IS_LITTLE_ENDIAN

include/internals.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2012, Nasel
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+ 
+#ifndef TINS_INTERNALS_H
+#define TINS_INTERNALS_H
+
+#include <sstream>
+#include <string>
+#include <stdint.h>
+
+/**
+ * \cond
+ */
+namespace Tins {
+namespace Internals {
+    void skip_line(std::istream &input);
+    bool from_hex(const std::string &str, uint32_t &result);
+    
+    template<bool, typename>
+    struct enable_if {
+        
+    };
+
+    template<typename T>
+    struct enable_if<true, T> {
+        typedef T type;
+    };
+    
+    template<typename T1, typename T2>
+    struct is_same {
+        static const bool value = false;
+    };
+    
+    template<typename T1>
+    struct is_same<T1, T1> {
+        static const bool value = true;
+    };
+}
+}
+/**
+ * \endcond
+ */
+
+#endif

include/utils.h

@@ -55,6 +55,7 @@
 #include "ip_address.h"
 #include "ipv6_address.h"
 #include "hw_address.h"
+#include "internals.h"
 
 namespace Tins {
     class NetworkInterface;
@@ -250,27 +251,6 @@ namespace Tins {
         }
         #endif // WIN32
         
-        /**
-         * \cond
-         */
-        namespace Internals {
-            void skip_line(std::istream &input);
-            bool from_hex(const std::string &str, uint32_t &result);
-            
-            template<bool, typename>
-            struct enable_if {
-                
-            };
-
-            template<typename T>
-            struct enable_if<true, T> {
-                typedef T type;
-            };
-        }
-        /**
-         * \endcond
-         */
-        
         template <typename T>
         struct is_pdu {  
             template <typename U>
@@ -372,7 +352,7 @@ void Tins::Utils::route_entries(ForwardIterator output) {
 #else
 template<class ForwardIterator>
 void Tins::Utils::route_entries(ForwardIterator output) {
-    using namespace Utils::Internals;
+    using namespace Tins::Internals;
     std::ifstream input("/proc/net/route");
     std::string destination, mask, gw;
     uint32_t dummy;

src/internals.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2012, Nasel
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "internals.h"
+
+using std::string;
+
+namespace Tins {
+namespace Internals {
+bool from_hex(const string &str, uint32_t &result) {
+    unsigned i(0);
+    result = 0;
+    while(i < str.size()) {
+        uint8_t tmp;
+        if(str[i] >= 'A' && str[i] <= 'F')
+            tmp = (str[i] - 'A' + 10);
+        else if(str[i] >= '0' && str[i] <= '9')
+            tmp = (str[i] - '0');
+        else
+            return false;
+        result = (result << 4) | tmp;
+        i++;
+    }
+    return true;
+}
+
+void skip_line(std::istream &input) {
+    int c = 0;
+    while(c != '\n' && input)
+         c = input.get();
+}
+}
+}

src/utils.cpp

@@ -83,29 +83,6 @@ struct IPv4Collector {
 
 namespace Tins {
 
-bool Utils::Internals::from_hex(const string &str, uint32_t &result) {
-    unsigned i(0);
-    result = 0;
-    while(i < str.size()) {
-        uint8_t tmp;
-        if(str[i] >= 'A' && str[i] <= 'F')
-            tmp = (str[i] - 'A' + 10);
-        else if(str[i] >= '0' && str[i] <= '9')
-            tmp = (str[i] - '0');
-        else
-            return false;
-        result = (result << 4) | tmp;
-        i++;
-    }
-    return true;
-}
-
-void Utils::Internals::skip_line(istream &input) {
-    int c = 0;
-    while(c != '\n' && input)
-         c = input.get();
-}
-
 /** \endcond */
 
 IPv4Address Utils::resolve_ip(const string &to_resolve) {