diff -r 000000000000 -r 31a43d94cc26 include/Base.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/Base.h	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,113 @@
+/*
+ *  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>
+#include <libkern/OSByteOrder.h>
+#include <CoreFoundation/CFByteOrder.h>
+
+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_