/*

  *  Base.h

  *  Ottoman

  *

  *  Created by Jens Alfke on 8/18/09.

  *  Copyright 2009 Jens Alfke. All rights reserved.

  *  BSD-Licensed: See the file "LICENSE.txt" for details.

  */

 #ifndef _MOOSEYARD_BASE_

 #define _MOOSEYARD_BASE_

 #include <stdlib.h>

 #include <stdint.h>

 #include <string.h>

 #if OSX

 /* OS X specific bits */

 #include <libkern/OSByteOrder.h>

 #include <CoreFoundation/CFByteOrder.h>

 #else

 /* OS X fixup kludge bits */

 #include <cf_fixup.h>

 #include <stdint.h>

 #endif

 namespace Mooseyard {

     /** A 32-bit file position/offset. Supports files of up to 4GB. */

     typedef uint32_t FilePosition;

     const FilePosition kNoFilePosition = (FilePosition)-1L;

     /** A simple structure representing a range of memory (a pointer plus a length).

         It doesn't do any memory management; it just points. */

     struct Blob {

         const void *bytes;

         size_t length;

         Blob()                                                  :bytes(NULL), length(0) { }

         Blob (const void *b, size_t len)                        :bytes(b), length(len) { }

         Blob (const char *str);

         const void* end() const                                 {return (const uint8_t*)bytes+length;}

         operator bool() const                                   {return bytes!=NULL;}

         bool operator== (const Blob &b)                         {return bytes==b.bytes && length==b.length;}

         bool equals (const Blob &b) const                       {return length==b.length && memcmp(bytes,b.bytes,length)==0;}

         void clear()                                            {bytes=NULL; length=0;}

     };

     // Utility to offset a pointer by some number of bytes.

     inline const void* offsetBy(const void *src, size_t off)   {return (const uint8_t*)src + off;}

     inline void* offsetBy(void *src, size_t off)               {return (uint8_t*)src + off;}

     #define UNCOPYABLE(CLASS)  private: CLASS(const CLASS&);  CLASS& operator=(const CLASS&)

 #pragma mark -

 #pragma mark LITTLE-ENDIAN:

     /** A template for numeric types that are always stored in little-endian form.

         Useful for structures stored in files that need to be useable on all architectures. */

     template <typename INT, typename REP=INT>

     class LittleEndian {

     public:

         inline LittleEndian ();

         inline LittleEndian (INT);

         inline operator INT() const;

         inline LittleEndian& operator= (INT);

         inline LittleEndian& operator= (const LittleEndian&);

         inline LittleEndian& operator++();

         inline LittleEndian& operator--();

     private:

         static inline REP makeLittle (INT);

         static inline INT makeNative (REP);

         REP _value;

     };

     typedef LittleEndian<double,CFSwappedFloat64> LittleEndianDouble;

     // Implementation gunk:

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>::LittleEndian ()               :_value() { }

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>::LittleEndian (INT i)          :_value(makeLittle(i)) { }

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>::operator INT() const          {return makeNative(_value);}

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator++() {return *this = (INT)*this + 1;}

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator--() {return *this = (INT)*this - 1;}

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator= (INT i) {

         _value = makeLittle(i);

         return *this;

     }

     template <typename INT, typename REP>

     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator= (const LittleEndian<INT,REP> &p) {

         _value = p._value;

         return *this;

     }

     template <> inline uint32_t LittleEndian<uint32_t>::makeLittle (uint32_t i) 

     {return OSSwapHostToLittleInt32(i);}

     template <> inline uint32_t LittleEndian<uint32_t>::makeNative (uint32_t i) 

     {return OSSwapLittleToHostInt32(i);}

     template <> inline uint16_t LittleEndian<uint16_t>::makeLittle (uint16_t i) 

     {return OSSwapHostToLittleInt16(i);}

     template <> inline uint16_t LittleEndian<uint16_t>::makeNative (uint16_t i) 

     {return OSSwapLittleToHostInt16(i);}

     template <> inline CFSwappedFloat64 LittleEndian<double,CFSwappedFloat64>::makeLittle (double d) 

     {return CFConvertDoubleHostToSwapped(d);}

     template <> inline double LittleEndian<double,CFSwappedFloat64>::makeNative (CFSwappedFloat64 d) 

     {return CFConvertDoubleSwappedToHost(d);}

 }

 #endif /* _MOOSEYARD_BASE_ */