zorba-coders team mailing list archive

[Ghislain Fourny <ghislain.fourny@xxxxxxxxxx>]

Ghislain Fourny has proposed merging lp:~zorba-coders/zorba/jsoniq-static-casts into lp:zorba.

Requested reviews:
  Markos Zaharioudakis (markos-za)
  Matthias Brantner (matthias-brantner)

For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/jsoniq-static-casts/+merge/118961

Simplified JSON items class and fixed some Xml Node static casts to handle JSON items as well.
-- 
https://code.launchpad.net/~zorba-coders/zorba/jsoniq-static-casts/+merge/118961
Your team Zorba Coders is subscribed to branch lp:zorba.

=== modified file 'src/store/naive/json_items.cpp'
--- src/store/naive/json_items.cpp	2012-07-11 15:38:39 +0000
+++ src/store/naive/json_items.cpp	2012-08-09 13:45:44 +0000
@@ -76,6 +76,119 @@
 
 /////////////////////////////////////////////////////////////////////////////////
 //                                                                             //
+//  JSON Item                                                                  //
+//                                                                             //
+/////////////////////////////////////////////////////////////////////////////////
+/******************************************************************************
+
+*******************************************************************************/
+JSONItem::~JSONItem()
+{
+  delete theTree;
+}
+
+/******************************************************************************
+
+*******************************************************************************/
+const simplestore::Collection* JSONItem::getCollection() const
+{
+  if (theTree == NULL)
+  {
+    return NULL;
+  }
+  return theTree->getCollection();
+}
+
+
+/******************************************************************************
+
+*******************************************************************************/
+const TreeId& JSONItem::getTreeId() const
+{
+  ZORBA_ASSERT(theTree);
+  return theTree->getTreeId();
+}
+
+
+/******************************************************************************
+
+*******************************************************************************/
+JSONItem* JSONItem::getRoot() const
+{
+  ZORBA_ASSERT(theTree);
+  return theTree->getRoot();
+}
+
+/******************************************************************************
+
+*******************************************************************************/
+void JSONItem::free()
+{
+  destroy();
+}
+
+/******************************************************************************
+
+*******************************************************************************/
+void JSONItem::destroy()
+{
+  delete this;
+}
+
+/*******************************************************************************
+
+********************************************************************************/
+void JSONItem::fix(Collection* aCollection, const TreeId& aTreeId)
+{
+  ASSERT_INVARIANT();
+  
+  assert(aCollection);
+
+  // Attach
+  assert(getTree() == NULL);
+  setTree(new JSONTree());
+  getTree()->setRoot(this);
+  getTree()->setCollection(aCollection);
+  getTree()->setTreeId(aTreeId);
+  
+  ASSERT_INVARIANT();
+}
+
+/*******************************************************************************
+
+********************************************************************************/
+void JSONItem::unfix()
+{
+  ASSERT_INVARIANT();
+  
+  JSONTree* lTree = getTree();
+  // Detach
+  assert(lTree);
+  delete lTree;
+  setTree(NULL);
+  return;
+
+  ASSERT_INVARIANT();
+}
+
+#ifndef NDEBUG
+/******************************************************************************
+
+*******************************************************************************/
+void JSONItem::assertInvariant() const
+{
+  if (theTree != NULL)
+  {
+    assert(theTree->getCollection() != NULL);
+    assert(theTree->getRoot() != NULL);
+    assert(isThisTreeOfAllDescendants(theTree));
+    assert(theTree->getRoot()->isThisJSONItemInDescendance(this));
+  }
+}
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////
+//                                                                             //
 //  Object                                                                     //
 //                                                                             //
 /////////////////////////////////////////////////////////////////////////////////
@@ -93,36 +206,6 @@
 /******************************************************************************
 
 *******************************************************************************/
