ArchiveBase/Archive renamed. More to come.

23 files changed, 501 insertions, 590 deletions

diff --git a/src/stable/archival.cpp b/src/stable/archival.cpp
deleted file mode 100644
index 227e25d..0000000
--- a/src/stable/archival.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#include "bu/archival.h"
-
-Bu::Archival::Archival()
-{
-}
-
-Bu::Archival::~Archival()
-{
-}
-
-Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, const Bu::Archival &p)
-{
-    const_cast<Bu::Archival &>(p).archive( s );
-    return s;
-}
-
-Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, Bu::Archival &p)
-{
-    p.archive( s );
-    return s;
-}
-
-Bu::ArchiveBase &Bu::operator>>(Bu::ArchiveBase &s, Bu::Archival &p)
-{
-    p.archive( s );
-    return s;
-}
-
diff --git a/src/stable/archival.h b/src/stable/archival.h
deleted file mode 100644
index f7122bc..0000000
--- a/src/stable/archival.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#ifndef BU_ARCHIVAL_H
-#define BU_ARCHIVAL_H
-
-#include "bu/archivebase.h"
-
-namespace Bu
-{
-    /**
-     * The base class for any class you want to archive.  Simply include this as
-     * a base class, implement the purely virtual archive function and you've
-     * got an easily archiveable class.
-     *
-     * Archival: "of or pertaining to archives or valuable records; contained
-         * in or comprising such archives or records."
-     */
-    class Archival
-    {
-    public:
-        /**
-         * Does nothing, here for completeness.
-         */
-        Archival();
-
-        /**
-         * Here to ensure the deconstructor is virtual.
-         */
-        virtual ~Archival();
-
-        /**
-         * This is the main workhorse of the archive system, just override and
-         * you've got a archiveable class.  A reference to the Archive
-         * used is passed in as your only parameter, query it to discover if
-         * you are loading or saving.
-         * @param ar A reference to the Archive object to use.
-         */
-        virtual void archive( class ArchiveBase &ar )=0;
-    };
-
-    ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
-    ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
-    ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
-
-}
-
-#endif
diff --git a/src/stable/archive.cpp b/src/stable/archive.cpp
index 69447fb..df9b1ff 100644
--- a/src/stable/archive.cpp
+++ b/src/stable/archive.cpp
@@ -6,15 +6,8 @@
  */
 
 #include "bu/archive.h"
-#include "bu/stream.h"
-#include "bu/archival.h"
 
-#include "bu/sio.h"
-
-Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
-    bLoading( bLoading ),
-    rStream( rStream ),
-    nNextID( 1 )
+Bu::Archive::Archive()
 {
 }
 
@@ -22,78 +15,183 @@ Bu::Archive::~Archive()
 {
 }
 
-void Bu::Archive::write( const void *pData, size_t nSize )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, bool p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, char p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, signed char p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, unsigned char p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, signed short p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, unsigned short p)
 {
-    if( nSize == 0 || pData == NULL )
-        return;
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
 
-    rStream.write( (const char *)pData, nSize );
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, signed int p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-void Bu::Archive::read( void *pData, size_t nSize )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, unsigned int p)
 {
-    if( nSize == 0 || pData == NULL )
-        return;
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
 
-    if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
-        throw Bu::ExceptionBase("Insufficient data to unarchive object.");
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, signed long p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-void Bu::Archive::close()
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, unsigned long p)
 {
-    rStream.close();
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-bool Bu::Archive::isLoading()
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, signed long long p)
 {
-    return bLoading;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-uint32_t Bu::Archive::getID( const void *ptr )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, unsigned long long p)
 {
-    if( hPtrID.has( (ptrdiff_t)ptr ) )
-        return hPtrID.get( (ptrdiff_t)ptr );
-    hPtrID.insert( (ptrdiff_t)ptr, nNextID );
-    return nNextID++;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-void Bu::Archive::assocPtrID( void **ptr, uint32_t id )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, float p)
 {
-    if( hPtrID.has( id ) )
-    {
-        *ptr = (void *)hPtrID.get( id );
-        return;
-    }
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
 
-    if( !hPtrDest.has( id ) )
-        hPtrDest.insert( id, List<void **>() );
-            
-    hPtrDest[id].getValue().append( ptr );
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, double p)
+{
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
-void Bu::Archive::readID( const void *ptr, uint32_t id )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, long double p)
 {
-    hPtrID.insert( id, (ptrdiff_t)ptr );
+    ar.write( &p, sizeof(p) );
+    return ar;
+}
 
