endian.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2012:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published
        by the Free Software Foundation, version 3 of the License.
        
        This program 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.
        
        You should have received a copy of the GNU Lesser General Public License
        along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef ASEBA_ENDIAN
#define ASEBA_ENDIAN

namespace Aseba
{
        

        struct ByteSwapper
        {
                template<size_t size>
                static inline void swapp(void *data)
                {
                        uint8 temp[size];
                        for (size_t i = 0; i < size; ++i)
                                temp[i] = reinterpret_cast<uint8*>(data);
                        for (size_t i = 0; i < size; ++i)
                                reinterpret_cast<uint8*>(data)[i] = temp[size-1-i];
                }
                
                template<typename T> 
                static void swap(T& v)
                {
                        swapp<sizeof(T)>(&v);
                }
                
                template<typename T> 
                static T swap(const T& v)
                {
                        T temp(v);
                        swapp<sizeof(T)>(&temp);
                        return temp;
                }
        };
        template<> inline void ByteSwapper::swapp<1>(void * /*data*/)
        {
        }
        template<> inline void ByteSwapper::swapp<2>(void *data)
        {
                const uint16 a=*reinterpret_cast<uint16*>(data);
                *reinterpret_cast<uint16*>(data)=
                        ((a&0x00ff)<< 8)|
                        ((a>> 8)&0x00ff);
        }
        template<> inline void ByteSwapper::swapp<4>(void *data)
        {
                const uint32 a=*reinterpret_cast<uint32*>(data);
                *reinterpret_cast<uint32*>(data)=
                        ((a&0x000000ff)<<24)|
                        ((a&0x0000ff00)<< 8)|
                        ((a>> 8)&0x0000ff00)|
                        ((a>>24)&0x000000ff);
        }
        template<> inline void ByteSwapper::swapp<8>(void *data)
        {
                const uint64 a=*reinterpret_cast<uint64*>(data);
                *reinterpret_cast<uint64*>(data)=
                        ((a&0x00000000000000ffLL)<<56)|
                        ((a&0x000000000000ff00LL)<<40)|
                        ((a&0x0000000000ff0000LL)<<24)|
                        ((a&0x00000000ff000000LL)<< 8)|
                        ((a>> 8)&0x00000000ff000000LL)|
                        ((a>>24)&0x0000000000ff0000LL)|
                        ((a>>40)&0x000000000000ff00LL)|
                        ((a>>56)&0x00000000000000ffLL);
        }
        
        #ifdef __BIG_ENDIAN__
        
        template<typename T>
        T swapEndianCopy(const T& v) { return ByteSwapper::swap<T>(v); }
        template<typename T>
        void swapEndian(T& v) { ByteSwapper::swap<T>(v); }
        
        #else
        
        template<typename T>
        T swapEndianCopy(const T& v) { return v; }
        template<typename T>
        void swapEndian(T& v) { /* do nothing */ }
        
        #endif
        
}

#endif // ASEBA_ENDIAN