3 files changed, 4 insertions, 115 deletions

diff --git a/src/stable/archivebinary.cpp b/src/stable/archivebinary.cpp
index 04e80d2..f46bd28 100644
--- a/src/stable/archivebinary.cpp
+++ b/src/stable/archivebinary.cpp
@@ -13,8 +13,7 @@
 
 Bu::ArchiveBinary::ArchiveBinary( Stream &rStream, bool bLoading ) :
     bLoading( bLoading ),
-    rStream( rStream ),
-    nNextID( 1 )
+    rStream( rStream )
 {
 }
 
@@ -236,44 +235,6 @@ 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 );
diff --git a/src/stable/archivebinary.h b/src/stable/archivebinary.h
index d28e5e7..d917249 100644
--- a/src/stable/archivebinary.h
+++ b/src/stable/archivebinary.h
@@ -20,51 +20,6 @@ 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
     {
@@ -116,39 +71,12 @@ namespace Bu
         virtual void read(           Bu::Blob    &rData );
         virtual void read(           Bu::Text    &rData );
         
-        /**
-         * 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;
     };
 }
diff --git a/src/tests/archivetags.cpp b/src/tests/archivetags.cpp
index f0587fd..5c8e0fa 100644
--- a/src/tests/archivetags.cpp
+++ b/src/tests/archivetags.cpp
@@ -25,9 +25,9 @@ Bu::Archive &operator<<( Bu::Archive &ar, const SubThing &st )
 {
     Bu::Archive::Dictionary ds( ar );
 
-    return ar
-        << ar.tag("data") << st.bData
-        << ar.tag("name") << st.tName;
+    ar.tag("data") << st.bData
+    ar.tag("name") << st.tName;
+    return ar;
 }
 
 Bu::Archive &operator>>( Bu::Archive &ar, SubThing &st )