-    if( hPtrDest.has( id ) )
-    {
-        Bu::List<void **> &l = hPtrDest.get( id );
-        for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
-        {
-            *(*i) = (void *)ptr;
-        }
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, bool &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
 
-        hPtrDest.erase( id );
-    }
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, char &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, signed char &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, unsigned char &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, signed short &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, unsigned short &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, signed int &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, unsigned int &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, signed long &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, unsigned long &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, signed long long &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, unsigned long long &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, float &p)
+{
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
-void Bu::Archive::setProperty( const Bu::Blob &rKey, const Bu::Variant &rValue )
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, double &p)
 {
-    hProps.insert( rKey, rValue );
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
-Bu::Variant Bu::Archive::getProperty( const Bu::Blob &rKey ) const
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, long double &p)
 {
-    return hProps.get( rKey );
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
diff --git a/src/stable/archive.h b/src/stable/archive.h
index b6cc2a9..45d9af6 100644
--- a/src/stable/archive.h
+++ b/src/stable/archive.h
@@ -5,123 +5,82 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#ifndef BU_ARCHIVE_H
-#define BU_ARCHIVE_H
+#ifndef BU_ARCHIVE_BASE_H
+#define BU_ARCHIVE_BASE_H
 
 #include <stdint.h>
-#include "bu/archivebase.h"
-#include "bu/hash.h"
-#include "bu/util.h"
+#include <unistd.h>
+
 #include "bu/variant.h"
 #include "bu/blob.h"
 
 namespace Bu
 {
-    class Archival;
-    class Stream;
-
-    /**
-     * Provides a framework for serialization of objects and primitives.  The
-     * archive will handle any basic primitive, a few special types, like char *
-     * strings, as well as STL classes and anything that inherits from the
-     * Archival class.  Each Archive operates on a Stream, so you can send the
-     * data using an Archive almost anywhere.
-     *
-     * In order to use an Archive to store something to a file, try something
-     * like:
-     *@code
-     * File sOut("output", "wb"); // This is a stream subclass
-     * Archive ar( sOut, Archive::save );
-     * ar << myClass;
-     @endcode
-     * In this example myClass is any class that inherits from Archival.  When
-     * the storage operator is called, the Archival::archive() function in the
-     * myClass object is called with a reference to the Archive.  This can be
-     * handled in one of two ways:
-     *@code
-     * void MyClass::archive( Archive &ar )
-     * {
-     *  ar && sName && nAge && sJob;
-     * }
-     @endcode
-     * Here we don't worry about weather we're loading or saving by using the
-     * smart && operator.  This allows us to write very consistent, very simple
-     * archive functions that really do a lot of work.  If we wanted to do
-     * something different in the case of loading or saving we would do:
-     *@code
-     * void MyClass::archive( Archive &ar )
-     * {
-     *  if( ar.isLoading() )
-     *  {
-     *      ar >> sName >> nAge >> sJob;
-     *  } else
-     *  {
-     *      ar << sName << nAge << sJob;
-     *  }
-     * }
-     @endcode
-     * Archive currently does not provide facility to make fully portable
-     * archives.  For example, it will not convert between endianness for you,
-     * nor will it take into account differences between primitive sizes on
-     * different platforms.  This, at the moment, is up to the user to ensure.
-     * One way of dealing with the latter problem is to make sure and use
-     * explicit primitive types from the stdint.h header, i.e. int32_t.
-     */
-    class Archive : public ArchiveBase
+    class Archive
     {
-    private:
-        bool bLoading;
     public:
-        bool isLoading();
-
+        Archive();
+        virtual ~Archive();
+        
         enum
         {
             load    =   true,
             save    =   false
         };
         
-        Archive( Stream &rStream, bool bLoading );
-        virtual ~Archive();
-        virtual void close();
-
-        virtual void write( const void *pData, size_t iSize );
-        virtual void read( void *pData, size_t iSize );
-        
-        /**
-         * For storage, get an ID for the pointer to the object you're going to
-         * write.
-         */
-        uint32_t getID( const void *ptr );
-
-        /**
-         * For loading.  Assosiates an empty pointer with an id.  When you wind
-         * up loading an id reference to a pointer for an object that may or
-         * may not have loaded yet, call this with the id, if it has been loaded
-         * already, you'll immediately get a pointer, if not, it will write one
-         * for you when the time comes.
-         */
-        void assocPtrID( void **ptr, uint32_t id );
-
-        /**
-         * For loading.  Call this when you load an object that other things may
-         * have pointers to.  It will assosiate every pointer that's been
-         * registered with assocPtrID to the pointer passed in, and id passed
-         * in.  It will also set things up so future calls to assocPtrID will
-         * automatically succeed immediately.
-         */
-        void readID( const void *ptr, uint32_t id );
+        virtual void close()=0;
+        virtual void write( const void *pData, size_t iLength )=0;
+        virtual void read( void *pData, size_t iLength )=0;
+        virtual bool isLoading()=0;
 
         virtual void setProperty( const Bu::Blob &rKey,
-                const Bu::Variant &rValue );
-        virtual Bu::Variant getProperty( const Bu::Blob &rKey ) const;
-
-    private:
-        Stream &rStream;
-        uint32_t nNextID;
-        Hash<uint32_t,ptrdiff_t> hPtrID;
-        Hash<uint32_t,List<void **> > hPtrDest;
-        Hash<Bu::Blob, Variant> hProps;
+                const Bu::Variant &rValue )=0;
+        virtual Bu::Variant getProperty( const Bu::Blob &rKey ) const=0;
     };
-}
+
+    template<typename T> Archive &operator&&( Archive &ar, T &dat )
+    {
+        if( ar.isLoading() )
+        {
+            return ar >> dat;
+        }
+        else
+        {
+            return ar << dat;
+        }
+    }
+
+    Archive &operator<<( Archive &ar, bool p );
+    Archive &operator<<( Archive &ar, char p );
+    Archive &operator<<( Archive &ar, signed char p );
+    Archive &operator<<( Archive &ar, unsigned char p );
+    Archive &operator<<( Archive &ar, signed short p );
+    Archive &operator<<( Archive &ar, unsigned short p );
+    Archive &operator<<( Archive &ar, signed int p );
+    Archive &operator<<( Archive &ar, unsigned int p );
+    Archive &operator<<( Archive &ar, signed long p );
+    Archive &operator<<( Archive &ar, unsigned long p );
+    Archive &operator<<( Archive &ar, signed long long p );
+    Archive &operator<<( Archive &ar, unsigned long long p );
+    Archive &operator<<( Archive &ar, float p );
+    Archive &operator<<( Archive &ar, double p );
+    Archive &operator<<( Archive &ar, long double p );
+    
+    Archive &operator>>( Archive &ar, bool &p );
+    Archive &operator>>( Archive &ar, char &p );
+    Archive &operator>>( Archive &ar, signed char &p );
+    Archive &operator>>( Archive &ar, unsigned char &p );
+    Archive &operator>>( Archive &ar, signed short &p );
+    Archive &operator>>( Archive &ar, unsigned short &p );
+    Archive &operator>>( Archive &ar, signed int &p );
+    Archive &operator>>( Archive &ar, unsigned int &p );
+    Archive &operator>>( Archive &ar, signed long &p );
+    Archive &operator>>( Archive &ar, unsigned long &p );
+    Archive &operator>>( Archive &ar, signed long long &p );
+    Archive &operator>>( Archive &ar, unsigned long long &p );
+    Archive &operator>>( Archive &ar, float &p );
+    Archive &operator>>( Archive &ar, double &p );
+    Archive &operator>>( Archive &ar, long double &p );
+};
 
 #endif
