ByteOrder.h

Go to the documentation of this file.

#ifndef __stir_ByteOrder_H__
#define __stir_ByteOrder_H__

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000-2009 Hammersmith Imanet Ltd
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
/*
  Modification History:
 
  - First version by KT
 
  - AZ&KT 15/12/99 rewrote swap_order using revert_region
*/
 
#include "stir/common.h"
// for swap
#include <algorithm>
 
START_NAMESPACE_STIR

 
/*
  \brief Internal class to swap bytes.
 
  This defines a revert function that swaps the outer elements of an
  array, and then calls itself recursively.
  Due to the use of templates, the recursion gets resolved at compile
  time.
  (We have to use a class for this, as we rely on
  template specialisation, which is unavailable for functions).
 
  \warning This class should not be used anywhere, except in the
  ByteOrder::swap_order implementation.
 
  \internal
*/
/*
  It really shouldn't be in this include file, but we have to because
  of a compiler bug in VC++ (member templates have to be defined in the
  class).
*/
// TODO put revert_region in own namespace or as private class of ByteOrder
 
template <int size>
class revert_region
{
public:
  inline static void revert(unsigned char* ptr)
  {
    std::swap(ptr[0], ptr[size - 1]);
    revert_region<size - 2>::revert(ptr + 1);
  }
};
 
template <>
class revert_region<1>
{
public:
  inline static void revert(unsigned char* ptr) {}
};
 
template <>
class revert_region<0>
{
public:
  inline static void revert(unsigned char* ptr) {}
};
 
class ByteOrder
{
public:
  enum Order
  {
    little_endian, 
    big_endian,    
    native,        
    swapped        
  };
 
  //******* static members (i.e. not using 'this')

  inline static Order get_native_order();
 
  // Note: this uses member templates. If your compiler cannot handle it,
  // you will have to write lots of lines for the built-in types
  // Note: Implementation has to be inside the class definition to get
  // this compiled by VC++ 5.0 and 6.0
  template <class NUMBER>
  inline static void swap_order(NUMBER& value)
  {
    revert_region<sizeof(NUMBER)>::revert(reinterpret_cast<unsigned char*>(&value));
  }
 
  //********* non-static members

  inline ByteOrder(Order byte_order = native);

  inline bool operator==(const ByteOrder order2) const;
  inline bool operator!=(const ByteOrder order2) const;

  inline bool is_native_order() const;
 
  // Note: this uses member templates. If your compiler cannot handle it,
  // you will have to write lots of lines for the built-in types
  // Note: Implementation has to be inside the class definition to get
  // this compiled by VC++ 5.0 and 6.0
  template <class NUMBER>
  inline void swap_if_necessary(NUMBER& a) const
  {
    if (!is_native_order())
      swap_order(a);
  }
 
private:
  // This static member has to be initialised somewhere (in file scope).
  static const Order native_order;
 
  Order byte_order;
};
 
END_NAMESPACE_STIR
 
#include "stir/ByteOrder.inl"
 
#endif