Ticket #6256: archivable.patch

src/kits/support/Archivable.cpp

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2008, Haiku, Inc.
+ * Copyright (c) 2001-2010, Haiku, Inc.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Erik Jaesler (erik@cgsoftware.com)
+ *      Alex Wilson (yourpalal2@gmail.com)
  */
 
 /*! BArchivable mix-in class defines the archiving protocol.
@@ -13 +14 @@
 
 #include <ctype.h>
 #include <errno.h>
+#include <new>
+#include <set>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string>
@@ -22 +25 @@
 
 #include <AppFileInfo.h>
 #include <Archivable.h>
+#include <ArchivablePrivate.h>
 #include <Entry.h>
 #include <List.h>
 #include <OS.h>
@@ -33 +37 @@
 using std::string;
 using std::vector;
 
+using namespace BPrivate::Archiving;
+
 const char* B_CLASS_FIELD = "class";
 const char* B_ADD_ON_FIELD = "add_on";
 const int32 FUNC_NAME_LEN = 1024;
 
+const char* kArchiveCountField = "_managed_archive_count";
+
 // TODO: consider moving these to a separate module, and making them more
 //  full-featured (e.g., taking NS::ClassName::Function(Param p) instead
 //  of just NS::ClassName)
@@ -209 +217 @@
 
 BArchivable::BArchivable(BMessage* from)
 {
+    if (BUnarchiver::ArchiveIsManaged(from)) {
+        BUnarchiver::PrepareArchive(from);
+        BUnarchiver(from).RegisterArchivable(this);
+    }
 }
 
 
@@ -225 +237 @@
         return B_BAD_VALUE;
     }
 
+    BArchiver::PrepareArchive(into);
+    BArchiver(into).RegisterArchivable(this);
+
     BString name;
     status_t status = demangle_class_name(typeid(*this).name(), name);
     if (status != B_OK)
@@ -250 +265 @@
 }
 
 
-void BArchivable::_ReservedArchivable1() {}
-void BArchivable::_ReservedArchivable2() {}
-void BArchivable::_ReservedArchivable3() {}
+status_t
+BArchivable::AllUnarchived(const BMessage* archive)
+{
+    return B_OK;
+}
 
+// #pragma mark -
 
+BArchiver::BArchiver(BMessage* archive)
+    :
+    fManager(_RetrieveManager(archive)),
+    fArchive(archive)
+{
+    if (!fManager)
+        debugger("BArchiver constructed with unprepared BMessage");
+}
+
+
+BArchiver::~BArchiver()
+{
+    fManager->ArchiverLeaving(this);    
+}
+
+
+status_t
+BArchiver::AddArchivable(const char* name, BArchivable* archivable, bool deep)
+{
+    int32 token;
+    status_t err = fManager->TokenForArchivable(archivable, deep, token);
+    if (err != B_OK)
+        return err;
+
+    return fArchive->AddInt32(name, token);
+}
+
+
+bool
+BArchiver::AddOptional(const char* name, BArchivable* archivable)
+{
+    int32 token;
+    status_t err = fManager->TokenForOptional(archivable, token);
+    if (err != B_OK)
+        return false;
+
+    err = fArchive->AddInt32(name, token);
+
+    return (err == B_OK);
+}
+
+
+status_t
+BArchiver::AddPendingArchival(const char* name, BArchivable* archivable)
+{
+    if (AddOptional(name, archivable))
+        return B_OK;
+
+    return fManager->AddTokenPendingArchival(fArchive, name, archivable);
+}
+
+
+BMessage*
+BArchiver::PrepareArchive(BMessage* archive)
+{
+    BArchiveManager* manager = _RetrieveManager(archive);
+    if (!manager)
+        manager = new BArchiveManager(archive);
+    manager->Acquire();
+    return archive;
+}
+
+
+void
+BArchiver::RegisterArchivable(const BArchivable* archivable)
+{
+    fManager->RegisterArchivable(archivable);
+}
+
+
+BArchiveManager*
+BArchiver::_RetrieveManager(BMessage* archive)
+{
+    return BManagerBase::ArchiveManager(archive);
+}
+
+
 // #pragma mark -
 
 
+BUnarchiver::BUnarchiver(const BMessage* archive)
+    :
+    fManager(_RetrieveManager(const_cast<BMessage*>(archive))),
+    fArchive(archive)
+{
+    if (!fManager) {
+        syslog(LOG_ERR, "BUnarchiver constructed with"
+            " unprepared or unmanaged BMessage");
+    }
+}
+
+
+BUnarchiver::~BUnarchiver()
+{
+    if (fManager)
+        fManager->UnarchiverLeaving(this);
+}
+
+
+status_t
+BUnarchiver::FindArchivable(const char* name, BArchivable** archivable)
+{
+    return FindArchivable(name, 0, archivable);
+}
+
+
+status_t
+BUnarchiver::FindArchivable(const char* name,
+    int32 index, BArchivable** archivable)
+{
+    _CallDebuggerIfManagerNull();
+
+    if (archivable == NULL)
+        return B_BAD_VALUE;
+
+    int32 token;
+    status_t err = fArchive->FindInt32(name, index, &token);
+    if (err != B_OK)
+        return err;
+
+    return fManager->ArchivableForToken(archivable, token);
+}
+
+
+status_t
+BUnarchiver::EnsureUnarchived(const char* name, int32 index)
+{
+    BArchivable* retriever;
+    return FindArchivable(name, index, &retriever);
+}
+
+
+const BMessage*
+BUnarchiver::ArchiveMessage() const
+{
+    return fArchive;
+}
+
+
+bool
+BUnarchiver::ArchiveIsManaged(BMessage* archive)
+{
+    // managed child archives will return here
+    if (BManagerBase::ManagerPointer(archive))
+        return true;
+
+    // managed top level archives return here
+    int32 dummy;
+    if (archive->FindInt32(kArchiveCountField, &dummy) == B_OK)
+        return true;
+
+    return false;
+}
+
+
+BMessage*
+BUnarchiver::PrepareArchive(BMessage* archive)
+{
+    // this check allows PrepareArchive to be
+    // called on new or old-style archives
+    if (BUnarchiver::ArchiveIsManaged(archive)) {
+        BUnarchiveManager* manager = _RetrieveManager(archive);
+        if (!manager)
+            manager = new BUnarchiveManager(archive);
+        manager->Acquire();
+    }
+    return archive;
+}
+
+
+void
+BUnarchiver::RegisterArchivable(BArchivable* archivable)
+{
+    _CallDebuggerIfManagerNull();
+    fManager->RegisterArchivable(archivable);
+}
+
+
+BUnarchiveManager*
+BUnarchiver::_RetrieveManager(BMessage* archive)
+{
+    return BManagerBase::UnarchiveManager(archive);
+}
+
+
+void
+BUnarchiver::_CallDebuggerIfManagerNull()
+{
+    if (!fManager)
+        debugger("BUnarchiver used with legacy or unprepared archive.");
+}
+
+
+// #pragma mark -
+
+
+namespace {
+    BString
+    ArchiveFieldNameForToken(int32 token)
+    {
+        return BString("managed_archivable_") << token;
+    }
+}
+
+
+// #pragma mark -
+
+
+BArchiveManager*
+BManagerBase::ArchiveManager(BMessage* archive)
+{
+    BManagerBase* manager = ManagerPointer(archive);
+    if (!manager)
+        return NULL;
+    
+    if (manager->fType == ARCHIVE_MANAGER)
+        return static_cast<BArchiveManager*>(manager);
+    
+    debugger("More calls to BArchiver::PrepareMessage() than BArchivers created");
+    return NULL;
+}
+
+
+BUnarchiveManager*
+BManagerBase::UnarchiveManager(BMessage* archive)
+{
+    BManagerBase* manager = ManagerPointer(archive);
+    if (!manager)
+        return NULL;
+    
+    if (manager->fType == UNARCHIVE_MANAGER)
+        return static_cast<BUnarchiveManager*>(manager);
+    
+    debugger("More calls to BUnarchiver::PrepareMessage()"
+        " than BUnarchivers created");
+
+    return NULL;
+}
+
+
+// #pragma mark -
+
+
+BArchiveManager::BArchiveManager(BMessage* topLevelArchive)
+    :
+    BManagerBase(topLevelArchive, BManagerBase::ARCHIVE_MANAGER),
+    fTokenMap(),
+    fPendingActions(20, true),
+    fRefcount(0)
+{
+}
+
+
+BArchiveManager::~BArchiveManager()
+{
+    _CompletePendingActions();
+    fTopLevelArchive->AddInt32(kArchiveCountField, fTokenMap.size());
+}
+
+
+status_t
+BArchiveManager::TokenForArchivable(BArchivable* archivable,
+    bool deep, int32& _token)
+{
+    if (TokenForOptional(archivable, _token) == B_OK)
+        return B_OK;
+
+    _token = fTokenMap.size();
+    fTokenMap[archivable] = _token;
+
+    status_t err = _ArchiveObject(archivable, _token, deep);
+    if (err != B_OK)
+        fTokenMap.erase(archivable);    
+    return err; 
+}
+
+
+status_t
+BArchiveManager::TokenForOptional(BArchivable* archivable, int32& _token)
+{
+    if (!archivable) {
+        _token = -42;
+        return B_OK;
+    }
+
+    std::map<const BArchivable*, int32>::iterator it = fTokenMap.find(archivable);
+    if (it == fTokenMap.end())
+        return B_ERROR;
+
+    _token = it->second;
+    return B_OK;
+}
+
+
+status_t
+BArchiveManager::AddTokenPendingArchival(BMessage* into, const char* name,
+    BArchivable* archivable)
+{
+    PendingAction* action = new(std::nothrow) PendingAction();
+    if (action && fPendingActions.AddItem(action)) {
+        action->intoArchive = into;
+        action->archiveField = name;
+        action->requested = archivable;
+        return B_OK;
+    }
+
+    return B_NO_MEMORY;
+}
+
+
+void
+BArchiveManager::ArchiverLeaving(const BArchiver* archiver)
+{
+    if (--fRefcount == 0)
+        delete this;
+}
+
+
+void
+BArchiveManager::Acquire()
+{
+    fRefcount++;
+}
+
+
+void
+BArchiveManager::RegisterArchivable(const BArchivable* archivable)
+{
+    if (fTokenMap.size() == 0)
+        fTokenMap[archivable] = 0;
+}
+
+
+status_t
+BArchiveManager::_ArchiveObject(BArchivable* object, int32 token, bool deep)
+{
+    BMessage childArchive;
+    MarkArchive(&childArchive);
+
+    int32 pendingActionsCount = fPendingActions.CountItems();
+    status_t err = object->Archive(&childArchive, deep);
+
+    if (err == B_OK && !_ProcessNewPendingActions(
+            pendingActionsCount, &childArchive, token, err)) {
+        return fTopLevelArchive->AddMessage(
+            ArchiveFieldNameForToken(token), &childArchive);
+    }
+
+    return err;
+}
+
+
+/*!
+    \retval true there are valid pending actions for this archive
+    \retval false there are no valid pending actions
+*/
+bool
+BArchiveManager::_ProcessNewPendingActions(int32 start, BMessage* forArchive,
+    int32 token, status_t error)
+{
+    BMessage* archive = NULL;
+    for (int32 index = fPendingActions.CountItems() -1; index >= start; index --) {
+        PendingAction* action = fPendingActions.ItemAt(index);
+        BMessage*& currentArchive = action->intoArchive;
+
+        if (currentArchive == forArchive) {
+            if (error != B_OK) {
+                fPendingActions.RemoveItemAt(index);
+                continue;
+            }
+            if (archive == NULL)
+                archive = new BMessage(*forArchive);
+            currentArchive = archive;
+            action->archiveToken = token;
+        }
+    }
+    return (error == B_OK && archive != NULL);
+}
+
+
+void
+BArchiveManager::_CompletePendingActions()
+{
+    if (fPendingActions.CountItems() == 0)
+        return;
+
+
+    for (int32 i = fPendingActions.CountItems() - 1; i >= 0; i--) {
+        PendingAction* action = fPendingActions.ItemAt(i);
+
+        int32 token;
+        if (TokenForOptional(action->requested, token) == B_OK)
+            action->intoArchive->AddInt32(action->archiveField, token);
+    }
+
+    std::set<BMessage*> finishedMessages;
+    finishedMessages.insert(fTopLevelArchive);
+
+    for (int32 i = fPendingActions.CountItems() - 1; i >= 0; i--) {
+
+        PendingAction* action = fPendingActions.ItemAt(i);
+        BMessage* archive = action->intoArchive;
+        int32 token = action->archiveToken;
+
+        if ((finishedMessages.insert(archive)).second == true) {
+            fTopLevelArchive->AddMessage(ArchiveFieldNameForToken(token),
+                archive);
+            delete archive;
+        }
+    }
+}
+
+
+// #pragma mark -
+
+
+BUnarchiveManager::BUnarchiveManager(BMessage* archive)
+    :
+    BManagerBase(archive, BManagerBase::UNARCHIVE_MANAGER),
+    fObjects(NULL),
+    fObjectCount(0),
+    fTokensInProgress(),
+    fRefcount(0)
+{
+    archive->FindInt32(kArchiveCountField, &fObjectCount);
+    fObjects = new ArchiveInfo[fObjectCount];
+
+    fTokensInProgress.push(0);
+    // fObjects[0] is a placeholder representing the
+    // BArchivable that has created us, and fTopLevelArchive
+    for (int32 i = 1; i < fObjectCount; i++)
+        _ArchiveForToken(&fObjects[i].archive, i);
+}
+
+
+BUnarchiveManager::~BUnarchiveManager()
+{
+    _EnterDestructor();
+
+    if (fObjects[0].archivable->AllUnarchived(fTopLevelArchive) != B_OK)
+        syslog(LOG_ERR, "AllUnarchived failed for root object.");
+
+    for (int32 i = 1; i < fObjectCount; i++) {
+        BArchivable*& archivable = fObjects[i].archivable;
+        if (archivable && 
+            (archivable->AllUnarchived(&fObjects[i].archive) != B_OK)) {
+
+            syslog(LOG_ERR, "AllUnarchived failed, BArchivable"
+                " object will be deleted");
+            delete archivable;
+            archivable = NULL;
+        }
+    }
+    delete[] fObjects;
+}
+
+
+status_t
+BUnarchiveManager::ArchivableForToken(BArchivable** _archivable, int32 token)
+{
+    if (!_archivable || token > fObjectCount)
+        return B_BAD_VALUE;
+
+    if (token < 0) {
+        *_archivable = NULL;
+        return B_OK;
+    }
+
+    status_t err = B_OK;
+    if (!fObjects[token].archivable) {
+        if (!_InDestructor())
+            err = _InstantiateObjectForToken(token);
+        else {
+            syslog(LOG_ERR, "Object requested from AllUnarchived()"
+                " was not previously instantiated");
+            err = B_ERROR;
+        }
+    }
+
+    *_archivable = fObjects[token].archivable;
+    return err;
+}
+
+
+void
+BUnarchiveManager::RegisterArchivable(BArchivable* archivable)
+{
+    fObjects[fTokensInProgress.top()].archivable = archivable;
+    fTokensInProgress.pop();
+}
+
+
+void
+BUnarchiveManager::UnarchiverLeaving(const BUnarchiver* unarchiver)
+{
+    if (--fRefcount == 0)
+        delete this;
+}
+
+
+void
+BUnarchiveManager::Acquire()
+{
+    if (!_InDestructor())
+        fRefcount++;
+}
+
+
+status_t
+BUnarchiveManager::_ArchiveForToken(BMessage* archive, int32 token)
+{
+    status_t err = fTopLevelArchive->FindMessage(
+        ArchiveFieldNameForToken(token), archive);
+
+    if (err == B_OK)
+        MarkArchive(archive);
+
+    return err;
+}
+
+
+status_t
+BUnarchiveManager::_InstantiateObjectForToken(int32 token)
+{
+    fTokensInProgress.push(token);
+    if (!instantiate_object(&fObjects[token].archive)) {
+        fTokensInProgress.pop();
+        return B_ERROR;
+    }
+    return B_OK;
+}
+
+
+bool
+BUnarchiveManager::_InDestructor()
+{
+    return (fRefcount < 0);
+}
+
+
+void
+BUnarchiveManager::_EnterDestructor()
+{
+    fRefcount = -1;
+}
+
+
+// #pragma mark -
+
+
 BArchivable*
 instantiate_object(BMessage* archive, image_id* _id)
 {
@@ -475 +1040 @@
     return find_instantiation_func(name, signature);
 }
 