diff --git a/src/stable/archivebase.cpp b/src/stable/archivebase.cpp
deleted file mode 100644
index d2d80a1..0000000
--- a/src/stable/archivebase.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#include "bu/archivebase.h"
-
-Bu::ArchiveBase::ArchiveBase()
-{
-}
-
-Bu::ArchiveBase::~ArchiveBase()
-{
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, bool p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, char p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed char p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned char p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed short p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned short p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed int p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned int p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long long p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long long p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, float p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, double p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, long double p)
-{
-    ar.write( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, bool &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, char &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed char &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned char &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed short &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned short &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed int &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned int &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long long &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long long &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, float &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, double &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, long double &p)
-{
-    ar.read( &p, sizeof(p) );
-    return ar;
-}
-
diff --git a/src/stable/archivebase.h b/src/stable/archivebase.h
deleted file mode 100644
index d846c27..0000000
--- a/src/stable/archivebase.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#ifndef BU_ARCHIVE_BASE_H
-#define BU_ARCHIVE_BASE_H
-
-#include <stdint.h>
-#include <unistd.h>
-
-#include "bu/variant.h"
-#include "bu/blob.h"
-
-namespace Bu
-{
-    class ArchiveBase
-    {
-    public:
-        ArchiveBase();
-        virtual ~ArchiveBase();
-
-        virtual void close()=0;
-        virtual void write( const void *pData, size_t iLength )=0;
-        virtual void read( void *pData, size_t iLength )=0;
-        virtual bool isLoading()=0;
-
-        virtual void setProperty( const Bu::Blob &rKey,
-                const Bu::Variant &rValue )=0;
-        virtual Bu::Variant getProperty( const Bu::Blob &rKey ) const=0;
-    };
-
-    template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
-    {
-        if( ar.isLoading() )
-        {
-            return ar >> dat;
-        }
-        else
-        {
-            return ar << dat;
-        }
-    }
-
-    ArchiveBase &operator<<( ArchiveBase &ar, bool p );
-    ArchiveBase &operator<<( ArchiveBase &ar, char p );
-    ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
-    ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
-    ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
-    ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
-    ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
-    ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
-    ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
-    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
-    ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
-    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
-    ArchiveBase &operator<<( ArchiveBase &ar, float p );
-    ArchiveBase &operator<<( ArchiveBase &ar, double p );
-    ArchiveBase &operator<<( ArchiveBase &ar, long double p );
-    
-    ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, char &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, float &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, double &p );
-    ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
-};
-
-#endif
diff --git a/src/stable/archivebinary.cpp b/src/stable/archivebinary.cpp
new file mode 100644
index 0000000..3f05947
--- /dev/null
+++ b/src/stable/archivebinary.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/archivebinary.h"
+#include "bu/stream.h"
+
+#include "bu/sio.h"
+
+Bu::ArchiveBinary::ArchiveBinary( Stream &rStream, bool bLoading ) :
+    bLoading( bLoading ),
+    rStream( rStream ),
+    nNextID( 1 )
+{
+}
+
+Bu::ArchiveBinary::~ArchiveBinary()
+{
+}
+
+void Bu::ArchiveBinary::write( const void *pData, size_t nSize )
+{
+    if( nSize == 0 || pData == NULL )
+        return;
+
+    rStream.write( (const char *)pData, nSize );
+}
+
+void Bu::ArchiveBinary::read( void *pData, size_t nSize )
+{
+    if( nSize == 0 || pData == NULL )
+        return;
+
+    if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
+        throw Bu::ExceptionBase("Insufficient data to unarchive object.");
+}
+
+void Bu::ArchiveBinary::close()
+{
+    rStream.close();
+}
+
+bool Bu::ArchiveBinary::isLoading()
+{
+    return bLoading;
+}
+
+uint32_t Bu::ArchiveBinary::getID( const void *ptr )
+{
+    if( hPtrID.has( (ptrdiff_t)ptr ) )
+        return hPtrID.get( (ptrdiff_t)ptr );
+    hPtrID.insert( (ptrdiff_t)ptr, nNextID );
+    return nNextID++;
+}
+
+void Bu::ArchiveBinary::assocPtrID( void **ptr, uint32_t id )
+{
+    if( hPtrID.has( id ) )
+    {
+        *ptr = (void *)hPtrID.get( id );
+        return;
+    }
+
+    if( !hPtrDest.has( id ) )
+        hPtrDest.insert( id, List<void **>() );
+            
+    hPtrDest[id].getValue().append( ptr );
+}
+
+void Bu::ArchiveBinary::readID( const void *ptr, uint32_t id )
+{
+    hPtrID.insert( id, (ptrdiff_t)ptr );
+
+    if( hPtrDest.has( id ) )
+    {
+        Bu::List<void **> &l = hPtrDest.get( id );
+        for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+            *(*i) = (void *)ptr;
+        }
+
+        hPtrDest.erase( id );
+    }
+}
+
+void Bu::ArchiveBinary::setProperty( const Bu::Blob &rKey, const Bu::Variant &rValue )
+{
+    hProps.insert( rKey, rValue );
+}
+
+Bu::Variant Bu::ArchiveBinary::getProperty( const Bu::Blob &rKey ) const
+{
+    return hProps.get( rKey );
+}
+
diff --git a/src/stable/archivebinary.h b/src/stable/archivebinary.h
new file mode 100644
index 0000000..4c12e02
--- /dev/null
+++ b/src/stable/archivebinary.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ARCHIVE_BINARY_H
+#define BU_ARCHIVE_BINARY_H
+
+#include <stdint.h>
+#include "bu/archive.h"
+#include "bu/hash.h"
+#include "bu/util.h"
+#include "bu/variant.h"
+#include "bu/blob.h"
+
+namespace Bu
+{
+    class Stream;
+
+    /**
+     * Provides a framework for serialization of objects and primitives.  The
+     * archive will handle any basic primitive, a few special types, like char *
+     * strings, as well as STL classes and anything that inherits from the
+     * Archival class.  Each ArchiveBinary operates on a Stream, so you can send the
+     * data using an ArchiveBinary almost anywhere.
+     *
+     * In order to use an ArchiveBinary to store something to a file, try something
+     * like:
+     *@code
+     * File sOut("output", "wb"); // This is a stream subclass
+     * ArchiveBinary ar( sOut, ArchiveBinary::save );
+     * ar << myClass;
+     @endcode
+     * In this example myClass is any class that inherits from Archival.  When
+     * the storage operator is called, the Archival::archive() function in the
+     * myClass object is called with a reference to the ArchiveBinary.  This can be
+     * handled in one of two ways:
+     *@code
+     * void MyClass::archive( ArchiveBinary &ar )
+     * {
+     *  ar && sName && nAge && sJob;
+     * }
+     @endcode
+     * Here we don't worry about weather we're loading or saving by using the
+     * smart && operator.  This allows us to write very consistent, very simple
+     * archive functions that really do a lot of work.  If we wanted to do
+     * something different in the case of loading or saving we would do:
+     *@code
+     * void MyClass::archive( ArchiveBinary &ar )
+     * {
+     *  if( ar.isLoading() )
+     *  {
+     *      ar >> sName >> nAge >> sJob;
+     *  } else
+     *  {
+     *      ar << sName << nAge << sJob;
+     *  }
+     * }
+     @endcode
+     * ArchiveBinary currently does not provide facility to make fully portable
+     * archives.  For example, it will not convert between endianness for you,
+     * nor will it take into account differences between primitive sizes on
+     * different platforms.  This, at the moment, is up to the user to ensure.
+     * One way of dealing with the latter problem is to make sure and use
+     * explicit primitive types from the stdint.h header, i.e. int32_t.
+     */
+    class ArchiveBinary : public Archive
+    {
+    private:
+        bool bLoading;
+    public:
+        bool isLoading();
+
+        ArchiveBinary( Stream &rStream, bool bLoading );
+        virtual ~ArchiveBinary();
+        virtual void close();
+
+        virtual void write( const void *pData, size_t iSize );
+        virtual void read( void *pData, size_t iSize );
+        
+        /**
+         * For storage, get an ID for the pointer to the object you're going to
+         * write.
+         */
+        uint32_t getID( const void *ptr );
+
+        /**
+         * For loading.  Assosiates an empty pointer with an id.  When you wind
+         * up loading an id reference to a pointer for an object that may or
+         * may not have loaded yet, call this with the id, if it has been loaded
+         * already, you'll immediately get a pointer, if not, it will write one
+         * for you when the time comes.
+         */
+        void assocPtrID( void **ptr, uint32_t id );
+
+        /**
+         * For loading.  Call this when you load an object that other things may
+         * have pointers to.  It will assosiate every pointer that's been
+         * registered with assocPtrID to the pointer passed in, and id passed
+         * in.  It will also set things up so future calls to assocPtrID will
+         * automatically succeed immediately.
+         */
+        void readID( const void *ptr, uint32_t id );
+
+        virtual void setProperty( const Bu::Blob &rKey,
+                const Bu::Variant &rValue );
+        virtual Bu::Variant getProperty( const Bu::Blob &rKey ) const;
+
+    private:
+        Stream &rStream;
+        uint32_t nNextID;
+        Hash<uint32_t,ptrdiff_t> hPtrID;
+        Hash<uint32_t,List<void **> > hPtrDest;
+        Hash<Bu::Blob, Variant> hProps;
+    };
+}
+
+#endif
diff --git a/src/stable/array.h b/src/stable/array.h
index ca66213..6069832 100644
--- a/src/stable/array.h
+++ b/src/stable/array.h
@@ -10,7 +10,7 @@
 
 #include <memory>
 #include "bu/exceptionbase.h"
