TCUtil.h

Go to the documentation of this file.

//*******************************************************************************
//
// *******   ***   ***               *
//    *     *     *                  *
//    *    *      *                *****
//    *    *       ***  *   *   **   *    **    ***
//    *    *          *  * *   *     *   ****  * * *
//    *     *         *   *      *   * * *     * * *
//    *      ***   ***    *     **   **   **   *   *
//                        *
//*******************************************************************************
// see http://sourceforge.net/projects/tcsystem/ for details.
// Copyright (C) 2003 - 2008 Thomas Goessler. All Rights Reserved. 
//*******************************************************************************
//
// TCSystem is the legal property of its developers.
// Please refer to the COPYRIGHT file distributed with this source distribution.
// 
// This library 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; either              
// version 2.1 of the License, or (at your option) any later version.        
//                                                                           
// 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.                           
//                                                                           
// You should have received a copy of the GNU Lesser General Public          
// License along with this library; if not, write to the Free Software       
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
//*******************************************************************************
//  $Id: TCUtil.h 894 2008-10-28 21:51:36Z the_____tiger $
//*******************************************************************************

#ifndef _TC_UTIL_H_
#define _TC_UTIL_H_

#include "TCTypes.h"

namespace TC
{
   namespace Util
   {
      template <class T>
      inline T Abs(const T& x)
      {
         return (x < 0) ? -x : x;
      }

      template <class T>
      inline const T& Max(const T& x, const T& y)
      {
         return (x > y) ? x : y;
      }
      template <class T>
      inline const T& Max(const T& x, const T& y, const T& z)
      {
         return Max(x, Max(y, z));
      }

      template <class T>
      inline const T& Min(const T& x, const T& y)
      {
         return (x < y) ? x : y;
      }
      template <class T>
      inline const T& Min(const T& x, const T& y, const T& z)
      {
         return Min(x, Min(y, z));
      }


      template <class T>
      inline void Swap(T& x, T& y)
      {
         T tmp = x;
         x     = y;
         y     = tmp;
      }

      template <class T>
      inline void FreeMemoryOfStlContainer(T& container)
      {
         T tmp;
         container.swap(tmp);
      }

      template <class T>
      inline void MinimizeMemoryOfStlContainer(T& container)
      {
         T tmp(container);
         container.swap(tmp);
      }

      template <class T>
      inline void SafeRelease(T& mem)
      {
         if (mem != 0)
         {
            delete mem;
            mem = 0;
         }
      }

      template <class T>
      inline void SafeReleaseArray(T& mem)
      {
         if (mem != 0)
         {
            delete[] mem;
            mem = 0;
         }
      }

      template <class T>
      uint32 ArraySize(const T& array)
      {
         return sizeof(array)/sizeof(array[0]);
      }

      inline void SwapBytes(uint8&)
      {
      }
      inline void SwapBytes(uint16& val)
      {
          val = (val >> 8) | (val << 8);
      }
      inline void SwapBytes(uint32& val)
      {
          val = (val >> 24) | ((val & 0x00ff0000) >> 8) | ((val & 0x0000ff00) << 8) | (val << 24);
      }
      inline void SwapBytes(uint64& val)
      {
         uint32 *val_ptr = (uint32 *)&val;
         uint32 tmp1 = val_ptr[0];
         uint32 tmp2 = val_ptr[1];
         SwapBytes(tmp1);
         SwapBytes(tmp2);
         val_ptr[0] = tmp2;
         val_ptr[1] = tmp1;
      }

      inline void SwapBytes(sint8&)
      {
      }
      inline void SwapBytes(sint16& val)
      {
          SwapBytes((uint16&)val);
      }
      inline void SwapBytes(sint32& val)
      {
          SwapBytes((uint32&)val);
      }
      inline void SwapBytes(sint64& val)
      {
          SwapBytes((uint64&)val);
      }
      inline void SwapBytes(float& val)
      {
          SwapBytes((uint32&)val);
      }
      inline void SwapBytes(double& val)
      {
          SwapBytes((uint64&)val);
      }

      template <class T>
      void SwapBytes(T &val)
      {
         uchar *buffer = (uchar*)&val;
         for (uint32 i = 0; i<sizeof(val)/2; i++)
         {
            uchar b = buffer[i];

            buffer[i] = buffer[sizeof(val)/2 - i - 1];
            buffer[sizeof(val)/2 - i - 1] = b;
         }
      }
      inline bool IsBigEndian()
      {
         union
         {
            sint32 int_val;
            char bytes[4];
         } data;
         data.int_val = 1;

         return (data.bytes[3] == 1);
      }
      inline bool IsLittleEndian()
      {
         return !IsBigEndian();
      }
   }

}

#endif // _TC_UTIL_H_