jens@0: /*
jens@0:  *  Base.h
jens@0:  *  Ottoman
jens@0:  *
jens@0:  *  Created by Jens Alfke on 8/18/09.
jens@0:  *  Copyright 2009 Jens Alfke. All rights reserved.
jens@0:  *  BSD-Licensed: See the file "LICENSE.txt" for details.
jens@0:  */
jens@0: 
jens@0: #ifndef _MOOSEYARD_BASE_
jens@0: #define _MOOSEYARD_BASE_
jens@0: #include <stdlib.h>
jens@0: #include <stdint.h>
jens@0: #include <string.h>
jens@0: #include <libkern/OSByteOrder.h>
jens@0: #include <CoreFoundation/CFByteOrder.h>
jens@0: 
jens@0: namespace Mooseyard {
jens@0:     
jens@0:     /** A 32-bit file position/offset. Supports files of up to 4GB. */
jens@0:     typedef uint32_t FilePosition;
jens@0:     const FilePosition kNoFilePosition = (FilePosition)-1L;
jens@0:     
jens@0: 
jens@0:     /** A simple structure representing a range of memory (a pointer plus a length).
jens@0:         It doesn't do any memory management; it just points. */
jens@0:     struct Blob {
jens@0:         const void *bytes;
jens@0:         size_t length;
jens@0:         
jens@0:         Blob()                                                  :bytes(NULL), length(0) { }
jens@0:         Blob (const void *b, size_t len)                        :bytes(b), length(len) { }
jens@0:         Blob (const char *str);
jens@0:         const void* end() const                                 {return (const uint8_t*)bytes+length;}
jens@0:         
jens@0:         operator bool() const                                   {return bytes!=NULL;}
jens@0:         bool operator== (const Blob &b)                         {return bytes==b.bytes && length==b.length;}
jens@0:         bool equals (const Blob &b) const                       {return length==b.length && memcmp(bytes,b.bytes,length)==0;}
jens@0:         void clear()                                            {bytes=NULL; length=0;}
jens@0:     };
jens@0: 
jens@0:     
jens@0:     // Utility to offset a pointer by some number of bytes.
jens@0:     inline const void* offsetBy(const void *src, size_t off)   {return (const uint8_t*)src + off;}
jens@0:     inline void* offsetBy(void *src, size_t off)               {return (uint8_t*)src + off;}
jens@0:     
jens@0:     
jens@0:     #define UNCOPYABLE(CLASS)  private: CLASS(const CLASS&);  CLASS& operator=(const CLASS&)
jens@0:     
jens@0:     
jens@0: #pragma mark -
jens@0: #pragma mark LITTLE-ENDIAN:
jens@0:     
jens@0:     /** A template for numeric types that are always stored in little-endian form.
jens@0:         Useful for structures stored in files that need to be useable on all architectures. */
jens@0:     template <typename INT, typename REP=INT>
jens@0:     class LittleEndian {
jens@0:     public:
jens@0:         inline LittleEndian ();
jens@0:         inline LittleEndian (INT);
jens@0:         inline operator INT() const;
jens@0:         inline LittleEndian& operator= (INT);
jens@0:         inline LittleEndian& operator= (const LittleEndian&);
jens@0:         inline LittleEndian& operator++();
jens@0:         inline LittleEndian& operator--();
jens@0:     private:
jens@0:         static inline REP makeLittle (INT);
jens@0:         static inline INT makeNative (REP);
jens@0:         REP _value;
jens@0:     };
jens@0:     
jens@0:     typedef LittleEndian<double,CFSwappedFloat64> LittleEndianDouble;
jens@0:     
jens@0: 
jens@0:     // Implementation gunk:
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>::LittleEndian ()               :_value() { }
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>::LittleEndian (INT i)          :_value(makeLittle(i)) { }
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>::operator INT() const          {return makeNative(_value);}
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator++() {return *this = (INT)*this + 1;}
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator--() {return *this = (INT)*this - 1;}
jens@0:     
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator= (INT i) {
jens@0:         _value = makeLittle(i);
jens@0:         return *this;
jens@0:     }
jens@0:     template <typename INT, typename REP>
jens@0:     inline LittleEndian<INT,REP>& LittleEndian<INT,REP>::operator= (const LittleEndian<INT,REP> &p) {
jens@0:         _value = p._value;
jens@0:         return *this;
jens@0:     }
jens@0:     
jens@0:     template <> inline uint32_t LittleEndian<uint32_t>::makeLittle (uint32_t i) 
jens@0:     {return OSSwapHostToLittleInt32(i);}
jens@0:     template <> inline uint32_t LittleEndian<uint32_t>::makeNative (uint32_t i) 
jens@0:     {return OSSwapLittleToHostInt32(i);}
jens@0:     template <> inline uint16_t LittleEndian<uint16_t>::makeLittle (uint16_t i) 
jens@0:     {return OSSwapHostToLittleInt16(i);}
jens@0:     template <> inline uint16_t LittleEndian<uint16_t>::makeNative (uint16_t i) 
jens@0:     {return OSSwapLittleToHostInt16(i);}
jens@0:     template <> inline CFSwappedFloat64 LittleEndian<double,CFSwappedFloat64>::makeLittle (double d) 
jens@0:     {return CFConvertDoubleHostToSwapped(d);}
jens@0:     template <> inline double LittleEndian<double,CFSwappedFloat64>::makeNative (CFSwappedFloat64 d) 
jens@0:     {return CFConvertDoubleSwappedToHost(d);}
jens@0:     
jens@0: }
jens@0: 
jens@0: #endif _MOOSEYARD_BASE_