-#include "bu/archivebase.h"
+#include "bu/archive.h"
 #include "bu/sharedcore.h"
 
 namespace Bu
@@ -761,7 +761,7 @@ namespace Bu
     }
 
     template<typename value, int inc, typename valuealloc>
-    ArchiveBase &operator<<( ArchiveBase &ar,
+    Archive &operator<<( Archive &ar,
             const Array<value, inc, valuealloc> &h )
     {
         ar << h.getSize();
@@ -775,7 +775,7 @@ namespace Bu
     }
 
     template<typename value, int inc, typename valuealloc>
-    ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
+    Archive &operator>>(Archive &ar, Array<value, inc, valuealloc> &h )
     {
         h.clear();
         long nSize;
diff --git a/src/stable/hash.h b/src/stable/hash.h
index 0c5bd9e..e515088 100644
--- a/src/stable/hash.h
+++ b/src/stable/hash.h
@@ -12,7 +12,7 @@
 #include "bu/exceptionbase.h"
 #include "bu/list.h"
 #include "bu/util.h"
-#include "bu/archivebase.h"
+#include "bu/archive.h"
 #include "bu/sharedcore.h"
 
 namespace Bu
@@ -1319,7 +1319,7 @@ namespace Bu
 
     template<typename key, typename value, typename a, typename b,
         typename c, typename d>
-    ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
+    Archive &operator<<( Archive &ar, const Hash<key,value,a,b,c,d> &h )
     {
         long iSize = h.getSize();
         ar << iSize;
@@ -1334,7 +1334,7 @@ namespace Bu
 
     template<typename key, typename value, typename a, typename b,
         typename c, typename d>
-    ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
+    Archive &operator>>( Archive &ar, Hash<key,value,a,b,c,d> &h )
     {
         h.clear();
         long nSize;
diff --git a/src/stable/list.h b/src/stable/list.h
index c1a5559..5ef7ce0 100644
--- a/src/stable/list.h
+++ b/src/stable/list.h
@@ -11,7 +11,7 @@
 #include <memory>
 #include "bu/exceptionbase.h"
 #include "bu/sharedcore.h"
-#include "bu/archivebase.h"
+#include "bu/archive.h"
 #include "bu/heap.h"
 
 namespace Bu
@@ -1042,7 +1042,7 @@ namespace Bu
     }
 
     template<typename value, typename a, typename b>
-    ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
+    Archive &operator<<( Archive &ar, const List<value,a,b> &h )
     {
         ar << h.getSize();
         for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
@@ -1054,7 +1054,7 @@ namespace Bu
     }
 
     template<typename value, typename a, typename b>
-    ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
+    Archive &operator>>( Archive &ar, List<value,a,b> &h )
     {
         h.clear();
         long nSize;
diff --git a/src/stable/string.cpp b/src/stable/string.cpp
index ed4e58b..c36b768 100644
--- a/src/stable/string.cpp
+++ b/src/stable/string.cpp
@@ -1520,7 +1520,7 @@ Bu::String &Bu::operator<<( Bu::String &dst, const Bu::String &sIn )
     return dst;
 }
 
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::String &s )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, const Bu::String &s )
 {
     long n = s.getSize();
     ar << n;
@@ -1528,7 +1528,7 @@ Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::String &s )
     return ar;
 }
 
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Bu::String &s )
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, Bu::String &s )
 {
     long n;
     ar >> n;
diff --git a/src/stable/string.h b/src/stable/string.h
index c469580..b4768bb 100644
--- a/src/stable/string.h
+++ b/src/stable/string.h
@@ -14,7 +14,7 @@
 #include "bu/util.h"
 #include "bu/sharedcore.h"
 #include "bu/exceptionbase.h"
-#include "bu/archivebase.h"
+#include "bu/archive.h"
 #include "bu/list.h"
 #include "bu/fmt.h"
 #include "bu/variant.h"
@@ -1051,8 +1051,8 @@ namespace Bu
         return ret;
     }
 