+// BArchivable binary compatability
+#if __GNUC__ == 2
+
+// TODO: make sure this is the correct signature
+extern "C" status_t
+_ReservedArchivable1__11BArchivable(BArchivable* archivable,
+    const BMessage* archive)
+{
+    return archivable->AllUnarchived(archive);
+}
+
+#elif __GNUC__ > 2
+
+extern "C" status_t
+_ZN11BArchivable20_ReservedArchivable1Ev(BArchivable* archivable,
+    const BMessage* archive)
+{
+    return archivable->AllUnarchived(archive);
+}
+
+#endif // _GNUC__ > 2
+
+void BArchivable::_ReservedArchivable2() {}
+void BArchivable::_ReservedArchivable3() {}
+
+

headers/os/support/Archivable.h

@@ -1 +1 @@
 /*
- * Copyright 2001-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2001-2010, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  */
 #ifndef _ARCHIVABLE_H
@@ -12 +12 @@
 
 class BMessage;
 
+namespace BPrivate {
+namespace Archiving {
+    class BArchiveManager;
+    class BUnarchiveManager;
+}
+}
 
+using BPrivate::Archiving::BArchiveManager;
+using BPrivate::Archiving::BUnarchiveManager;
+
+
 class BArchivable {
-    public:
-        BArchivable(BMessage* from);
-        BArchivable();
-        virtual ~BArchivable(); 
+public:
+    BArchivable(BMessage* from);
+    BArchivable();
+    virtual ~BArchivable(); 
 
-        virtual status_t Archive(BMessage* into, bool deep = true) const;
-        static BArchivable* Instantiate(BMessage* archive);
+    virtual status_t Archive(BMessage* into, bool deep = true) const;
+    static BArchivable* Instantiate(BMessage* archive);
 
-        // Private or reserved
-        virtual status_t Perform(perform_code d, void* arg);
+    virtual status_t Perform(perform_code d, void* arg);
 
-    private:
-        virtual void _ReservedArchivable1();
-        virtual void _ReservedArchivable2();
-        virtual void _ReservedArchivable3();
+    // In the context of an unarchiving session (using BUnarchiver)
+    // returning a value other than B_OK here means this object is
+    // not valid, so it will be deleted, and any further attempts
+    // to retrieve if (via BUnarchiver::FindArchivable()) will give
+    // a NULL pointer. If there was an error, but this object is
+    // still valid, return B_OK.
+    virtual status_t AllUnarchived(const BMessage* archive);
 
-        uint32 _reserved[2];
+private:
+    virtual void _ReservedArchivable2();
+    virtual void _ReservedArchivable3();
+
+    uint32 _reserved[2];
 };
 
 