-void setJSONRoot(store::Item* aJSONItem, const JSONItem* aRoot)
-{
-  if (aJSONItem->isJSONObject())
-  {
-    assert(dynamic_cast<SimpleJSONObject*>(aJSONItem));
-    SimpleJSONObject* lObject = static_cast<SimpleJSONObject*>(aJSONItem);
-
-    // Only attach or detach allowed - no direct reattach.
-    assert(aRoot == NULL || lObject->theRoot == NULL);
-    lObject->setRoot(aRoot);
-  }
-  else if (aJSONItem->isJSONArray())
-  {
-    assert(dynamic_cast<SimpleJSONArray*>(aJSONItem));
-    SimpleJSONArray* lArray = static_cast<SimpleJSONArray*>(aJSONItem);
-
-    // Only attach or detach allowed - no direct reattach.
-    assert(aRoot == NULL || lArray->theRoot == NULL);
-    lArray->setRoot(aRoot);
-  } 
-  else
-  {
-    assert(false);
-  }
-}
-
-
-/******************************************************************************
-
-*******************************************************************************/
 SimpleJSONObject::~SimpleJSONObject()
 {
   ASSERT_INVARIANT();
@@ -134,7 +217,9 @@
     store::Item* lChild = lIter->second;
     if (getCollection() != NULL && lChild->isJSONItem())
     {
-      setJSONRoot(lChild, NULL);
+      assert(dynamic_cast<JSONItem*>(lChild));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(lChild);
+      lJSONItem->setTree(NULL);
     }
     lName->removeReference();
     lChild->removeReference();
@@ -212,7 +297,9 @@
 
     if (getCollection() != NULL && aValue->isJSONItem())
     {
-      setJSONRoot(lValue, theRoot);
+      assert(dynamic_cast<JSONItem*>(aValue.getp()));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(aValue.getp());
+      lJSONItem->setTree(getTree());
     }
     
     csize lPosition = thePairs.size();
@@ -244,7 +331,7 @@
 
       if (getCollection() != NULL)
       {
-        setJSONRoot(array.getp(), theRoot);
+        array->setTree(getTree());
       }
 
       lValue->removeReference();
@@ -285,7 +372,9 @@
 
   if (getCollection() != NULL && lValue->isJSONItem())
   {
-    setJSONRoot(lValue.getp(), NULL);
+    assert(dynamic_cast<JSONItem*>(lValue.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(lValue.getp());
+    lJSONItem->setTree(NULL);
   }
 
   lKey->removeReference();
@@ -331,7 +420,7 @@
 
       if (getCollection() != NULL && lValue->isJSONItem())
       {
-        setJSONRoot(lValue.getp(), NULL);
+        lValue->setTree(NULL);
       }
 
       // Erasing the corresponding entries.
@@ -381,12 +470,16 @@
   {
     if (lOldValue->isJSONItem())
     {
-      setJSONRoot(lOldValue.getp(), NULL);
+      assert(dynamic_cast<JSONItem*>(lOldValue.getp()));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(lOldValue.getp());
+      lJSONItem->setTree(NULL);
     }
 
     if (aValue->isJSONItem())
     {
-      setJSONRoot(aValue.getp(), theRoot);
+      assert(dynamic_cast<JSONItem*>(aValue.getp()));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(aValue.getp());
+      lJSONItem->setTree(getTree());
     }
   }
 
@@ -441,75 +534,21 @@
 /******************************************************************************
 
 *******************************************************************************/
-void SimpleJSONObject::setRoot(const JSONItem* aRoot)
+void SimpleJSONObject::setTree(JSONTree* aTree)
 {
-  theRoot = aRoot;
+  theTree = aTree;
 
   for (Pairs::iterator lIter = thePairs.begin();
        lIter != thePairs.end();
        ++lIter)
   {
     store::Item* lValue = lIter->second;
-    if (lValue->isJSONObject())
-    {
-      assert(dynamic_cast<SimpleJSONObject*>(lValue));
-      SimpleJSONObject* lObject = static_cast<SimpleJSONObject*>(lValue);
-
-      lObject->setRoot(aRoot);
-    }
-    else if (lValue->isJSONArray())
-    {
-      assert(dynamic_cast<SimpleJSONArray*>(lValue));
-      SimpleJSONArray* lArray = static_cast<SimpleJSONArray*>(lValue);
-      
-      lArray->setRoot(aRoot);
-    }
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleJSONObject::setCollection(SimpleCollection* collection, xs_integer /*pos*/)
-{
-  ASSERT_INVARIANT();
-  // Ensures one either detaches or attaches.
-  assert(collection == NULL || theCollection == NULL);
-
-  theCollection = collection;
-  
-  if (theCollection != NULL)
-  {
-    // Attach
-    setRoot(this);
-  }
-  else 
-  {
-    // Detach
-    setRoot(NULL);
-  }
-  
-  ASSERT_INVARIANT();
-}
-
-
-/******************************************************************************
-
-*******************************************************************************/
-const store::Collection* SimpleJSONObject::getCollection() const
-{
-  if (theRoot == this)
-  {
-    return theCollection;
-  }
-  else if (theRoot != NULL)
-  {
-    return theRoot->getCollection();
-  }
-  else
-  {
-    return NULL;
+    if (lValue->isJSONItem())
+    {
+      assert(dynamic_cast<JSONItem*>(lValue));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(lValue);
+      lJSONItem->setTree(aTree);
+    }
   }
 }
 
@@ -590,34 +629,7 @@
 *******************************************************************************/
 void SimpleJSONObject::assertInvariant() const
 {
-  // Note: only root objects may point to a collection, so if theCollection ==
-  // NULL, it doesn't mean that the object does not belong to a collection.
-  assert(theCollection == NULL || theRoot == this);
-
-  if (theRoot != NULL)
-  {
-    const store::Collection* lCollection = getCollection();
-    assert(lCollection != NULL);
-
-    const SimpleJSONObject* lObject =
-        dynamic_cast<const SimpleJSONObject*>(theRoot);
-    const SimpleJSONArray* lArray =
-        dynamic_cast<const SimpleJSONArray*>(theRoot);
-
-    assert(lObject != NULL || lArray != NULL);
-
-    if (lObject != NULL) 
-    {
-      assert(lObject->isThisRootOfAllDescendants(theRoot));
-      assert(lObject->isThisJSONItemInDescendance(this));
-    }
-    else
-    {
-      assert(lArray->isThisRootOfAllDescendants(theRoot));
-      assert(lArray->isThisJSONItemInDescendance(this));
-    }
-  }
-
+  JSONItem::assertInvariant();
   assert(theKeys.size() == thePairs.size());
 
   for(Keys::iterator lIter = theKeys.begin();
@@ -637,9 +649,9 @@
 /******************************************************************************
 
 *******************************************************************************/
-bool SimpleJSONObject::isThisRootOfAllDescendants(const store::Item* aRoot) const
+bool SimpleJSONObject::isThisTreeOfAllDescendants(const JSONTree* aTree) const
 {
-  if (theRoot != aRoot)
+  if (theTree != aTree)
   {
     return false;
   }
@@ -649,16 +661,8 @@
        ++lIter)
   {
     store::Item* lValue = lIter->second;
-    const SimpleJSONObject* lObject =
-      dynamic_cast<const SimpleJSONObject*>(lValue);
-    const SimpleJSONArray* lArray =
-      dynamic_cast<const SimpleJSONArray*>(lValue);
- 
-   if (lObject != NULL && (!lObject->isThisRootOfAllDescendants(aRoot)))
-    {
-      return false;
-    }
-    else if (lArray != NULL && (!lArray->isThisRootOfAllDescendants(aRoot)))
+    const JSONItem* lJSONItem = dynamic_cast<const JSONItem*>(lValue);
+    if (lJSONItem != NULL && (!lJSONItem->isThisTreeOfAllDescendants(aTree)))
     {
       return false;
     }
@@ -783,7 +787,9 @@
   {
     if (getCollection() != NULL && (*lIter)->isJSONItem())
     {
-      setJSONRoot(*lIter, NULL);
+      assert(dynamic_cast<JSONItem*>(*lIter));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(*lIter);
+      lJSONItem->setTree(NULL);
     }
     (*lIter)->removeReference();
   }
@@ -799,7 +805,9 @@
 
   if (getCollection() != NULL && aValue->isJSONItem())
   {
-    setJSONRoot(aValue.getp(), theRoot);
+    assert(dynamic_cast<JSONItem*>(aValue.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(aValue.getp());
+    lJSONItem->setTree(getTree());
   }
 
   aValue->addReference();
@@ -844,7 +852,9 @@
 
   if (getCollection() != NULL && member->isJSONItem())
   {
-    setJSONRoot(member.getp(), theRoot);
+    assert(dynamic_cast<JSONItem*>(member.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(member.getp());
+    lJSONItem->setTree(getTree());
   }
 
   member->addReference();
@@ -903,7 +913,9 @@
 
     if (getCollection() != NULL && lItem->isJSONItem())
     {
-      setJSONRoot(lItem, theRoot);
+      assert(dynamic_cast<JSONItem*>(lItem));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(lItem);
+      lJSONItem->setTree(getTree());
     }
 
     lItem->addReference();
@@ -924,7 +936,9 @@
 
   if (getCollection() != NULL && lItem->isJSONItem())
   {
-    setJSONRoot(lItem.getp(), NULL);
+    assert(dynamic_cast<JSONItem*>(lItem.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(lItem.getp());
+    lJSONItem->setTree(NULL);
   }
 
   lItem->removeReference();
@@ -948,14 +962,18 @@
 
   if (getCollection() != NULL && lItem->isJSONItem())
   {
-    setJSONRoot(lItem.getp(), NULL);
+    assert(dynamic_cast<JSONItem*>(lItem.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(lItem.getp());
+    lJSONItem->setTree(NULL);
   }
 
   uint64_t pos = cast(aPos) - 1;
 
   if (getCollection() != NULL && value->isJSONItem())
   {
-    setJSONRoot(value.getp(), theRoot);
+    assert(dynamic_cast<JSONItem*>(value.getp()));
+    JSONItem* lJSONItem = static_cast<JSONItem*>(value.getp());
+    lJSONItem->setTree(getTree());
   }
 
   theContent[pos]->removeReference();
@@ -970,27 +988,20 @@
 /******************************************************************************
 
 *******************************************************************************/
-void SimpleJSONArray::setRoot(const JSONItem* aRoot)
+void SimpleJSONArray::setTree(JSONTree* aTree)
 {
-  theRoot = aRoot;
+  theTree = aTree;
 
   for (Members::const_iterator lIter = theContent.begin();
        lIter != theContent.end();
        ++lIter)
   {
-    if ((*lIter)->isJSONObject())
-    {
-      assert(dynamic_cast<SimpleJSONObject*>(*lIter));
-      SimpleJSONObject* lObject = static_cast<SimpleJSONObject*>(*lIter);
-
-      lObject->setRoot(aRoot);
-    }
-    else if ((*lIter)->isJSONArray())
-    {
-      assert(dynamic_cast<SimpleJSONArray*>(*lIter));
-      SimpleJSONArray* lArray = static_cast<SimpleJSONArray*>(*lIter);
-      
-      lArray->setRoot(aRoot);
+    store::Item* lValue = *lIter;
+    if (lValue->isJSONItem())
+    {
+      assert(dynamic_cast<JSONItem*>(lValue));
+      JSONItem* lJSONItem = static_cast<JSONItem*>(lValue);
+      lJSONItem->setTree(aTree);
     }
   }
 }
@@ -1137,100 +1148,25 @@
 }
 
 
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleJSONArray::setCollection(SimpleCollection* collection, xs_integer /*pos*/)
-{
-  ASSERT_INVARIANT();
-  // Ensures one either detaches or attaches.
-  ZORBA_ASSERT(collection == NULL || theCollection == NULL);
-
-  theCollection = collection;
-  
-  if (theCollection != NULL)
-  {
-    // Attach
-    setRoot(this);
-  }
-  else
-  {
-    // Detach
-    setRoot(NULL);
-  }
-  
-  ASSERT_INVARIANT();
-}
-
-
-/******************************************************************************
-
-*******************************************************************************/
-const store::Collection* SimpleJSONArray::getCollection() const
-{
-  if (theRoot == this)
-  {
-    return theCollection;
-  }
-  else if (theRoot != NULL)
-  {
-    return theRoot->getCollection();
-  }
-  else
-  {
-    return NULL;
-  }
-}
-
-
 #ifndef NDEBUG
 
 /******************************************************************************
 
 *******************************************************************************/
-void SimpleJSONArray::assertInvariant() const
-{
-  assert(theCollection == NULL || theRoot == this);
-  if (theRoot != NULL)
-  {
-    const store::Collection* lCollection = getCollection();
-    assert(lCollection != NULL);
-    const SimpleJSONObject* lObject = dynamic_cast<const SimpleJSONObject*>(theRoot);
-    const SimpleJSONArray* lArray = dynamic_cast<const SimpleJSONArray*>(theRoot);
-    assert(lObject != NULL || lArray != NULL);
-    if (lObject != NULL) {
-      assert(lObject->isThisRootOfAllDescendants(theRoot));
-      assert(lObject->isThisJSONItemInDescendance(this));
-    } else {
-      assert(lArray->isThisRootOfAllDescendants(theRoot));
-      assert(lArray->isThisJSONItemInDescendance(this));
-    }
-  }
-}
-
-
-/******************************************************************************
-
-*******************************************************************************/
-bool SimpleJSONArray::isThisRootOfAllDescendants(const store::Item* aRoot) const
-{
-  if(theRoot != aRoot)
+bool SimpleJSONArray::isThisTreeOfAllDescendants(const JSONTree* aTree) const
+{
+  if (getTree() != aTree)
   {
     return false;
   }
+
   for (Members::const_iterator lIter = theContent.begin();
        lIter != theContent.end();
        ++lIter)
   {
-    const SimpleJSONObject* lObject =
-        dynamic_cast<const SimpleJSONObject*>(*lIter);
-    const SimpleJSONArray* lArray =
-        dynamic_cast<const SimpleJSONArray*>(*lIter);
-    if (lObject != NULL && (!lObject->isThisRootOfAllDescendants(aRoot)))
-    {
-      return false;
-    }
-    else if (lArray != NULL && (!lArray->isThisRootOfAllDescendants(aRoot)))
+    store::Item* lValue = (*lIter);
+    const JSONItem* lJSONItem = dynamic_cast<const JSONItem*>(lValue);
+    if (lJSONItem != NULL && (!lJSONItem->isThisTreeOfAllDescendants(aTree)))
     {
       return false;
     }

=== modified file 'src/store/naive/json_items.h'
--- src/store/naive/json_items.h	2012-07-11 15:38:39 +0000
+++ src/store/naive/json_items.h	2012-08-09 13:45:44 +0000
@@ -87,6 +87,52 @@
 
 *******************************************************************************/
 
+class JSONTree
+{
+private:
+  simplestore::Collection* theCollection;
+  TreeId      theId;
+  JSONItem*   theRoot;
+
+public:
+  JSONTree() : theCollection(NULL), theId(), theRoot(NULL)
+  {}
+
+  simplestore::Collection* getCollection() const
+  {
+    return theCollection;
+  }
+
+  void setCollection(simplestore::Collection* aCollection)
+  {
+    theCollection = aCollection;
+  }
+
+  const TreeId& getTreeId() const
+  {
+    return theId;
+  }
+
+  void setTreeId(const TreeId& aId)
+  {
+    theId = aId;
+  }
+
+  JSONItem* getRoot() const
+  {
+    return theRoot;
+  }
+
+  void setRoot(JSONItem* aRoot)
+  {
+    theRoot = aRoot;
+  }
+};
+
+/******************************************************************************
+
+*******************************************************************************/
+
 class JSONItem : public store::Item
 {
 protected:
@@ -95,10 +141,19 @@
 public:
   SYNC_CODE(RCLock* getRCLock() const { return &theRCLock; })
 
-  JSONItem() : store::Item(JSONIQ) {}
-
-  virtual ~JSONItem() {}
-
+  JSONItem() : store::Item(JSONIQ), theTree(NULL) {}
+
+  virtual ~JSONItem();
+  
+  // Returns NULL if in no collection.
+  const simplestore::Collection* getCollection() const;
+  // These two functions are only to be called if in a collection.
+  JSONItem* getRoot() const;
+  const TreeId& getTreeId() const;
+  
+  void fix(Collection* aCollection, const TreeId& aTreeId);
+  void unfix();
+  
   // store API
 
   virtual bool equals(
@@ -109,10 +164,27 @@
     return this == other;
   }
   
-  // store methods
-  // store methods
-
-  virtual const JSONItem* getRoot() = 0;
+  virtual void free();
+  virtual void destroy();
+  
+  // Internal tree management methods
+  virtual void setTree(JSONTree* aTree) = 0;
+  JSONTree* getTree() const
+  {
+    return theTree;
+  }
+
+protected:
+  JSONTree* theTree;
+
+public:
+#ifndef NDEBUG
+  virtual void assertInvariant() const;
+
+  virtual bool isThisTreeOfAllDescendants(const JSONTree* aTree) const = 0;
+
+  virtual bool isThisJSONItemInDescendance(const store::Item* aJSONItem) const = 0;
+#endif
 };
 
 
@@ -156,8 +228,6 @@
   virtual bool rename(
     const store::Item_t& aName,
     const store::Item_t& aNewName) = 0;
-    
-  virtual void setCollection(SimpleCollection* collection, xs_integer pos) = 0;
 };
 
 
@@ -191,19 +261,10 @@
       virtual void close();
   };
 
-protected:
-
-  Keys                 theKeys;
-  Pairs                thePairs;
-  store::Collection  * theCollection;
-  const JSONItem     * theRoot;
-
 public:
   SimpleJSONObject()
     :
-    theKeys(64, false),
-    theCollection(NULL),
-    theRoot(NULL)
+    theKeys(64, false)
   {
   }
 
@@ -227,8 +288,6 @@
 
   virtual void getTypedValue(store::Item_t& val, store::Iterator_t& iter) const;
 
-  virtual const store::Collection* getCollection() const;
-
   // updates
   
   virtual bool add(
@@ -246,25 +305,21 @@
       const store::Item_t& aName,
       const store::Item_t& aNewName);
 
-  virtual void setCollection(SimpleCollection* collection, xs_integer pos);
-  
   // root management
   
 protected:
-  friend void setJSONRoot(store::Item* aJSONItem, const JSONItem* aRoot);
-
-  void setRoot(const JSONItem* aRoot);
-
-  const JSONItem* getRoot() { return theRoot; }
-  
+  void setTree(JSONTree* aTree);
+
+private:
+  Keys   theKeys;
+  Pairs  thePairs;
+
   // Invariant handling
-protected:
-  friend class SimpleJSONArray;
-
+public:
 #ifndef NDEBUG
   void assertInvariant() const;
-
-  bool isThisRootOfAllDescendants(const store::Item* aRoot) const;
+  
+  bool isThisTreeOfAllDescendants(const JSONTree* aTree) const;
 
   bool isThisJSONItemInDescendance(const store::Item* aJSONItem) const;
 #endif
@@ -324,7 +379,6 @@
   virtual store::Item_t
   replace(const xs_integer& pos, const store::Item_t& value) = 0;
 
-  virtual void setCollection(SimpleCollection* collection, xs_integer pos) = 0;
 };
 
 
@@ -358,18 +412,9 @@
       virtual void close();
   };
 
-protected:
-  Members                   theContent;
-  const store::Collection * theCollection;
-  const JSONItem          * theRoot;
-
 public:
   SimpleJSONArray()
-    :
-    theCollection(NULL),
-    theRoot(NULL)
-  {
-  }
+  {}
 
   virtual ~SimpleJSONArray();
   
@@ -393,8 +438,6 @@
 
   void getTypedValue(store::Item_t& val, store::Iterator_t& iter) const;
 
-  virtual const store::Collection* getCollection() const;
-  
   // updates
   
   virtual void
@@ -421,38 +464,29 @@
   virtual store::Item_t
   replace(const xs_integer& aPos, const store::Item_t& value);
 
-  void setCollection(SimpleCollection* collection, xs_integer pos);
-
   // root management
-protected:
-  friend void setJSONRoot(store::Item* aJSONItem, const JSONItem* aRoot);
-
-  void setRoot(const JSONItem* aRoot);
-
-  const JSONItem* getRoot() { return theRoot; }
-  
+public:
+  void setTree(JSONTree* aTree);
+
 protected:
   void add(uint64_t pos, const std::vector<store::Item_t>& aNewMembers);
 
   static uint64_t cast(const xs_integer& i);
   
+private:
+  Members theContent;
+
   // Invariant handling
-protected:
-  friend class SimpleJSONObject;
-
+public:
 #ifndef NDEBUG
-  void assertInvariant() const;
-
-  bool isThisRootOfAllDescendants(const store::Item* aRoot) const;
+  bool isThisTreeOfAllDescendants(const JSONTree* aTree) const;
 
   bool isThisJSONItemInDescendance(const store::Item* aJSONItem) const;
 #endif
 };
 
 
-void setJSONRoot(store::Item* aJSONItem, const JSONItem* aRoot);
-    
-#if 0 // ifndef NDEBUG
+#ifndef NDEBUG
 #define ASSERT_INVARIANT() assertInvariant()
 #else
 #define ASSERT_INVARIANT()

=== modified file 'src/store/naive/pul_primitives.cpp'
--- src/store/naive/pul_primitives.cpp	2012-07-24 08:48:48 +0000
+++ src/store/naive/pul_primitives.cpp	2012-08-09 13:45:44 +0000
@@ -164,8 +164,11 @@
     theParent->deleteChild(*this);
   }
   
-  static_cast<zorba::simplestore::XmlNode*>(theTarget.getp())
+  if (theTarget->isNode())
+  {
+    static_cast<zorba::simplestore::XmlNode*>(theTarget.getp())
         ->unregisterReferencesToDeletedSubtree();
+  }
 }
 
 
@@ -993,9 +996,21 @@
 
   for (uint64_t i = 0; i < size; ++i)
   {
-    XmlNode* root = static_cast<XmlNode*>(collection->nodeAt(xs_integer(i)).getp());
-    XmlTree* tree = root->getTree();
-    if (tree->getRefCount() > 1)
+    long lRefCount = 0;
+    store::Item* lItem = collection->nodeAt(xs_integer(i)).getp();
+    if (lItem->isNode())
+    {
+      assert(dynamic_cast<XmlNode*>(lItem));
+      XmlNode* lNode = static_cast<XmlNode*>(lItem);
+      lRefCount = lNode->getTree()->getRefCount();
+#ifdef ZORBA_WITH_JSON
+    } else if (lItem->isJSONItem()) {
+      assert(dynamic_cast<json::JSONItem*>(lItem));
+      json::JSONItem* lJSONItem = static_cast<json::JSONItem*>(lItem);
+      lRefCount = lJSONItem->getRefCount();
+#endif
+    }
+    if (lRefCount > 1)
     {
       RAISE_ERROR(zerr::ZDDY0015_COLLECTION_BAD_DESTROY_NODES, theLoc,
       ERROR_PARAMS(collection->getName()->getStringValue()));

=== modified file 'src/store/naive/simple_collection.cpp'
--- src/store/naive/simple_collection.cpp	2012-07-24 08:48:48 +0000
+++ src/store/naive/simple_collection.cpp	2012-08-09 13:45:44 +0000
@@ -155,9 +155,9 @@
 
 #ifdef ZORBA_WITH_JSON
   if (object)
-    object->setCollection(this, pos);
+    object->fix(this, createTreeId());
   else if (array)
-    array->setCollection(this, pos);
+    array->fix(this, createTreeId());
   else
 #endif
     node->setCollection(this, pos);
@@ -249,9 +249,9 @@
 
 #ifdef ZORBA_WITH_JSON
     if (object)
-      object->setCollection(this, pos);
+      object->fix(this, createTreeId());
     else if (array)
-      array->setCollection(this, pos);
+      array->fix(this, createTreeId());
     else
 #endif
       node->setCollection(this, pos);
@@ -331,9 +331,9 @@
 
 #ifdef ZORBA_WITH_JSON
     if (object)
-      object->setCollection(NULL, zero);
+      object->unfix();
     else if (array)
-      array->setCollection(NULL, zero);
+      array->unfix();
     else
 #endif
       node->setCollection(NULL, zero);
@@ -381,12 +381,12 @@
     else if (item->isJSONObject())
     {
       json::SimpleJSONObject* object = static_cast<json::SimpleJSONObject*>(item);
-      object->setCollection(NULL, zero);
+      object->unfix();
     }
     else if (item->isJSONArray())
     {
       json::SimpleJSONArray* array = static_cast<json::SimpleJSONArray*>(item);
-      array->setCollection(NULL, zero);
+      array->unfix();
     }
 #endif
     else
@@ -442,12 +442,12 @@
       else if (item->isJSONObject())
       {
         json::SimpleJSONObject* object = static_cast<json::SimpleJSONObject*>(item);
-        object->setCollection(NULL, zero);
+        object->unfix();
       }
       else if (item->isJSONArray())
       {
         json::SimpleJSONArray* array = static_cast<json::SimpleJSONArray*>(item);
-        array->setCollection(NULL, zero);
+        array->unfix();
       }
 #endif
       else

=== modified file 'src/store/naive/simple_pul.cpp'
--- src/store/naive/simple_pul.cpp	2012-07-24 08:48:48 +0000
+++ src/store/naive/simple_pul.cpp	2012-08-09 13:45:44 +0000
@@ -176,18 +176,28 @@
   assert(target->isNode());
 #endif
 
-  const XmlNode* n = static_cast<const XmlNode*>(target);
-
-  const store::Collection* collection = n->getCollection();
-
-  if (collection != NULL)
-  {
-    collName = static_cast<const QNameItem*>(collection->getName())->getNormalized();
+  const store::Collection* lCollection;
+  
+  if (target->isNode())
+  {
+    assert(dynamic_cast<const XmlNode*>(target));
+    const XmlNode* lNode = static_cast<const XmlNode*>(target);
+    lCollection = lNode->getCollection();
+#ifdef ZORBA_WITH_JSON
+  } else if (target->isJSONItem()) {
+    assert(dynamic_cast<const json::JSONItem*>(target));
+    const json::JSONItem* lJSONItem = static_cast<const json::JSONItem*>(target);
+    lCollection = lJSONItem->getCollection();
+#endif
+  }
+  if (lCollection != NULL)
+  {
+    collName = static_cast<const QNameItem*>(lCollection->getName())->getNormalized();
 
     if (collName == theLastCollection)
       return theLastPul;
 
-    return getCollectionPulByName(collName, collection->isDynamic());
+    return getCollectionPulByName(collName, lCollection->isDynamic());
   }
   else if (theNoCollectionPul != NULL)
   {
@@ -2230,23 +2240,48 @@
     NodeToUpdatesMap::iterator it = pul->theNodeToUpdatesMap.begin();
     NodeToUpdatesMap::iterator end = pul->theNodeToUpdatesMap.end();
 
+    bool found = false;
+    
     for (; it != end; ++it)
     {
-      const XmlNode* targetNode = static_cast<XmlNode*>((*it).first);
-
-      bool found = false;
-
-      for (csize i = 0; i < numRoots; i++)
+      zorba::store::Item* lItem = (*it).first;
+      if (lItem->isNode())
       {
-        XmlNode* rootNode = static_cast<XmlNode*>(rootNodes[i]);
+        assert(dynamic_cast<const XmlNode*>(lItem));
+        const XmlNode* lNode = static_cast<const XmlNode*>(lItem);
+        for (csize i = 0; i < numRoots; i++)
+        {
+          if (rootNodes[i]->isNode()) {
+            assert(dynamic_cast<const XmlNode*>(rootNodes[i]));
+            XmlNode* lRootNode = static_cast<XmlNode*>(rootNodes[i]);
+            
+            if (lNode->getTree() == lRootNode->getTree())
+            {
+              found = true;
+              break;
+            }
+          }
+        }
+#ifdef ZORBA_WITH_JSON
+      } else if (lItem->isJSONItem()) {
+        assert(dynamic_cast<const json::JSONItem*>(lItem));
+        const json::JSONItem* lJSONItem = static_cast<const json::JSONItem*>(lItem);
+        for (csize i = 0; i < numRoots; i++)
+        {
+          if (rootNodes[i]->isJSONItem()) {
+            assert(dynamic_cast<const json::JSONItem*>(rootNodes[i]));
+            json::JSONItem* lRootJSONItem = static_cast<json::JSONItem*>(rootNodes[i]);
+            
+            if (lJSONItem->getTree() == lRootJSONItem->getTree())
+            {
+              found = true;
+              break;
+            }
+          }
+        }
+#endif
+      }
         
-        if (targetNode->getTree() == rootNode->getTree())
-        {
-          found = true;
-          break;
-        }
-      }
-
       if (!found)
         throw XQUERY_EXCEPTION(err::XUDY0014);
     }