-    ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
-    ArchiveBase &operator>>( ArchiveBase &ar, String &s );
+    Archive &operator<<( Archive &ar, const String &s );
+    Archive &operator>>( Archive &ar, String &s );
 
     template<typename T>
     uint32_t __calcHashCode( const T &k );
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp
index 4751559..3b32daf 100644
--- a/src/tests/cache.cpp
+++ b/src/tests/cache.cpp
@@ -5,8 +5,8 @@
 
 class Something : public Bu::CacheObject<Bu::Uuid, Something>
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, Something &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const Something &s );
 public:
     Something()
     {
@@ -47,8 +47,8 @@ private:
 
 class SubSomethingA : public Something
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingA &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingA &s );
 public:
     SubSomethingA()
     {
@@ -71,8 +71,8 @@ private:
 
 class SubSomethingB : public Something
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingB &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingB &s );
 public:
     SubSomethingB()
     {
@@ -93,32 +93,32 @@ private:
     Bu::String sString;
 };
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s )
+Bu::Archive &operator>>( Bu::Archive &ar, Something &s )
 {
     return ar >> s.uId >> s.sName;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const Something &s )
 {
     return ar << s.uId << s.sName;
 }
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s )
+Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingA &s )
 {
     return ar >> (Something &)s >> s.iNumber;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingA &s )
 {
     return ar << (Something &)s << s.iNumber;
 }
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s )
+Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingB &s )
 {
     return ar >> (Something &)s >> s.sString;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingB &s )
 {
     return ar << (Something &)s << s.sString;
 }