+class BArchiver {
+public:
+    BArchiver(BMessage* archive);
+    BArchiver(); // not defined
+    ~BArchiver();
+
+            status_t            AddArchivable(const char* name,
+                                    BArchivable* archivable, bool deep = true);
+
+            // AddOptional will only add the object if it has 
+            // already been archived. Whether or not the object is added
+            // should not be crucial to successful archiving
+            // (it should be optional).
+            bool                AddOptional(const char* name,
+                                    BArchivable* archivable);
+
+            status_t            AddPendingArchival(const char* name,
+                                    BArchivable* archivable);
+                // archivable will be added if it is archived in this session
+
+    const   BMessage*           ArchiveMessage() const;
+
+    static  BMessage*           PrepareArchive(BMessage* archive);
+private:
+    friend class BArchivable;
+
+            void                RegisterArchivable(const BArchivable* archivable);
+
+    static  BArchiveManager*    _RetrieveManager(BMessage* archive);
+
+    BArchiveManager*            fManager;
+    BMessage*                   fArchive;
+};
+
+
+class BUnarchiver {
+public:
+    BUnarchiver(const BMessage* archive);
+    BUnarchiver(); // not defined
+    ~BUnarchiver();
+
+            status_t            FindArchivable(const char* name,
+                                    BArchivable** archivable);
+
+            status_t            FindArchivable(const char* name, int32 index,
+                                    BArchivable** archivable);
+
+            status_t            EnsureUnarchived(const char* name, int32 index = 0);
+
+    const   BMessage*           ArchiveMessage() const;
+
+    static  bool                ArchiveIsManaged(BMessage* archive);
+    static  BMessage*           PrepareArchive(BMessage* archive);
+private:
+    friend class BArchivable;
+
+            void                RegisterArchivable(BArchivable* archivable);
+
+    static  BUnarchiveManager*  _RetrieveManager(BMessage* archive);
+            void                _CallDebuggerIfManagerNull();
+
+            BUnarchiveManager*  fManager;
+    const   BMessage*           fArchive;
+};
+
+
 // global functions
 
 typedef BArchivable* (*instantiation_func)(BMessage*);
 