@@ -128,7 +128,7 @@ namespace Bu
     template<>
     void _cacheObjectSave<const Something>( Bu::Stream &s, const Something *pObject )
     {
-        Bu::Archive ar( s, Bu::Archive::save );
+        Bu::ArchiveBinary ar( s, Bu::ArchiveBinary::save );
         if( typeid(*pObject) == typeid(SubSomethingA) )
         {
             ar << (uint8_t)1 << (SubSomethingA &)*pObject;
@@ -147,7 +147,7 @@ namespace Bu
     template<>
     Something *_cacheObjectLoad<Bu::Uuid, Something>( Bu::CacheObject<Bu::Uuid, Something>::Initializer &initObj, const Bu::Uuid &rKey, Bu::Stream &s )
     {
-        Bu::Archive ar( s, Bu::Archive::load );
+        Bu::ArchiveBinary ar( s, Bu::ArchiveBinary::load );
         uint8_t uType;
         ar >> uType;
         switch( uType )
diff --git a/src/tests/cachedel.cpp b/src/tests/cachedel.cpp
index 817757c..fd40994 100644
--- a/src/tests/cachedel.cpp
+++ b/src/tests/cachedel.cpp
@@ -6,8 +6,8 @@
 
 class Something : public Bu::CacheObject<Bu::Uuid, Something>
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, Something &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const Something &s );
 public:
     Something()
     {
@@ -48,8 +48,8 @@ private:
 
 class SubSomethingA : public Something
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingA &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingA &s );
 public:
     SubSomethingA()
     {
@@ -72,8 +72,8 @@ private:
 
 class SubSomethingB : public Something
 {
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s );
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s );
+friend Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingB &s );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingB &s );
 public:
     SubSomethingB()
     {
@@ -94,32 +94,32 @@ private:
     Bu::String sString;
 };
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s )
+Bu::Archive &operator>>( Bu::Archive &ar, Something &s )
 {
     return ar >> s.uId >> s.sName;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const Something &s )
 {
     return ar << s.uId << s.sName;
 }
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s )
+Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingA &s )
 {
     return ar >> (Something &)s >> s.iNumber;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingA &s )
 {
     return ar << (Something &)s << s.iNumber;
 }
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s )
+Bu::Archive &operator>>( Bu::Archive &ar, SubSomethingB &s )
 {
     return ar >> (Something &)s >> s.sString;
 }
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s )
+Bu::Archive &operator<<( Bu::Archive &ar, const SubSomethingB &s )
 {
     return ar << (Something &)s << s.sString;
 }
@@ -129,7 +129,7 @@ namespace Bu
     template<>
     void _cacheObjectSave<const Something>( Bu::Stream &s, const Something *pObject )
     {
-        Bu::Archive ar( s, Bu::Archive::save );
+        Bu::ArchiveBinary ar( s, Bu::ArchiveBinary::save );
         if( typeid(*pObject) == typeid(SubSomethingA) )
         {
             ar << (uint8_t)1 << (SubSomethingA &)*pObject;
@@ -148,7 +148,7 @@ namespace Bu
     template<>
     Something *_cacheObjectLoad<Bu::Uuid, Something>( Bu::CacheObject<Bu::Uuid, Something>::Initializer &initObj, const Bu::Uuid &rKey, Bu::Stream &s )
     {
-        Bu::Archive ar( s, Bu::Archive::load );
+        Bu::ArchiveBinary ar( s, Bu::ArchiveBinary::load );
         uint8_t uType;
         ar >> uType;
         switch( uType )
diff --git a/src/unit/archive.unit b/src/unit/archive.unit
index 58f7d2b..6b975ac 100644
--- a/src/unit/archive.unit
+++ b/src/unit/archive.unit
@@ -8,17 +8,17 @@
 
 #include "bu/membuf.h"
 #include "bu/array.h"
-#include "bu/archive.h"
+#include "bu/archivebinary.h"
 
 using namespace Bu;
 
-suite Archive
+suite ArchiveBinary
 {
     test primitives
     {
         MemBuf mb;
         {
-            Archive ar( mb, Archive::save );
+            ArchiveBinary ar( mb, ArchiveBinary::save );
             ar << (int8_t)1;
             ar << (uint8_t)2;
             ar << (int16_t)3;
@@ -41,7 +41,7 @@ suite Archive
         }
         mb.setPos( 0 );
         {
-            Archive ar( mb, Archive::load );
+            ArchiveBinary ar( mb, ArchiveBinary::load );
             int8_t p1;
             uint8_t p2;
             int16_t p3;
@@ -104,7 +104,7 @@ suite Archive
     {
         MemBuf mb;
         {
-            Archive ar( mb, Archive::save );
+            ArchiveBinary ar( mb, ArchiveBinary::save );
             String sStr("This is a test string.");
             List<int> lList;
             lList.append( 10 );
@@ -117,7 +117,7 @@ suite Archive
         }
         mb.setPos( 0 );
         {
-            Archive ar( mb, Archive::load );
+            ArchiveBinary ar( mb, ArchiveBinary::load );
             String sStr;
             List<int> lList;
             ar >> sStr;
@@ -137,7 +137,7 @@ suite Archive
     {
         MemBuf mb;
         {
-            Archive ar( mb, Archive::save );
+            ArchiveBinary ar( mb, ArchiveBinary::save );
             String sStr("This is a test string.");
             Array<int> lArray;
             lArray.append( 10 );
@@ -150,7 +150,7 @@ suite Archive
         }
         mb.setPos( 0 );
         {
-            Archive ar( mb, Archive::load );
+            ArchiveBinary ar( mb, ArchiveBinary::load );
             String sStr;
             Array<int> lArray;
             ar >> sStr;
@@ -170,7 +170,7 @@ suite Archive
     {
         MemBuf mb;
         {
-            Archive ar( mb, Archive::save );
+            ArchiveBinary ar( mb, ArchiveBinary::save );
             Array<String> lArray;
             lArray.append( "10" );
             lArray.append( "20" );
@@ -181,7 +181,7 @@ suite Archive
         }
         mb.setPos( 0 );
         {
-            Archive ar( mb, Archive::load );
+            ArchiveBinary ar( mb, ArchiveBinary::load );
             Array<String> lArray;
             ar >> lArray;
             unitTest( lArray.getSize() == 4 );
diff --git a/src/unit/myriad.unit b/src/unit/myriad.unit
index 91a89c9..09d92a3 100644
--- a/src/unit/myriad.unit
+++ b/src/unit/myriad.unit
@@ -13,7 +13,7 @@
 #include "bu/array.h"
 
 #include "bu/sio.h"
-#include "bu/archive.h"
+#include "bu/archivebinary.h"
 #include "bu/md5.h"
 #include "bu/unitsuite.h"
 
@@ -23,8 +23,8 @@ using namespace Bu;
 
 class VerifyObject
 {
-friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo );
-friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo );
+friend Bu::Archive &operator<<( Bu::Archive &ar, const VerifyObject &vo );
+friend Bu::Archive &operator>>( Bu::Archive &ar, VerifyObject &vo );
 public:
     VerifyObject( int iUnits ) :
         iUnits( iUnits ),
@@ -46,7 +46,7 @@ private:
     mutable int iBytesWritten;
 };
 
-Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
+Bu::Archive &operator<<( Bu::Archive &ar, const VerifyObject &vo )
 {
     Md5 sum;
     ar << vo.iUnits;
@@ -70,7 +70,7 @@ Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
     return ar;
 }
 
-Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo )
+Bu::Archive &operator>>( Bu::Archive &ar, VerifyObject &vo )
 {
     Md5 sum;
     ar >> vo.iUnits;
@@ -347,7 +347,7 @@ suite Myriad
                 VerifyObject vo( random()%1024 );
                 {
                     MyriadStream ms = m.openStream( iStream );
-                    Archive ar( ms, Archive::save );
+                    ArchiveBinary ar( ms, ArchiveBinary::save );
                     ar << vo;
                     unitTest( ms.tell() == vo.getBytesWritten() );
                     ms.setSize( ms.tell() );
@@ -366,12 +366,12 @@ suite Myriad
                 VerifyObject vo( random()%1024 );
                 {
                     MyriadStream ms = m.openStream( *i );
-                    Archive ar( ms, Archive::load );
+                    ArchiveBinary ar( ms, ArchiveBinary::load );
                     ar >> vo;
                 }
                 {
                     MyriadStream ms = m.openStream( *i );
-                    Archive ar( ms, Archive::save );
+                    ArchiveBinary ar( ms, ArchiveBinary::save );
                     ar << vo;
                     unitTest( ms.tell() == vo.getBytesWritten() );
                     ms.setSize( ms.tell() );
diff --git a/src/unstable/archivestream.cpp b/src/unstable/archivestream.cpp
index 437c183..90a9599 100644
--- a/src/unstable/archivestream.cpp
+++ b/src/unstable/archivestream.cpp
@@ -7,7 +7,7 @@
 
 #include "bu/archivestream.h"
 
-Bu::ArchiveStream::ArchiveStream( Bu::ArchiveBase &ar ) :
+Bu::ArchiveStream::ArchiveStream( Bu::Archive &ar ) :
     ar( ar ),
     iPos( 0 )
 {
diff --git a/src/unstable/archivestream.h b/src/unstable/archivestream.h
index c694037..da6c6b0 100644
--- a/src/unstable/archivestream.h
+++ b/src/unstable/archivestream.h
@@ -7,7 +7,7 @@
 #ifndef BU_ARCHIVE_STREAM_H
 #define BU_ARCHIVE_STREAM_H
 
-#include "bu/archivebase.h"
+#include "bu/archive.h"
 #include "bu/stream.h"
 
 namespace Bu
@@ -15,7 +15,7 @@ namespace Bu
     class ArchiveStream : public Stream
     {
     public:
-        ArchiveStream( Bu::ArchiveBase &ar );
+        ArchiveStream( Bu::Archive &ar );
         virtual ~ArchiveStream();
 
         virtual void close();
@@ -41,7 +41,7 @@ namespace Bu
         virtual Bu::String getLocation() const;
 
     private:
-        Bu::ArchiveBase &ar;
+        Bu::Archive &ar;
         size iPos;
     };
 }
diff --git a/src/unstable/cachebase.h b/src/unstable/cachebase.h
index 7a54465..f986a89 100644
--- a/src/unstable/cachebase.h
+++ b/src/unstable/cachebase.h
@@ -9,7 +9,7 @@
 #define BU_CACHE_BASE_H
 
 #include "bu/string.h"
-#include "bu/archive.h"
+#include "bu/archivebinary.h"
 #include "bu/hash.h"
 #include "bu/readwritemutex.h"
 #include "bu/mutexlocker.h"
@@ -659,7 +659,7 @@ namespace Bu
     template<typename obtype>
     void _cacheObjectSave( Bu::Stream &s, obtype *pObject )
     {
-        Bu::Archive ar( s, Bu::Archive::save );
+        Bu::ArchiveBinary ar( s, Bu::Archive::save );
         ar << *pObject;
     }
 
@@ -670,7 +670,7 @@ namespace Bu
         Bu::Stream &s
         )
     {
-        Bu::Archive ar( s, Bu::Archive::load );
+        Bu::ArchiveBinary ar( s, Bu::Archive::load );
         obtype *ret = initObject(new obtype());
         ar >> *ret;
         return ret;
diff --git a/src/unstable/myriadcache.h b/src/unstable/myriadcache.h
index 7bba93b..8a1f9db 100644
--- a/src/unstable/myriadcache.h
+++ b/src/unstable/myriadcache.h
@@ -29,7 +29,7 @@ namespace Bu
             {
                 Bu::ReadWriteMutex::ReadLocker l( rwStore );
                 Bu::MyriadStream ms = mStore.openStream( 1 );
-                Bu::Archive ar( ms, Bu::Archive::load );
+                Bu::ArchiveBinary ar( ms, Bu::ArchiveBinary::load );
                 uint8_t uVer;
                 ar >> uVer;
                 switch( uVer )
@@ -118,7 +118,7 @@ namespace Bu
                 return;
 
             Bu::MyriadStream ms = mStore.openStream( 1 );
-            Bu::Archive ar( ms, Bu::Archive::save );
+            Bu::ArchiveBinary ar( ms, Bu::ArchiveBinary::save );
             ar << (uint8_t)0 << hIndex;
             ar.close();
             ms.setSize( ms.tell() );
diff --git a/src/unstable/uuid.cpp b/src/unstable/uuid.cpp
index c5ff943..6642d75 100644
--- a/src/unstable/uuid.cpp
+++ b/src/unstable/uuid.cpp
@@ -170,13 +170,13 @@ template<> bool Bu::__cmpHashKeys<Bu::Uuid>( const Bu::Uuid &a, const Bu::Uuid &
     return a == b;
 }
 
-Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Bu::Uuid &u )
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, Bu::Uuid &u )
 {
     ar.read( u.data, 16 );
     return ar;
 }
 
-Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::Uuid &u )
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, const Bu::Uuid &u )
 {
     ar.write( u.data, 16 );
     return ar;
diff --git a/src/unstable/uuid.h b/src/unstable/uuid.h
index 07ec333..d61a928 100644
--- a/src/unstable/uuid.h
+++ b/src/unstable/uuid.h
@@ -15,8 +15,8 @@ namespace Bu
 {
     class Uuid
     {
-    friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
-    friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
+    friend Bu::Archive &operator>>( Bu::Archive &ar, Uuid &u );
+    friend Bu::Archive &operator<<( Bu::Archive &ar, const Uuid &u );
     public:
         Uuid();
         Uuid( const Uuid &src );
@@ -65,8 +65,8 @@ namespace Bu
         const Uuid &a, const Uuid &b );
 
     class Formatter;
-    Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
-    Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
+    Bu::Archive &operator>>( Bu::Archive &ar, Uuid &u );
+    Bu::Archive &operator<<( Bu::Archive &ar, const Uuid &u );
     Bu::Formatter &operator<<( Bu::Formatter &f, const Uuid &u );
 };