-BArchivable* instantiate_object(BMessage *from, image_id *id);
-BArchivable* instantiate_object(BMessage *from);
+BArchivable* instantiate_object(BMessage* from, image_id* id);
+BArchivable* instantiate_object(BMessage* from);
 bool validate_instantiation(BMessage* from, const char* className);
 
 instantiation_func find_instantiation_func(const char* className,

headers/private/support/ArchivablePrivate.h

@@ +1 @@
+#ifndef _ARCHIVABLE_PRIVATE_H
+#define _ARCHIVABLE_PRIVATE_H
+/*
+ * Copyright 2010, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <map>
+#include <stack>
+
+#include <String.h>
+#include <ObjectList.h>
+#include <MessagePrivate.h>
+
+#include <Archivable.h>
+
+
+namespace BPrivate {
+namespace Archiving {
+
+
+class BManagerBase {
+public:
+    enum manager_type {
+        ARCHIVE_MANAGER,
+        UNARCHIVE_MANAGER
+    };
+
+    BManagerBase(BMessage* topLevelArchive, manager_type type)
+        :
+        fTopLevelArchive(topLevelArchive),
+        fType(type)
+    {
+        MarkArchive(topLevelArchive);
+    }
+
+
+    ~BManagerBase()
+    {
+        UnmarkArchive(fTopLevelArchive);
+    }
+
+
+    static BManagerBase*
+    ManagerPointer(BMessage* archive)
+    {
+        return static_cast<BManagerBase*>(
+            BMessage::Private(archive).ArchivingPointer());
+    }
+
+
+    static void
+    SetManagerPointer(BMessage* archive, BManagerBase* manager)
+    {
+        BMessage::Private(archive).ArchivingPointer() = static_cast<void*>(manager);
+    }
+
+
+    void
+    MarkArchive(BMessage* archive)
+    {
+        BManagerBase* manager = ManagerPointer(archive);
+        if (manager != NULL && manager != this)
+            debugger("Overlapping managed archiving/unarchiving sessions!");
+
+        SetManagerPointer(archive, this);
+    }
+
+
+    void
+    UnmarkArchive(BMessage* archive)
+    {
+        BManagerBase* manager = ManagerPointer(archive);
+        if (manager == this)
+            SetManagerPointer(archive, NULL);
+        else
+            debugger("Overlapping managed archiving/unarchiving sessions!");
+    }
+
+
+    static  BArchiveManager*    ArchiveManager(BMessage* archive);
+    static  BUnarchiveManager*  UnarchiveManager(BMessage* archive);
+
+protected:
+    BMessage*       fTopLevelArchive;
+    manager_type    fType;
+};
+
+
+struct PendingAction {
+        PendingAction()
+        :
+        requested(NULL),
+        intoArchive(NULL),
+        archiveField(NULL),
+        archiveToken(0)
+    {
+    }
+
+    BArchivable*    requested;
+    BMessage*       intoArchive;
+    BString         archiveField;
+    int32           archiveToken;
+};
+
+
+class BArchiveManager: public BManagerBase {
+public:
+    BArchiveManager(BMessage* topLevelArchive);
+    ~BArchiveManager();
+
+            status_t    TokenForArchivable(BArchivable* archivable,
+                            bool deep, int32& _token);
+
+            status_t    TokenForOptional(BArchivable* archivable,
+                            int32& _token);
+
+            status_t    AddTokenPendingArchival(BMessage* into,
+                            const char* archiveField, BArchivable* archivable);
+
+            void        ArchiverLeaving(const BArchiver* archiver);
+            void        Acquire();
+            void        RegisterArchivable(const BArchivable* archivable);
+
+private:
+            status_t    _ArchiveObject(BArchivable* object,
+                            int32 token, bool deep);
+            bool        _ProcessNewPendingActions(int32 startIndex,
+                            BMessage* forArchive, int32 token, status_t error);
+            void        _CompletePendingActions();
+
+    std::map<const BArchivable*, int32> fTokenMap;
+    BObjectList<PendingAction>          fPendingActions;
+    int32                               fRefcount;
+};
+
+
+struct ArchiveInfo {
+    ArchiveInfo()
+        :
+        archivable(NULL),
+        archive()
+    {
+    }
+
+    bool
+    operator<(const ArchiveInfo& other)
+    {
+        return archivable < other.archivable;
+    }
+
+    BArchivable*    archivable;
+    BMessage        archive;
+};
+
+
+class BUnarchiveManager: public BManagerBase {
+public:
+    BUnarchiveManager(BMessage* topLevelArchive);
+    ~BUnarchiveManager();
+
+            status_t        ArchivableForToken(BArchivable** archivable, int32 token);
+            void            RegisterArchivable(BArchivable* archivable);
+            void            UnarchiverLeaving(const BUnarchiver* archiver);
+            void            Acquire();
+
+private:
+            status_t        _ArchiveForToken(BMessage* archive, int32 token);
+            status_t        _InstantiateObjectForToken(int32 token);
+            bool            _InDestructor();
+            void            _EnterDestructor();
+
+    ArchiveInfo*            fObjects;
+    int32                   fObjectCount;
+    std::stack<int32>       fTokensInProgress;
+    int32                   fRefcount;
+};
+
+
+} // namespace Archiving
+} // namespace BPrivate
+
+#endif

headers/os/app/Message.h

@@ -1 +1 @@
 /*
- * Copyright 2005-2009, Haiku Inc. All Rights Reserved.
+ * Copyright 2005-2010, Haiku Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -320 +320 @@
         BMessage*       fQueueLink;
             // fQueueLink is used by BMessageQueue to build a linked list
 
-        uint32          fReserved[9];
+        void*           fArchivingPointer;
 
+        uint32          fReserved[8];
+
                         // deprecated
                         BMessage(BMessage *message);
 

headers/private/app/MessagePrivate.h

@@ -1 +1 @@
 /*
- * Copyright 2005-2009, Haiku Inc. All rights reserved.
+ * Copyright 2005-2010, Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -13 +13 @@
 #include <MessengerPrivate.h>
 #include <TokenSpace.h>
 
-
 #define MESSAGE_BODY_HASH_TABLE_SIZE    5
 #define MAX_DATA_PREALLOCATION          B_PAGE_SIZE * 10
 #define MAX_FIELD_PREALLOCATION         50
@@ -191 +190 @@
                 reply, sendTimeout, replyTimeout);
         }
 
+
+        void*&  
+        ArchivingPointer()
+        {
+            return fMessage->fArchivingPointer;
+        }
+
         // static methods
 
         static status_t