Merge lp:~zorba-coders/zorba/simplestore-api into lp:zorba

[Ghislain Fourny]

Introduced SimpleStore API (separating factory, collection and treeID creation from the rest of the store).

Introduced SimpleStore API (separating factory, collection and treeID creation from the rest of the store).

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/simplestore-api-2012-03-07T14-29-07.412Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job simplestore-api-2012-03-07T14-29-07.412Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1. Got: 1 Pending.

[Matthias Brantner (matthias-brantner)]

- The destroy* functions could also be pure virtual in store.h. Why aren't they?
- With the introduction of a new abstract Store class, the need for types like DocumentSet, CollectionSet, IndexSet somehow disappears because functions such as getDocument only delegate to the corresponding Set. Instead, the implementation could be directly done in the deriving store class. But this is just something to consider and not a must fix.
- Along this argument, the RefNodeMap should be moved into the SimpleStore class because it's unlikely that another store shares the same data structure.
- The counters (i.e. theUriCounter, theCollectionCounter, and theTreeCounter) could go into the SimpleStore subclass.

review: Needs Information

[Ghislain Fourny (gislenius)]

Hi Matthias, thanks for your comments. The pushed revisions address comments 1, 3, and 4. Comment 2 was considered but not implemented, as discussed with you over the phone.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/simplestore-api-2012-03-12T18-02-52.82Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job simplestore-api-2012-03-12T18-02-52.82Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1. Got: 1 Needs Information, 2 Pending.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Attempt to merge into lp:zorba failed due to conflicts:

text conflict in src/store/naive/loader.h
text conflict in src/store/naive/simple_store.cpp
text conflict in src/store/naive/simple_store.h

[Zorba Build Bot (zorba-buildbot)]

Attempt to merge into lp:zorba failed due to conflicts:

text conflict in src/store/naive/loader.h
text conflict in src/store/naive/simple_store.cpp
text conflict in src/store/naive/simple_store.h

[Zorba Build Bot (zorba-buildbot)]

Attempt to merge into lp:zorba failed due to conflicts:

text conflict in src/store/naive/loader.h
text conflict in src/store/naive/simple_store.cpp
text conflict in src/store/naive/simple_store.h

[lp:~zorba-coders/zorba/simplestore-api]

10708. By Markos Zaharioudakis on 2012-03-27

merge from trunk

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/simplestore-api-2012-03-27T01-51-30.554Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job simplestore-api-2012-03-27T01-51-30.554Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/store/naive/CMakeLists.txt'
--- src/store/naive/CMakeLists.txt	2012-03-26 01:31:32 +0000
+++ src/store/naive/CMakeLists.txt	2012-03-27 01:25:22 +0000
@@ -48,6 +48,7 @@
     inmemorystorec.cpp
     dataguide.cpp
     collection.cpp
+    store.cpp
 )
 
 IF (NOT ZORBA_NO_FULL_TEXT)

=== modified file 'src/store/naive/atomic_items.cpp'
--- src/store/naive/atomic_items.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/atomic_items.cpp	2012-03-27 01:25:22 +0000
@@ -46,7 +46,7 @@
 #include "util/utf8_util.h"
 
 #define CREATE_XS_TYPE(aType) \
-  GET_STORE().getItemFactory()->createQName(SimpleStore::XS_URI, "xs", aType);
+  GET_STORE().getItemFactory()->createQName(Store::XS_URI, "xs", aType);
 
 #define CREATE_BOOLITEM(item, aValue) \
   GET_STORE().getItemFactory()->createBoolean(item, aValue)
@@ -735,7 +735,7 @@
   if (ZSTREQ(getLocalName(), "id"))
   {
     if (ZSTREQ(getPrefix(), "xml") ||
-        ztd::equals(theNamespace, SimpleStore::XML_URI, SimpleStore::XML_URI_LEN))
+        ztd::equals(theNamespace, Store::XML_URI, Store::XML_URI_LEN))
       return true;
   }
 
@@ -748,7 +748,7 @@
   if (ZSTREQ(getLocalName(), "base"))
   {
     if (ZSTREQ(getPrefix(), "xml") ||
-        ztd::equals(getNamespace(), SimpleStore::XML_URI, SimpleStore::XML_URI_LEN))
+        ztd::equals(getNamespace(), Store::XML_URI, Store::XML_URI_LEN))
       return true;
   }
 

=== modified file 'src/store/naive/inmemorystore.cpp'
--- src/store/naive/inmemorystore.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/inmemorystore.cpp	2012-03-27 01:25:22 +0000
@@ -34,14 +34,14 @@
 
 void StoreManager::shutdownStore(void* store)
 {
-  static_cast<simplestore::SimpleStore*>(store)->shutdown();
+  static_cast<simplestore::Store*>(store)->shutdown();
 }
 
 
 namespace simplestore
 {
 
-SimpleStore* StoreManagerImpl::theStore = NULL;
+Store* StoreManagerImpl::theStore = NULL;
 
 }
 

=== modified file 'src/store/naive/inmemorystorec.cpp'
--- src/store/naive/inmemorystorec.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/inmemorystorec.cpp	2012-03-27 01:25:22 +0000
@@ -29,6 +29,6 @@
 void 
 shutdown_store(void* aStore)
 {
-  static_cast<zorba::simplestore::SimpleStore*>(aStore)->shutdown();
+  static_cast<zorba::simplestore::Store*>(aStore)->shutdown();
 }
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/store/naive/loader.h'
--- src/store/naive/loader.h	2012-03-26 01:31:32 +0000
+++ src/store/naive/loader.h	2012-03-27 01:25:22 +0000
@@ -99,26 +99,17 @@
 
 public:
   XmlLoader(
-        BasicItemFactory* factory,
-        XQueryDiagnostics* xqueryDiagnostics,
-        const store::LoadProperties& loadProperties,
-        bool dataguide)
-    :
-    theLoadProperties(loadProperties),
-    ctxt(NULL),
-    theFactory(factory),
-    theXQueryDiagnostics(xqueryDiagnostics),
-    theTraceLevel(0),
-    theBuildDataGuide(dataguide)
-  {
-  }
+      store::ItemFactory* factory,
+      XQueryDiagnostics* xqueryDiagnostics,
+      const store::LoadProperties& loadProperties,
+      bool dataguide);
 
-  virtual ~XmlLoader() {}
+  virtual ~XmlLoader();
 
   virtual store::Item_t loadXml(
-        const zstring& baseUri,
-        const zstring& docUri,
-        std::istream& xmlStream) = 0;
+      const zstring& baseUri,
+      const zstring& docUri,
+      std::istream& xmlStream) = 0;
 };
 
 
@@ -164,17 +155,17 @@
 
 public:
   FastXmlLoader(
-        BasicItemFactory* factory,
-        XQueryDiagnostics* xqueryDiagnostics,
-        const store::LoadProperties& loadProperties,
-        bool dataguide);
+      store::ItemFactory* factory,
+      XQueryDiagnostics* xqueryDiagnostics,
+      const store::LoadProperties& loadProperties,
+      bool dataguide);
 
   ~FastXmlLoader();
 
   store::Item_t loadXml(
-        const zstring& baseUri,
-        const zstring& uri,
-        std::istream& xmlStream);
+      const zstring& baseUri,
+      const zstring& uri,
+      std::istream& xmlStream);
 
 protected:
   void abortload();
@@ -191,31 +182,31 @@
   static void endDocument(void * ctx);
 
   static void startElement(
-        void * ctx,
-        const xmlChar * localname,
-        const xmlChar * prefix,
-        const xmlChar * URI,
-        int nb_namespaces,
-        const xmlChar ** namespaces,
-        int nb_attributes,
-        int nb_defaulted,
-        const xmlChar ** attributes);
+      void * ctx,
+      const xmlChar * localname,
+      const xmlChar * prefix,
+      const xmlChar * URI,
+      int nb_namespaces,
+      const xmlChar ** namespaces,
+      int nb_attributes,
+      int nb_defaulted,
+      const xmlChar ** attributes);
 
   static void endElement(
-        void * ctx,
-        const xmlChar * localname,
-        const xmlChar * prefix,
-        const xmlChar * URI);
+      void * ctx,
+      const xmlChar * localname,
+      const xmlChar * prefix,
+      const xmlChar * URI);
 
   static void characters(
-        void * ctx,
-        const xmlChar * ch,
-        int len);
+      void * ctx,
+      const xmlChar * ch,
+      int len);
 
   static void	cdataBlock(
-        void * ctx,
-        const xmlChar * value,
-        int len);
+      void * ctx,
+      const xmlChar * value,
+      int len);
 
   static void comment(
         void * ctx,
@@ -247,6 +238,7 @@
         xmlChar *content);
 };
 
+
 /*******************************************************************************
   FragmentXmlLoader
 *******************************************************************************/
@@ -254,18 +246,18 @@
 {
 public:
   FragmentXmlLoader(
-        BasicItemFactory* factory,
-        XQueryDiagnostics* xqueryDiagnostics,
-        const store::LoadProperties& loadProperties,
-        bool dataguide);
+      store::ItemFactory* factory,
+      XQueryDiagnostics* xqueryDiagnostics,
+      const store::LoadProperties& loadProperties,
+      bool dataguide);
 
   ~FragmentXmlLoader();
 
   store::Item_t loadXml(
-        const zstring& baseUri,
-        const zstring& uri,
-        std::istream& xmlStream);
-
+      const zstring& baseUri,
+      const zstring& uri,
+      std::istream& xmlStream);
+  
 protected:
   bool fillBuffer(FragmentIStream* theFragmentStream);
 
@@ -356,17 +348,17 @@
 
 public:
   DtdXmlLoader(
-        BasicItemFactory* factory,
-        XQueryDiagnostics* xqueryDiagnostics,
-        const store::LoadProperties& loadProperties,
-        bool dataguide);
+      store::ItemFactory* factory,
+      XQueryDiagnostics* xqueryDiagnostics,
+      const store::LoadProperties& loadProperties,
+      bool dataguide);
 
   ~DtdXmlLoader();
 
   store::Item_t loadXml(
-        const zstring& baseUri,
-        const zstring& uri,
-        std::istream& xmlStream);
+      const zstring& baseUri,
+      const zstring& uri,
+      std::istream& xmlStream);
 
 protected:
   void abortload();

=== modified file 'src/store/naive/loader_dtd.cpp'
--- src/store/naive/loader_dtd.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/loader_dtd.cpp	2012-03-27 01:25:22 +0000
@@ -115,7 +115,7 @@
 
 ********************************************************************************/
 FragmentXmlLoader::FragmentXmlLoader(
-    BasicItemFactory* factory,
+    store::ItemFactory* factory,
     XQueryDiagnostics* xqueryDiagnostics,
     const store::LoadProperties& loadProperties,
     bool dataguide)
@@ -507,7 +507,7 @@
 
 ********************************************************************************/
 DtdXmlLoader::DtdXmlLoader(
-    BasicItemFactory* factory,
+    store::ItemFactory* factory,
     XQueryDiagnostics* xqueryDiagnostics,
     const store::LoadProperties& loadProperties,
     bool dataguide)
@@ -1124,7 +1124,7 @@
   for (xmlNs  *ns = node->nsDef; ns != NULL; ns = ns->next)
     numNamespaces++;
 
-  SimpleStore& store = GET_STORE();
+  Store& store = GET_STORE();
   NodeFactory& nfactory = store.getNodeFactory();
   DtdXmlLoader& loader = *(static_cast<DtdXmlLoader *>(ctx));
   ZORBA_LOADER_CHECK_ERROR(loader);
@@ -1291,7 +1291,7 @@
           break;
         case XML_ATTRIBUTE_IDREFS:
           GET_STORE().getItemFactory()->createIDREFS(typedValue, value);
-          GET_STORE().getItemFactory()->createQName(typeName, SimpleStore::XS_URI, "xs", "IDREFS");
+          GET_STORE().getItemFactory()->createQName(typeName, Store::XS_URI, "xs", "IDREFS");
           attrNode->setHaveListValue();
           break;
         case XML_ATTRIBUTE_ENTITY:
@@ -1300,7 +1300,7 @@
           break;
         case XML_ATTRIBUTE_ENTITIES:
           GET_STORE().getItemFactory()->createENTITIES(typedValue, value);
-          GET_STORE().getItemFactory()->createQName(typeName, SimpleStore::XS_URI, "xs", "ENTITIES");
+          GET_STORE().getItemFactory()->createQName(typeName, Store::XS_URI, "xs", "ENTITIES");
           attrNode->setHaveListValue();
           break;
         case XML_ATTRIBUTE_NMTOKEN:
@@ -1309,16 +1309,16 @@
           break;
         case XML_ATTRIBUTE_NMTOKENS:
           GET_STORE().getItemFactory()->createNMTOKENS(typedValue, value);
-          GET_STORE().getItemFactory()->createQName(typeName, SimpleStore::XS_URI, "xs", "NMTOKENS");
+          GET_STORE().getItemFactory()->createQName(typeName, Store::XS_URI, "xs", "NMTOKENS");
           attrNode->setHaveListValue();
           break;
         case XML_ATTRIBUTE_NOTATION:
           GET_STORE().getItemFactory()->createNOTATION(typedValue, value);
-          GET_STORE().getItemFactory()->createQName(typeName, SimpleStore::XS_URI, "xs", "NOTATION");
+          GET_STORE().getItemFactory()->createQName(typeName, Store::XS_URI, "xs", "NOTATION");
           break;
         case XML_ATTRIBUTE_ENUMERATION:
           GET_STORE().getItemFactory()->createUntypedAtomic(typedValue, value);
-          GET_STORE().getItemFactory()->createQName(typeName, SimpleStore::XS_URI, "xs", "anySimpleType");
+          GET_STORE().getItemFactory()->createQName(typeName, Store::XS_URI, "xs", "anySimpleType");
           break;
         default:
           std::cout << "AssertError: unknown libxml2 attribute type: " <<

=== modified file 'src/store/naive/loader_fast.cpp'
--- src/store/naive/loader_fast.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/loader_fast.cpp	2012-03-27 01:25:22 +0000
@@ -70,11 +70,36 @@
       return; \
   } while (0);
 
+
+/*******************************************************************************
+
+********************************************************************************/
+XmlLoader::XmlLoader(
+    store::ItemFactory* factory,
+    XQueryDiagnostics* xqueryDiagnostics,
+    const store::LoadProperties& loadProperties,
+    bool dataguide)
+  :
+  theLoadProperties(loadProperties),
+  ctxt(NULL),
+  theFactory(static_cast<BasicItemFactory*>(factory)),
+  theXQueryDiagnostics(xqueryDiagnostics),
+  theTraceLevel(0),
+  theBuildDataGuide(dataguide)
+{
+}
+
+
+XmlLoader::~XmlLoader() 
+{
+}
+
+
 /*******************************************************************************
 
 ********************************************************************************/
 FastXmlLoader::FastXmlLoader(
-    BasicItemFactory* factory,
+    store::ItemFactory* factory,
     XQueryDiagnostics* xqueryDiagnostics,
     const store::LoadProperties& loadProperties,
     bool dataguide)
@@ -542,7 +567,7 @@
     int numDefaulted,
     const xmlChar ** attributes)
 {
-  SimpleStore& store = GET_STORE();
+  Store& store = GET_STORE();
   NodeFactory& nfactory = store.getNodeFactory();
   FastXmlLoader& loader = *(static_cast<FastXmlLoader *>(ctx));
   ZORBA_LOADER_CHECK_ERROR(loader);

=== modified file 'src/store/naive/node_factory.h'
--- src/store/naive/node_factory.h	2012-03-26 01:31:32 +0000
+++ src/store/naive/node_factory.h	2012-03-27 01:25:22 +0000
@@ -41,13 +41,13 @@
   class CommentNode;
 
 
-/** 
- * This class implements the Abstract Factory Pattern and is responsible for
- * creating node items of the SimpleStore. Having a factory for node items
- * allows other stores to derive from the node items of the SimpleStore without
- * modifying a lot of code (e.g. of the loader). The class can only be
- * instantiated by the SimpleStore.
- */
+/*******************************************************************************
+  This class implements the Abstract Factory Pattern and is responsible for
+  creating node items of the SimpleStore. Having a factory for node items
+  allows other stores to derive from the node items of the SimpleStore without
+  modifying a lot of code (e.g. of the loader). The class can only be
+  instantiated by the SimpleStore.
+********************************************************************************/
 class NodeFactory 
 {
  protected:

=== modified file 'src/store/naive/node_items.cpp'
--- src/store/naive/node_items.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/node_items.cpp	2012-03-27 01:25:22 +0000
@@ -1293,7 +1293,7 @@
     lCurrent = lCurrent->getParent();
   }
   store::Item_t lRes;
-  GET_STORE().getItemFactory()->createInteger(lRes, lNumLevels);
+  GET_FACTORY().createInteger(lRes, lNumLevels);
   return lRes;
 }
 
@@ -1765,7 +1765,7 @@
 {
   zstring rch;
   getStringValue2(rch);
-  GET_STORE().getItemFactory()->createUntypedAtomic(val, rch);
+  GET_FACTORY().createUntypedAtomic(val, rch);
   iter = NULL;
 }
 
@@ -2643,7 +2643,7 @@
 
   if (getType()->equals(GET_STORE().XS_UNTYPED_QNAME))
   {
-    GET_STORE().getItemFactory()->createBoolean(val, false);
+    GET_FACTORY().createBoolean(val, false);
     return val;
   }
 
@@ -2687,7 +2687,7 @@
     }
   }
 
-  GET_STORE().getItemFactory()->createBoolean(val, nilled);
+  GET_FACTORY().createBoolean(val, nilled);
   return val;
 }
 
@@ -3145,7 +3145,7 @@
 {
   ZORBA_FATAL(!absUri.empty(), "");
 
-  const SimpleStore& store = GET_STORE();
+  const Store& store = GET_STORE();
 
   store::Item_t qname = store.getQNamePool().insert(store.XML_URI, "xml", "base");
   store::Item_t typeName = store.theSchemaTypeNames[store::XS_ANY_URI];
@@ -3154,7 +3154,7 @@
 
   if (relUri.empty())
   {
-    GET_STORE().getItemFactory()->createAnyURI(typedValue, absUri);
+    GET_FACTORY().createAnyURI(typedValue, absUri);
   }
   else
   {
@@ -3171,7 +3171,7 @@
       resolvedUriString = relUri;
     }
 
-    GET_STORE().getItemFactory()->createAnyURI(typedValue, resolvedUriString);
+    GET_FACTORY().createAnyURI(typedValue, resolvedUriString);
   }
 
   checkUniqueAttr(qname.getp());
@@ -3470,7 +3470,7 @@
   assert(parent != NULL || rootParent == NULL);
   ZORBA_FATAL(!isHidden(), "");
 
-  SimpleStore& store = GET_STORE();
+  Store& store = GET_STORE();
 
   XmlTree* tree = NULL;
   AttributeNode* copyNode = NULL;
@@ -3502,21 +3502,21 @@
     {
       zstring rch;
       getStringValue2(rch);
-      GET_STORE().getItemFactory()->createUntypedAtomic(typedValue, rch);
+      GET_FACTORY().createUntypedAtomic(typedValue, rch);
     }
   }
 
   try
   {
     if (parent == NULL)
-      tree = GET_STORE().getNodeFactory().createXmlTree();
+      tree = GET_NODE_FACTORY().createXmlTree();
 
     else if (parent == rootParent)
       reinterpret_cast<ElementNode*>(parent)->checkUniqueAttr(nodeName);
 
     bool append = (rootParent != parent);
 
-    copyNode = GET_STORE().getNodeFactory().createAttributeNode(
+    copyNode = GET_NODE_FACTORY().createAttributeNode(
                  tree,
                  static_cast<ElementNode*>(parent),
                  append,
@@ -4150,12 +4150,12 @@
   if (isTyped())
   {
     getValue()->getStringValue2(rch);
-    GET_STORE().getItemFactory()->createUntypedAtomic(val, rch);
+    GET_FACTORY().createUntypedAtomic(val, rch);
   }
   else
   {
     rch = getText();
-    GET_STORE().getItemFactory()->createUntypedAtomic(val, rch);
+    GET_FACTORY().createUntypedAtomic(val, rch);
   }
   iter = NULL;
 }
@@ -4434,7 +4434,7 @@
   xs_integer lParentLevel = getParent()->getLevel()->getIntegerValue();
 
   store::Item_t lRes;
-  GET_STORE().getItemFactory()->createInteger(lRes, ++lParentLevel);
+  GET_FACTORY().createInteger(lRes, ++lParentLevel);
 
   return lRes;
 }
@@ -4581,7 +4581,7 @@
 void PiNode::getTypedValue(store::Item_t& val, store::Iterator_t& iter) const
 {
   zstring rch = theContent;
-  GET_STORE().getItemFactory()->createString(val, rch);
+  GET_FACTORY().createString(val, rch);
   iter = NULL;
 }
 
@@ -4705,7 +4705,7 @@
 void CommentNode::getTypedValue(store::Item_t& val, store::Iterator_t& iter) const
 {
   zstring rch = theContent;
-  GET_STORE().getItemFactory()->createString(val, rch);
+  GET_FACTORY().createString(val, rch);
   iter = NULL;
 }
 

=== modified file 'src/store/naive/pul_primitives.cpp'
--- src/store/naive/pul_primitives.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/pul_primitives.cpp	2012-03-27 01:25:22 +0000
@@ -793,7 +793,7 @@
 ********************************************************************************/
 void UpdPut::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   zstring targetUri;
   theTargetUri->getStringValue2(targetUri);
@@ -847,7 +847,7 @@
 
 void UpdPut::undo()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   store->deleteDocument(theTargetUri->getStringValue());
 
@@ -1034,9 +1034,12 @@
   assert(lColl);
 
   uint64_t lastPos;
-  try {
+  try 
+  {
     lastPos = to_xs_unsignedLong(lColl->size()) - 1;
-  } catch (std::range_error& e) {
+  }
+  catch (std::range_error& e)
+  {
     throw ZORBA_EXCEPTION(
         zerr::ZSTR0060_RANGE_EXCEPTION,
         ERROR_PARAMS(
@@ -1329,7 +1332,7 @@
 
 void UpdCreateIndex::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   try
   {
@@ -1355,7 +1358,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
 
     store->deleteIndex(theQName);
   }
@@ -1375,7 +1378,7 @@
 
 void UpdDeleteIndex::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   if ((theIndex = store->getIndex(theQName)) == NULL)
   {
@@ -1395,7 +1398,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
 
     store->addIndex(theIndex);
   }
@@ -1425,7 +1428,7 @@
 
 void UpdRefreshIndex::apply()
 {
-  SimpleStore& store = GET_STORE();
+  Store& store = GET_STORE();
 
   if ((theIndex = store.getIndex(theQName)) == NULL)
   {
@@ -1445,7 +1448,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
     store->deleteIndex(theQName);
     store->addIndex(theIndex);
   }
@@ -1475,7 +1478,7 @@
 
 void UpdActivateIC::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
   store->activateIC(theQName, theCollectionName,theIsApplied);
 }
 
@@ -1484,7 +1487,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
     bool isApplied;
     store->deactivateIC(theQName,isApplied);
     theIsApplied=false;
@@ -1517,7 +1520,7 @@
 
 void UpdActivateForeignKeyIC::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
   store->activateForeignKeyIC(theQName, theFromCollectionName, theToCollectionName,theIsApplied);
 }
 
@@ -1526,7 +1529,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
     bool isApplied;
     store->deactivateIC(theQName,isApplied);
     theIsApplied=false;
@@ -1555,7 +1558,7 @@
 
 void UpdDeActivateIC::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
   store::IC_t ic = store->deactivateIC(theQName,theIsApplied);
   if (theIsApplied)
   {
@@ -1579,9 +1582,10 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
     bool isApplied;
-    switch (theICKind) {
+    switch (theICKind) 
+    {
       case store::IC::ic_collection:
         store->activateIC(theQName, theFromCollectionName,isApplied);
         break;
@@ -1617,7 +1621,7 @@
 
 void UpdCreateDocument::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   store->addNode(theUri->getStringValue(), theDoc);
 
@@ -1629,7 +1633,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
 
     store->deleteDocument(theUri->getStringValue());
     theIsApplied = false;
@@ -1653,7 +1657,7 @@
 
 void UpdDeleteDocument::apply()
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   zstring lUri = theUri->getStringValue();
 
@@ -1671,7 +1675,7 @@
 {
   if (theIsApplied)
   {
-    SimpleStore* store = &GET_STORE();
+    Store* store = &GET_STORE();
     store->addNode(theUri->getStringValue(), theDoc);
     theIsApplied = false;
   }

=== modified file 'src/store/naive/simple_index_value.h'
--- src/store/naive/simple_index_value.h	2012-03-26 01:31:32 +0000
+++ src/store/naive/simple_index_value.h	2012-03-27 01:25:22 +0000
@@ -73,7 +73,7 @@
 *******************************************************************************/
 class ValueIndex : public IndexImpl
 {
-  friend class SimpleStore;
+  friend class Store;
 
 protected:
   ValueIndexCompareFunction   theCompFunction;
@@ -102,7 +102,7 @@
 *******************************************************************************/
 class ValueHashIndex : public ValueIndex
 {
-  friend class SimpleStore;
+  friend class Store;
   friend class ProbeValueHashIndexIterator;
 
   typedef HashMap<const store::IndexKey*,
@@ -191,7 +191,7 @@
 ********************************************************************************/
 class ValueTreeIndex : public ValueIndex
 {
-  friend class SimpleStore;
+  friend class Store;
   friend class ProbeValueTreeIndexIterator;
 
   typedef std::pair<const store::IndexKey*, ValueIndexValue*> IndexMapPair;

=== modified file 'src/store/naive/simple_item_factory.cpp'
--- src/store/naive/simple_item_factory.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/simple_item_factory.cpp	2012-03-27 01:25:22 +0000
@@ -1163,10 +1163,8 @@
   ElementNode* n = NULL;
 
   if ( typeName == NULL )
-    throw ZORBA_EXCEPTION(
-      zerr::ZAPI0014_INVALID_ARGUMENT,
-      ERROR_PARAMS( "null", ZED( NotAllowedForTypeName ) )
-    );
+    throw ZORBA_EXCEPTION(zerr::ZAPI0014_INVALID_ARGUMENT,
+    ERROR_PARAMS("null", ZED( NotAllowedForTypeName)));
 
   assert(parent == NULL ||
          parent->getNodeKind() == store::StoreConsts::elementNode ||

=== modified file 'src/store/naive/simple_pul.cpp'
--- src/store/naive/simple_pul.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/simple_pul.cpp	2012-03-27 01:25:22 +0000
@@ -1522,7 +1522,7 @@
     std::vector<store::Index*>& indices,
     std::vector<store::Index*>& truncate_indices)
 {
-  SimpleStore* store = &GET_STORE();
+  Store* store = &GET_STORE();
 
   if (store->getIndices().empty())
     return;

=== modified file 'src/store/naive/simple_store.cpp'
--- src/store/naive/simple_store.cpp	2012-03-26 01:31:32 +0000
+++ src/store/naive/simple_store.cpp	2012-03-27 01:25:22 +0000
@@ -15,57 +15,24 @@
  */
 #include "stdafx.h"
 
-#include <iostream>
-#include <climits>
-#include <memory>
-
-#include <libxml/parser.h>
-
-#include "zorbautils/hashfun.h"
-#include "zorbautils/fatal.h"
-#include "zorbatypes/rchandle.h"
-#include "diagnostics/xquery_diagnostics.h"
-#include "diagnostics/assert.h"
-#include "diagnostics/util_macros.h"
-
-#include "store/api/pul.h"
-#include "store/api/xs_type_codes.h"
-
-#include "properties.h"
-#include "string_pool.h"
 #include "simple_store.h"
-#include "simple_temp_seq.h"
-#include "simple_lazy_temp_seq.h"
+#include "store_defs.h"
+
 #include "simple_collection.h"
 #include "simple_collection_set.h"
-#include "simple_index.h"
-#include "simple_index_value.h"
-#include "simple_index_general.h"
-#include "simple_ic.h"
-#include "qname_pool.h"
-#include "loader.h"
-#include "store_defs.h"
-#include "node_items.h"
-#include "dataguide.h"
-#include "node_iterators.h"
 #include "simple_item_factory.h"
 #include "simple_iterator_factory.h"
-#include "query_context.h"
-#include "item_iterator.h"
 #include "node_factory.h"
-#include "name_iterator.h"
-#include "document_name_iterator.h"
 #include "pul_primitive_factory.h"
-
-#include "util/cxx_util.h"
+#include "node_items.h"
+
+#include "diagnostics/zorba_exception.h"
+#include "diagnostics/diagnostic.h"
+#include <zorba/diagnostic_list.h>
+
 #include "util/uuid/uuid.h"
 #include "zorbautils/string_util.h"
 
-#ifndef ZORBA_NO_FULL_TEXT
-#include "runtime/full_text/default_tokenizer.h"
-#include "runtime/full_text/stemmer.h"
-#endif /* ZORBA_NO_FULL_TEXT */
-
 namespace zorba
 {
 
@@ -74,49 +41,14 @@
 
 typedef rchandle<store::TempSeq> TempSeq_t;
 
-
-/*******************************************************************************
-  SimpleStore static data
-********************************************************************************/
-const ulong SimpleStore::NAMESPACE_POOL_SIZE = 128;
-const ulong SimpleStore::DEFAULT_DOCUMENT_SET_SIZE = 32;
-const ulong SimpleStore::DEFAULT_URI_COLLECTION_SET_SIZE = 32;
-const ulong SimpleStore::DEFAULT_INDICES_SET_SIZE = 32;
-const ulong SimpleStore::DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE = 32;
-
-const char* SimpleStore::XS_URI = "http://www.w3.org/2001/XMLSchema";
-const char* SimpleStore::XML_URI = "http://www.w3.org/2001/XML/1998/namespace";
-const char* SimpleStore::ZXSE_URI = "http://www.zorba-xquery.com/zorba/schema-extensions";
-
-const ulong SimpleStore::XML_URI_LEN = sizeof(SimpleStore::XML_URI);
-
-
 /*******************************************************************************
 
 ********************************************************************************/
 SimpleStore::SimpleStore()
   :
-  theNumUsers(0),
-  theUriCounter(0),
   theCollectionCounter(1),
   theTreeCounter(1),
-  theNamespacePool(NULL),
-  theQNamePool(NULL),
-  theItemFactory(NULL),
-  theIteratorFactory(NULL),
-  theNodeFactory(NULL),
-  thePULFactory(NULL),
-  theDocuments(DEFAULT_DOCUMENT_SET_SIZE, true),
-  theCollections(0),
-  theIndices(0, NULL, DEFAULT_INDICES_SET_SIZE, true),
-  theICs(0, NULL, DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE, true),
-  theHashMaps(0, NULL, DEFAULT_INDICES_SET_SIZE, true),
-  theTraceLevel(0),
   theNodeToReferencesMap(128, true)
-#ifndef ZORBA_NO_FULL_TEXT
-  , theStemmerProvider( nullptr )
-  , theTokenizerProvider( nullptr )
-#endif /* ZORBA_NO_FULL_TEXT */
 {
 }
 
@@ -135,216 +67,18 @@
 ********************************************************************************/
 void SimpleStore::init()
 {
-  SYNC_CODE(AutoLock lock(getGlobalLock(), Lock::WRITE);)
-
-  //zorba::zstring zstr("foo");
-  //zorba::zstring_p pstr;
-  //zorba::zstring_b bstr;
-
-  if (theNumUsers == 0)
-  {
-    // This initializes the libxml2 library and checks potential ABI mismatches
-    // between the version it was compiled for and the actual  shared library used.
-    // Calling its init is done here because we also want to free it at the end,
-    // i.e. when the store is shutdown
-    LIBXML_TEST_VERSION
-
-    store::Properties::load(0, NULL);
-
-    theUriCounter = 0;
-    theCollectionCounter = 1;
-    theTreeCounter = 1;
-
-    theNamespacePool = new StringPool(NAMESPACE_POOL_SIZE);
-
-    theNamespacePool->insertc("", theEmptyNs);
-    theNamespacePool->insertc(XS_URI, theXmlSchemaNs);
-
-    theQNamePool = new QNamePool(QNamePool::MAX_CACHE_SIZE, theNamespacePool);
-
-    // createItemFactory uses theNamespacePool and theQNamePool
-    // they have to be created before this function is called
-    theItemFactory = createItemFactory();
-
-    initTypeNames();
-
-    theIteratorFactory = new SimpleIteratorFactory();
-
-    theNodeFactory = createNodeFactory();
-
-    thePULFactory = createPULPrimitiveFactory();
-
-    theTraceLevel = store::Properties::instance()->storeTraceLevel();
-
-    theCollections = createCollectionSet();
-
-    StoreManagerImpl::theStore = this;
-  }
-
-  ++theNumUsers;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::initTypeNames()
-{
-  const char* ns = XS_URI;
-  BasicItemFactory* f = theItemFactory;
-
-  theSchemaTypeNames.resize(store::XS_LAST);
-
-  f->createQName(XS_UNTYPED_QNAME, ns, "xs", "untyped");
-
-  f->createQName(XS_ANY_QNAME, ns, "xs", "anyType");
-
-  f->createQName(XS_ANY_SIMPLE_QNAME, ns, "xs", "anySimpleType");
-
-  f->createQName(theSchemaTypeNames[store::XS_ANY_ATOMIC],     ns, "xs", "anyAtomicType");
-
-  f->createQName(theSchemaTypeNames[store::XS_UNTYPED_ATOMIC], ns, "xs", "untypedAtomic");
-
-  f->createQName(theSchemaTypeNames[store::XS_ANY_URI],        ns, "xs", "anyURI");
-
-  f->createQName(theSchemaTypeNames[store::XS_QNAME],          ns, "xs", "QName");
-
-  f->createQName(theSchemaTypeNames[store::XS_NOTATION],       ns, "xs", "NOTATION");
-
-  f->createQName(theSchemaTypeNames[store::XS_STRING],         ns, "xs", "string");
-  f->createQName(theSchemaTypeNames[store::XS_NORMALIZED_STRING], ns, "xs", "normalizedString");
-  f->createQName(theSchemaTypeNames[store::XS_TOKEN],          ns, "xs", "token");
-  f->createQName(theSchemaTypeNames[store::XS_NMTOKEN],        ns, "xs", "NMTOKEN");
-  f->createQName(theSchemaTypeNames[store::XS_LANGUAGE],       ns, "xs", "language");
-  f->createQName(theSchemaTypeNames[store::XS_NAME],           ns, "xs", "Name");
-  f->createQName(theSchemaTypeNames[store::XS_NCNAME],         ns, "xs", "NCName");
-  f->createQName(theSchemaTypeNames[store::XS_ID],             ns, "xs", "ID");
-  f->createQName(theSchemaTypeNames[store::XS_IDREF],          ns, "xs", "IDREF");
-  f->createQName(theSchemaTypeNames[store::XS_ENTITY],         ns, "xs", "ENTITY");
-
-  f->createQName(theSchemaTypeNames[store::XS_DATETIME],       ns, "xs", "dateTime");
-  f->createQName(theSchemaTypeNames[store::XS_DATE],           ns, "xs", "date");
-  f->createQName(theSchemaTypeNames[store::XS_TIME],           ns, "xs", "time");
-  f->createQName(theSchemaTypeNames[store::XS_GYEAR_MONTH],    ns, "xs", "gYearMonth");
-  f->createQName(theSchemaTypeNames[store::XS_GYEAR],          ns, "xs", "gYear");
-  f->createQName(theSchemaTypeNames[store::XS_GMONTH_DAY],     ns, "xs", "gMonthDay");
-  f->createQName(theSchemaTypeNames[store::XS_GDAY],           ns, "xs", "gDay");
-  f->createQName(theSchemaTypeNames[store::XS_GMONTH],         ns, "xs", "gMonth");
-
-  f->createQName(theSchemaTypeNames[store::XS_DURATION],       ns, "xs", "duration");
-  f->createQName(theSchemaTypeNames[store::XS_DT_DURATION],    ns, "xs", "dayTimeDuration");
-  f->createQName(theSchemaTypeNames[store::XS_YM_DURATION],    ns, "xs", "yearMonthDuration");
-
-  f->createQName(theSchemaTypeNames[store::XS_FLOAT],          ns, "xs", "float");
-  f->createQName(theSchemaTypeNames[store::XS_DOUBLE],         ns, "xs", "double");
-  f->createQName(theSchemaTypeNames[store::XS_DECIMAL],        ns, "xs", "decimal");
-  f->createQName(theSchemaTypeNames[store::XS_INTEGER],        ns, "xs", "integer");
-  f->createQName(theSchemaTypeNames[store::XS_NON_POSITIVE_INTEGER], ns, "xs", "nonPositiveInteger");
-  f->createQName(theSchemaTypeNames[store::XS_NON_NEGATIVE_INTEGER], ns, "xs", "nonNegativeInteger");
-  f->createQName(theSchemaTypeNames[store::XS_NEGATIVE_INTEGER], ns, "xs", "negativeInteger");
-  f->createQName(theSchemaTypeNames[store::XS_POSITIVE_INTEGER], ns, "xs", "positiveInteger");
-
-  f->createQName(theSchemaTypeNames[store::XS_LONG],           ns, "xs", "long");
-  f->createQName(theSchemaTypeNames[store::XS_INT],            ns, "xs", "int");
-  f->createQName(theSchemaTypeNames[store::XS_SHORT],          ns, "xs", "short");
-  f->createQName(theSchemaTypeNames[store::XS_BYTE],           ns, "xs", "byte");
-  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_LONG],  ns, "xs", "unsignedLong");
-  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_INT],   ns, "xs", "unsignedInt");
-  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_SHORT], ns, "xs", "unsignedShort");
-  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_BYTE],  ns, "xs", "unsignedByte");
-
-  f->createQName(theSchemaTypeNames[store::XS_BASE64BINARY],   ns, "xs", "base64Binary");
-  f->createQName(theSchemaTypeNames[store::XS_HEXBINARY],      ns, "xs", "hexBinary");
-  f->createQName(theSchemaTypeNames[store::XS_BOOLEAN],        ns, "xs", "boolean");
-
-  for (ulong i = 0; i < store::XS_LAST; ++i)
-  {
-    theSchemaTypeCodes[theSchemaTypeNames[i].getp()] = 
-    static_cast<store::SchemaTypeCode>(i);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
+  theCollectionCounter = 1;
+  theTreeCounter = 1;
+
+  Store::init();
+}
+
 void SimpleStore::shutdown(bool soft)
 {
-  SYNC_CODE(AutoLock lock(getGlobalLock(), Lock::WRITE);)
-
-  if (theNumUsers == 0)
-    return;
-
-  --theNumUsers;
-
-  if (theNumUsers == 0 || soft == false)
+  Store::shutdown(soft);
+
+  if (theNumUsers == 0 || soft == false) 
   {
-    theIndices.clear();
-    theICs.clear();
-    theHashMaps.clear();
-
-    if (theCollections != NULL)
-    {
-      theCollections->clear();
-      destroyCollectionSet(theCollections);
-      theCollections = NULL;
-    }
-
-    theDocuments.clear();
-
-    if (thePULFactory != NULL)
-    {
-      destroyPULPrimitiveFactory(thePULFactory);
-      thePULFactory = NULL;
-    }
-
-    if (theNodeFactory != NULL)
-    {
-      destroyNodeFactory(theNodeFactory);
-      theNodeFactory = NULL;
-    }
-
-    if (theItemFactory != NULL)
-    {
-      destroyItemFactory(theItemFactory);
-      theItemFactory = NULL;
-    }
-
-    if (theQNamePool != NULL)
-    {
-      csize numTypes = theSchemaTypeNames.size();
-      for (csize i = 0; i < numTypes; ++i)
-        theSchemaTypeNames[i] = NULL;
-
-      XS_UNTYPED_QNAME = NULL;
-      XS_ANY_QNAME = NULL;
-      XS_ANY_SIMPLE_QNAME = NULL;
-
-      delete theQNamePool;
-      theQNamePool = NULL;
-    }
-
-    if (theNamespacePool != NULL)
-    {
-      theEmptyNs.~zstring();
-      theXmlSchemaNs.~zstring();
-
-      delete theNamespacePool;
-      theNamespacePool = NULL;
-    }
-
-    if (theIteratorFactory != NULL)
-    {
-      delete theIteratorFactory;
-      theIteratorFactory = NULL;
-    }
-
-    if (theNodeFactory != NULL)
-    {
-      delete theNodeFactory;
-      theNodeFactory = NULL;
-    }
-
     if (theNodeToReferencesMap.size() > 0)
     {
       NodeRefMap::iterator iter = theNodeToReferencesMap.begin();
@@ -370,16 +104,6 @@
       ZORBA_FATAL(0, theReferencesToNodeMap.size() +
                      " node references still in the references to nodes map");
     }
-
-    // do cleanup of the libxml2 library
-    // however, after that, a user will have to call
-    // LIBXML_TEST_VERSION if he wants to use libxml2
-    // beyond the lifecycle of zorba
-    xmlCleanupParser();
-    
-    theNumUsers = 0;
-    
-    StoreManagerImpl::theStore = NULL;
   }
 }
 
@@ -388,7 +112,7 @@
 
 *******************************************************************************/
 PULPrimitiveFactory*
-SimpleStore::createPULPrimitiveFactory() const
+SimpleStore::createPULFactory() const
 {
   return new PULPrimitiveFactory();
 }
@@ -398,11 +122,12 @@
 
 *******************************************************************************/
 void
-SimpleStore::destroyPULPrimitiveFactory(PULPrimitiveFactory* f) const
+SimpleStore::destroyPULFactory(PULPrimitiveFactory* f) const
 {
   delete f;
 }
 
+
 /*******************************************************************************
 
 *******************************************************************************/
@@ -442,7 +167,7 @@
 /*******************************************************************************
 
 *******************************************************************************/
-BasicItemFactory* SimpleStore::createItemFactory() const
+store::ItemFactory* SimpleStore::createItemFactory() const
 {
   return new BasicItemFactory(theNamespacePool, theQNamePool);
 }
@@ -451,18 +176,37 @@
 /*******************************************************************************
 
 *******************************************************************************/
-void SimpleStore::destroyItemFactory(BasicItemFactory* f) const
-{
-  delete f;
-}
-
-
-/*******************************************************************************
-
+void SimpleStore::destroyItemFactory(store::ItemFactory* f) const
+{
+  delete f;
+}
+
+
+/*******************************************************************************
+
+*******************************************************************************/
+store::IteratorFactory* SimpleStore::createIteratorFactory() const
+{
+  return new SimpleIteratorFactory();
+}
+
+
+/*******************************************************************************
+
+*******************************************************************************/
+void SimpleStore::destroyIteratorFactory(store::IteratorFactory* f) const
+{
+  delete f;
+}
+
+
+/*******************************************************************************
+  create a tree id for a new tree that does not belong to any collection.
 ********************************************************************************/
-store::ItemFactory* SimpleStore::getItemFactory() const
+ulong SimpleStore::createTreeId()
 {
-  return theItemFactory;
+  SYNC_CODE(AutoMutex lock(&theTreeCounterMutex);)
+  return theTreeCounter++;
 }
 
 
@@ -477,457 +221,6 @@
 
 
 /*******************************************************************************
-  create a tree id for a new tree that does not belong to any collection.
-********************************************************************************/
-ulong SimpleStore::createTreeId()
-{
-  SYNC_CODE(AutoMutex lock(&theTreeCounterMutex);)
-  return theTreeCounter++;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-XmlLoader* SimpleStore::getXmlLoader(XQueryDiagnostics* aXQueryDiagnostics,
-    const store::LoadProperties& loadProperties)
-{
-  if (loadProperties.getParseExternalParsedEntity())
-    return new FragmentXmlLoader(theItemFactory,
-                                 aXQueryDiagnostics,
-                                 loadProperties,
-                                 store::Properties::instance()->buildDataguide());
-  else if (loadProperties.getDTDValidate())
-    return new DtdXmlLoader(theItemFactory,
-                            aXQueryDiagnostics,
-                            loadProperties,
-                            store::Properties::instance()->buildDataguide());
-  else
-    return new FastXmlLoader(theItemFactory,
-                             aXQueryDiagnostics,
-                             loadProperties,
-                             store::Properties::instance()->buildDataguide());
-}
-
-
-/*******************************************************************************
-  Create an index with a given URI and return an rchandle to the index object.
-  If an index with the given URI exists already and the index we want to create
-  is not a temporary one, raise an error.
-********************************************************************************/
-store::Index_t SimpleStore::createIndex(
-    const store::Item_t& qname,
-    const store::IndexSpecification& spec,
-    store::Iterator* sourceIter)
-{
-  store::Item* qname2 = const_cast<store::Item*>(qname.getp());
-  store::Index_t index;
-
-  if (!spec.theIsTemp && theIndices.get(qname.getp(), index))
-  {
-    throw ZORBA_EXCEPTION(zerr::ZSTR0001_INDEX_ALREADY_EXISTS,
-    ERROR_PARAMS(qname->getStringValue()));
-  }
-
-  if (spec.theIsGeneral && spec.theIsSorted)
-  {
-    index = new GeneralTreeIndex(qname, spec);
-    populateGeneralIndex(index, sourceIter, spec.getNumColumns());
-  }
-  else if (spec.theIsSorted)
-  {
-    index = new ValueTreeIndex(qname, spec);
-    populateValueIndex(index, sourceIter, spec.getNumColumns());
-  }
-  else if (spec.theIsGeneral)
-  {
-    index = new GeneralHashIndex(qname, spec);
-    populateGeneralIndex(index, sourceIter, spec.getNumColumns());
-  }
-  else
-  {
-    index = new ValueHashIndex(qname, spec);
-    populateValueIndex(index, sourceIter, spec.getNumColumns());
-  }
-
-  if (!spec.theIsTemp)
-  {
-    theIndices.insert(qname2, index);
-  }
-
-  return index;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::populateValueIndex(
-    const store::Index_t& aIndex,
-    store::Iterator* aSourceIter,
-    ulong aNumColumns)
-{
-  if (!aSourceIter)
-    return;
-
-  store::Item_t domainItem;
-  store::IndexKey* key = NULL;
-
-  ValueIndex* index = static_cast<ValueIndex*>(aIndex.getp());
-
-  aSourceIter->open();
-
-  try
-  {
-    while (aSourceIter->next(domainItem))
-    {
-      if (domainItem->isNode() &&
-          domainItem->getCollection() == NULL &&
-          !index->isTemporary())
-      {
-        RAISE_ERROR_NO_LOC(zerr::ZDDY0020_INDEX_DOMAIN_NODE_NOT_IN_COLLECTION,
-        ERROR_PARAMS(index->getName()->getStringValue()));
-      }
-
-      if (key == NULL)
-        key = new store::IndexKey(aNumColumns);
-
-      for (ulong i = 0; i < aNumColumns; ++i)
-      {
-        if (!aSourceIter->next((*key)[i]))
-        {
-          // The source iter is a ValueIndexEntryBuilderIterator, whose next()
-          // method is guaranteed to return true exactly once. The result from
-          // this single successful next() may be a NULL item.
-          RAISE_ERROR_NO_LOC(zerr::ZXQP0003_INTERNAL_ERROR,
-          ERROR_PARAMS(ZED(IncompleteKeyInIndexBuild)));
-        }
-      }
-
-      index->insert(key, domainItem);
-    }
-  }
-  catch(...)
-  {
-    if (key != NULL)
-      delete key;
-
-    aSourceIter->close();
-    throw;
-  }
-
-  if (key != NULL)
-    delete key;
-
-  aSourceIter->close();
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::populateGeneralIndex(
-    const store::Index_t& idx,
-    store::Iterator* sourceIter,
-    ulong numColumns)
-{
-  store::Item_t domainNode;
-  store::Item_t firstKeyItem;
-  store::Item_t keyItem;
-
-  GeneralIndex* index = static_cast<GeneralIndex*>(idx.getp());
-
-  sourceIter->open();
-
-  try
-  {
-    if (sourceIter->next(domainNode))
-    {
-      bool more = true;
-
-      assert(domainNode->isNode());
-      assert(keyItem == NULL);
-
-      // Compute the keys associated with the current domain node. Note: We
-      // must check whether the domain node has more than one key, before we
-      // do any insertions in the index.
-      while (more)
-      {
-        if (domainNode->getCollection() == NULL && !index->isTemporary())
-        {
-          RAISE_ERROR_NO_LOC(zerr::ZDDY0020_INDEX_DOMAIN_NODE_NOT_IN_COLLECTION,
-          ERROR_PARAMS(index->getName()->getStringValue()));
-        }
-
-        // Compute 1st key, or next domain node
-        more = sourceIter->next(firstKeyItem);
-
-        // If current node has no keys, put it in the "null" entry and continue
-        // with the next domain node, if nay.
-        if (!more || firstKeyItem->isNode())
-        {
-          index->insert(keyItem, domainNode);
-
-          domainNode.transfer(firstKeyItem);
-          continue;
-        }
-
-        // Compute 2nd key, or next domain node
-        more = sourceIter->next(keyItem);
-
-        // If current domain node has exactly 1 key, insert it in the index
-        // and continue with next domain node, if any.
-        if (!more || keyItem->isNode())
-        {
-          index->insert(firstKeyItem, domainNode);
-
-          domainNode.transfer(keyItem);
-          continue;
-        }
-
-        // Current domain node has at least 2 keys. So insert them in the index.
-        // Note: we have to copy the domainNode rchandle because index->insert()
-        // will transfer the given node.
-        index->setMultiKey();
-
-        store::Item_t node = domainNode;
-        index->insert(firstKeyItem, node);
-        node = domainNode;
-        index->insert(keyItem, node);
-
-        // Compute next keys or next domain node.
-        while ((more = sourceIter->next(keyItem)))
-        {
-          if (keyItem->isNode())
-          {
-            domainNode.transfer(keyItem);
-            break;
-          }
-
-          node = domainNode;
-          index->insert(keyItem, node);
-        }
-      }
-    }
-  }
-  catch(...)
-  {
-    sourceIter->close();
-
-    throw;
-  }
-
-  sourceIter->close();
-}
-
-
-/*******************************************************************************
-  Refreshes an index with a given URI and return an rchandle to the index object.
-  If an index with the given URI exists already and the index we want to create
-  is not a temporary one, raise an error.
-********************************************************************************/
-store::Index_t SimpleStore::refreshIndex(
-    const store::Item_t& qname,
-    const store::IndexSpecification& spec,
-    store::Iterator* sourceIter)
-{
-  store::Index_t index;
-  store::Item* non_const_items = const_cast<store::Item*>(qname.getp());
-
-  if (!theIndices.get(non_const_items, index))
-  {
-    throw ZORBA_EXCEPTION(
-      zerr::ZSTR0002_INDEX_DOES_NOT_EXIST,
-      ERROR_PARAMS( qname->getStringValue() )
-    );
-  }
-
-  deleteIndex(qname);
-
-  try
-  {
-    createIndex(qname, index->getSpecification(), sourceIter);
-  }
-  catch (...)
-  {
-    addIndex(index);
-    throw;
-  }
-
-  return index;
-}
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::addIndex(store::Index_t& index)
-{
-  if (index == NULL)
-    return;
-
-  store::Item* qname = const_cast<store::Item*>(index->getName());
-
-  theIndices.insert(qname, index);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Index* SimpleStore::getIndex(const store::Item* qname)
-{
-  if (qname == NULL)
-    return NULL;
-
-  store::Item* qname2 = const_cast<store::Item*>(qname);
-  store::Index_t index;
-
-  if (theIndices.get(qname2, index))
-    return index.getp();
-
-  return NULL;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::deleteIndex(const store::Item* qname)
-{
-  if (qname == NULL)
-    return;
-
-  store::Item* qname2 = const_cast<store::Item*>(qname);
-
-  theIndices.erase(qname2);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Iterator_t SimpleStore::listIndexNames()
-{
-  return new NameIterator<IndexSet>(theIndices);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::IC_t SimpleStore::activateIC(
-    const store::Item_t& icQName,
-    const store::Item_t& collectionQName,
-    bool& isApplied)
-{
-  ZORBA_ASSERT(icQName != NULL);
-
-  store::Item* qname = icQName.getp();
-
-  store::IC_t ic;
-
-  if (theICs.get(qname, ic))
-  {
-    return ic; // already activated => noop
-  }
-
-  ic = new ICCollectionImpl(icQName, collectionQName);
-
-  theICs.insert(qname, ic);
-
-  isApplied=true;
-  return ic;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::IC_t SimpleStore::activateForeignKeyIC(
-    const store::Item_t& icQName,
-    const store::Item_t& fromCollectionQName,
-    const store::Item_t& toCollectionQName,
-    bool& isApplied)
-{
-  ZORBA_ASSERT(icQName != NULL);
-
-  store::Item* qname = const_cast<store::Item*>(icQName.getp());
-
-  store::IC_t ic;
-
-  if (theICs.get(qname, ic))
-  {
-    return ic; // already activated => noop
-  }
-
-  ic = new ICForeignKeyImpl(qname, fromCollectionQName, toCollectionQName);
-
-  theICs.insert(qname, ic);
-
-  isApplied=true;
-  return ic;
-}
-
-
-store::IC_t
-SimpleStore::deactivateIC(const store::Item_t& icQName,
-    bool& isApplied)
-{
-  ZORBA_ASSERT(icQName != NULL);
-
-  store::IC_t ic;
-
-  if (!theICs.get(icQName.getp(), ic))
-  {
-    return ic; // already deactivated in the same PUL => noop
-  }
-
-  theICs.erase(icQName.getp());
-  isApplied=true;
-  return ic;
-}
-
-
-store::Iterator_t SimpleStore::listActiveICNames()
-{
-  return new NameIterator<ICSet>(theICs);
-}
-
-
-store::IC* SimpleStore::getIC(const store::Item* icQName)
-{
-  store::Item* qname = const_cast<store::Item*>(icQName);
-  store::IC_t ic;
-  theICs.get(qname, ic);
-
-  return ic.getp();
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Index*
-SimpleStore::getMap(const store::Item* aQName) const
-{
-  store::Item* lQName = const_cast<store::Item*>(aQName);
-  store::Index_t lIndex;
-  const_cast<IndexSet*>(&theHashMaps)->get(lQName, lIndex);
-
-  return lIndex.getp();
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Iterator_t SimpleStore::listMapNames()
-{
-  return new NameIterator<IndexSet>(theHashMaps);
-}
-
-
-/*******************************************************************************
   Create a collection with a given QName and return an rchandle to the new
   collection object. If a collection with the given QName exists already, raise
   an error.
@@ -963,401 +256,6 @@
 
 
 /*******************************************************************************
-
-********************************************************************************/
-void SimpleStore::addCollection(store::Collection_t& collection)
-{
-  const store::Item* lName = collection->getName();
-
-  bool inserted = theCollections->insert(lName, collection);
-
-  if (!inserted)
-  {
-    throw ZORBA_EXCEPTION(zerr::ZSTR0008_COLLECTION_ALREADY_EXISTS,
-    ERROR_PARAMS(lName->getStringValue()));
-  }
-}
-
-
-/*******************************************************************************
-  Return an rchandle to the Collection object corresponding to the given QName,
-  or NULL if there is no collection with that QName.
-********************************************************************************/
-store::Collection_t SimpleStore::getCollection(
-    const store::Item* aName,
-    bool aDynamicCollection)
-{
-  if (aName == NULL)
-    return NULL;
-
-  store::Collection_t collection;
-  if (theCollections->get(aName, collection, aDynamicCollection))
-  {
-    return collection;
-  }
-  else
-  {
-    return NULL;
-  }
-}
-
-
-/*******************************************************************************
-  Delete the collection with the given QName. If there is no collection with
-  that QName, this method is a NOOP.
-********************************************************************************/
-void SimpleStore::deleteCollection(
-    const store::Item* aName,
-    bool aDynamicCollection)
-{
-  if (aName == NULL)
-    return;
-
-  if (!theCollections->remove(aName, aDynamicCollection))
-  {
-    throw ZORBA_EXCEPTION(zerr::ZSTR0009_COLLECTION_NOT_FOUND,
-    ERROR_PARAMS(aName->getStringValue()));
-  }
-}
-
-
-/*******************************************************************************
-  Returns an iterator that lists the QName's of all the available collections.
-********************************************************************************/
-store::Iterator_t SimpleStore::listCollectionNames(bool aDynamicCollections)
-{
-  return theCollections->names(aDynamicCollections);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Item_t SimpleStore::loadDocument(
-    const zstring& baseUri,
-    const zstring& docUri,
-    std::istream& stream,
-    const store::LoadProperties& loadProperties)
-{
-  zstring_b urib;
-
-  if (!docUri.empty())
-    urib.wrap_memory(docUri.data(), docUri.size());
-
-  XmlNode_t root;
-  bool found = theDocuments.get(urib, root);
-
-  if (found)
-  {
-    return root.getp();
-  }
-
-  XQueryDiagnostics lXQueryDiagnostics;
-  std::auto_ptr<XmlLoader> loader(getXmlLoader(&lXQueryDiagnostics, loadProperties));
-
-  root = loader->loadXml(baseUri, docUri, stream);
-
-  if (!lXQueryDiagnostics.errors().empty())
-  {
-    lXQueryDiagnostics.errors().front()->polymorphic_throw();
-  }
-
-  if (root != NULL && loadProperties.getStoreDocument())
-    theDocuments.insert(urib, root);
-
-  return root.getp();
-}
-
-
-/*******************************************************************************
-  For lazy loading...
-  Param stream is a heap pointer to an input stream. This is to be deallocated
-  by Zorba.
-********************************************************************************/
-store::Item_t SimpleStore::loadDocument(
-    const zstring& baseUri,
-    const zstring& docUri,
-    std::istream* stream,
-    const store::LoadProperties& loadProperties)
-{
-  store::Item_t docitem;
-  try
-  {
-    //do full loading for now
-    docitem = loadDocument(baseUri, docUri, *stream, loadProperties);
-    delete stream;
-  }
-  catch(...)
-  {
-    delete stream;
-  }
-  return docitem;
-}
-
-
-/*******************************************************************************
-  Add the given node with the given uri to the store. Essentially, this method
-  establishes an association between a uri and a node. If the given uri is
-  already associated to another node, the method raises an error. If the given
-  uri is already associated to the given node, this method is a noop.
-********************************************************************************/
-void SimpleStore::addNode(const zstring& uri, const store::Item_t& node)
-{
-  ZORBA_ASSERT(!uri.empty());
-
-  if (node == NULL || !node->isNode())
-  {
-    RAISE_ERROR_NO_LOC(zerr::ZAPI0021_ITEM_TO_LOAD_IS_NOT_NODE, ERROR_PARAMS(uri));
-  }
-
-  XmlNode_t root = reinterpret_cast<XmlNode*>(node.getp());
-
-  bool inserted = theDocuments.insert(uri, root);
-
-  if (!inserted && node.getp() != root.getp())
-  {
-    RAISE_ERROR_NO_LOC(zerr::ZAPI0020_DOCUMENT_ALREADY_EXISTS, ERROR_PARAMS(uri));
-  }
-
-  ZORBA_FATAL(node.getp() == root.getp(), "");
-}
-
-
-/*******************************************************************************
-  Return an rchandle to an iterator over the set of documents in the store
-********************************************************************************/
-store::Iterator_t SimpleStore::getDocumentNames() const
-{
-  return new DocumentNameIterator<DocumentSet>(theDocuments);
-}
-
-
-/*******************************************************************************
-  Return an rchandle to the root node of the document corresponding to the given
-  URI, or NULL if there is no document with that URI.
-********************************************************************************/
-store::Item_t SimpleStore::getDocument(const zstring& uri)
-{
-  if (uri.empty())
-    return NULL;
-
-  XmlNode_t root;
-
-  bool found = theDocuments.get(uri, root);
-
-  if (found)
-    return root.getp();
-
-  return NULL;
-}
-
-
-/*******************************************************************************
-  Delete the document with the given URI. If there is no document with that
-  URI, this method is a NOOP.
-********************************************************************************/
-void SimpleStore::deleteDocument(const zstring& uri)
-{
-  if (uri.empty())
-    return;
-
-  theDocuments.erase(uri);
-}
-
-
-/*******************************************************************************
-  Delete all the documents.
-********************************************************************************/
-void SimpleStore::deleteAllDocuments()
-{
-  theDocuments.clear();
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Index_t
-SimpleStore::createHashMap(
-    const store::Item_t& aQName,
-    const store::IndexSpecification& aSpec)
-{
-  store::Index_t lIndex;
-
-  if (theHashMaps.get(aQName.getp(), lIndex))
-  {
-    throw ZORBA_EXCEPTION(
-      zerr::ZSTR0001_INDEX_ALREADY_EXISTS,
-      ERROR_PARAMS( aQName->getStringValue() )
-    );
-  }
-
-  lIndex = new ValueHashIndex(aQName, aSpec);
-
-  addHashMap(lIndex);
-
-  return lIndex;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Index_t
-SimpleStore::destroyHashMap(const store::Item_t& aQName)
-{
-  store::Index_t lIndex;
-  if (!theHashMaps.get(aQName.getp(), lIndex))
-  {
-    throw ZORBA_EXCEPTION(
-      zerr::ZDDY0023_INDEX_DOES_NOT_EXIST,
-      ERROR_PARAMS( aQName->getStringValue() )
-    );
-  }
-  theHashMaps.erase(aQName.getp());
-  return lIndex;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-store::Index_t
-SimpleStore::getHashMap(const store::Item_t& aQName) const
-{
-  store::Index_t lIndex;
-  if (const_cast<IndexSet*>(&theHashMaps)->get(aQName.getp(), lIndex))
-  {
-    return lIndex;
-  }
-  else
-  {
-    return 0;
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void
-SimpleStore::addHashMap(const store::Index_t& aIndex)
-{
-  store::Item* lName = aIndex->getName();
-  store::Index_t lIndex = aIndex;
-  theHashMaps.insert(lName, lIndex);
-}
-
-/*******************************************************************************
-  Compare two nodes, based on their node id. Return -1 if node1 < node2, 0, if
-  node1 == node2, or 1 if node1 > node2.
-********************************************************************************/
-short SimpleStore::compareNodes(store::Item* node1, store::Item* node2) const
-{
-  ZORBA_FATAL(node1->isNode(), "");
-  ZORBA_FATAL(node2->isNode(), "");
-
-  if (node1 == node2)
-    return 0;
-
-  XmlNode* n1 = static_cast<XmlNode*>(node1);
-  XmlNode* n2 = static_cast<XmlNode*>(node2);
-
-  return (short)n1->compare2(n2);
-}
-
-
-/*******************************************************************************
-  Sorts the items of the passed iterator
-
-  @param iterator to sort
-  @param ascendent true for ascendent and false for descendant
-  @param duplicate duplicate elemination should be applied
-  @return iterator which produces the sorted items
-********************************************************************************/
-store::Iterator_t SimpleStore::sortNodes(
-    store::Iterator* input,
-    bool ascendent,
-    bool duplicateElemination,
-    bool aAllowAtomics)
-{
-  if (aAllowAtomics)
-    return new StoreNodeSortOrAtomicIterator(input, ascendent, duplicateElemination);
-  else
-    return new StoreNodeSortIterator(input, ascendent, duplicateElemination);
-}
-
-
-/*******************************************************************************
-  Create an iterator that eliminates the duplicate nodes in the set of items
-  which is produced by the passed iterator
-********************************************************************************/
-store::Iterator_t SimpleStore::distinctNodes(
-    store::Iterator* input,
-    bool aAllowAtomics)
-{
-  if (aAllowAtomics)
-    return new StoreNodeDistinctOrAtomicIterator(input);
-  else
-    return new StoreNodeDistinctIterator(input, false);
-}
-
-
-/*******************************************************************************
-  Create an iterator that checks for duplicate nodes in the set of nodes which
-  is produced by the passed iterator, and raises an error if any duplicates
-  are found. If no duplicates are found, the iterator simply passes on the
-  input nodes to its consumer.
-********************************************************************************/
-store::Iterator_t SimpleStore::checkDistinctNodes(store::Iterator* input)
-{
-  return new StoreNodeDistinctIterator(input, true);
-}
-
-
-/*******************************************************************************
-  Computes the Structural Reference for the given node.
-********************************************************************************/
-bool SimpleStore::getStructuralInformation(
-    store::Item_t& result,
-    const store::Item* node)
-{
-#ifdef TEXT_ORDPATH
-  const OrdPathNode* n = static_cast<const OrdPathNode*>(node);
-
-  return theItemFactory->createStructuralAnyURI(result,
-                                                n->getCollectionId(),
-                                                n->getTreeId(),
-                                                n->getNodeKind(),
-                                                n->getOrdPath());
-#else
-  if (node->getNodeKind() == store::StoreConsts::textNode)
-  {
-    OrdPath ordPath;
-    const TextNode* n = static_cast<const TextNode*>(node);
-    n->getOrdPath(ordPath);
-
-    return theItemFactory->createStructuralAnyURI(result,
-                                                  n->getCollectionId(),
-                                                  n->getTreeId(),
-                                                  store::StoreConsts::textNode,
-                                                  ordPath);
-  }
-  else
-  {
-    const OrdPathNode* n = static_cast<const OrdPathNode*>(node);
-
-    return theItemFactory->createStructuralAnyURI(result,
-                                                  n->getCollectionId(),
-                                                  n->getTreeId(),
-                                                  n->getNodeKind(),
-                                                  n->getOrdPath());
-  }
-#endif
-}
-
-
-/*******************************************************************************
  Computes the reference of the given node.
 
  @param node XDM node
@@ -1391,6 +289,18 @@
 
 
 /*******************************************************************************
+  Returns whether a reference has already been generated for the given node.
+ 
+  @param item XDM node
+  @return whether a reference has already been generated for the given node.
+********************************************************************************/
+bool SimpleStore::hasReference(const store::Item* node)
+{
+  return static_cast<const XmlNode*>(node)->haveReference();
+}
+
+
+/*******************************************************************************
   Returns the node which is identified by the given reference.
 
   @param reference an xs:anyURI item
@@ -1420,18 +330,6 @@
 
 
 /*******************************************************************************
-  Returns whether a reference has already been generated for the given node.
-
-  @param item XDM node
-  @return whether a reference has already been generated for the given node.
-********************************************************************************/
-bool SimpleStore::hasReference(const store::Item* node)
-{
-  return static_cast<const XmlNode*>(node)->haveReference();
-}
-
-
-/*******************************************************************************
   Removes a node from the reference-to-nodes and nodes-to-references maps.
 
   @param node XDM node
@@ -1461,121 +359,5 @@
 }
 
 
-/*******************************************************************************
-
-********************************************************************************/
-bool SimpleStore::getPathInfo(
-    const store::Item*               docUriItem,
-    std::vector<const store::Item*>& contextPath,
-    std::vector<const store::Item*>& relativePath,
-    bool                             isAttrPath,
-    bool&                            found,
-    bool&                            unique)
-{
-  zstring docUri;
-  docUriItem->getStringValue2(docUri);
-
-  XmlNode_t docRoot = BASE_NODE(getDocument(docUri));
-
-  if (docRoot == NULL)
-    return false;
-
-#ifdef DATAGUIDE
-  GuideNode* guideRoot = docRoot->getDataGuide();
-
-  if (!guideRoot)
-    return false;
-
-  guideRoot->getPathInfo(contextPath, relativePath, isAttrPath, found, unique);
-#endif
-  return true;
-}
-
-
-/*******************************************************************************
-  Creates a new TempSeq. The instance can be used, e.g. for variable bindings
-
-  @param iterator   The source for the XMDInstance
-  @param lazy       Hint for the store. If possible a XMDInstance should be
-                    evaluated lazily. For XQueryP it might be necassary to set
-                    this to false.
-********************************************************************************/
-TempSeq_t SimpleStore::createTempSeq(const store::Iterator_t& iterator, bool lazy)
-{
-  if(lazy)
-  {
-    //tempSeq = new SimpleTempSeq(iterator, copyNodes);
-    return new SimpleLazyTempSeq(iterator);
-  }
-  else
-  {
-    return new SimpleTempSeq(iterator);
-  }
-}
-
-
-/*******************************************************************************
-  Creates an empty TempSeq.
-********************************************************************************/
-TempSeq_t SimpleStore::createTempSeq(bool lazy)
-{
-  if (lazy)
-  {
-    return new SimpleLazyTempSeq();
-  }
-  else
-  {
-    return new SimpleTempSeq();
-  }
-}
-
-
-/*******************************************************************************
-  Creates a temp seq initialized by the given vector.
-  @param item_v - The vector to use to initialize the seq.
-********************************************************************************/
-TempSeq_t SimpleStore::createTempSeq(std::vector<store::Item_t>& items)
-{
-  return new SimpleTempSeq(items);
-}
-
-
-/*******************************************************************************
-  Creates a temp seq initialized by the given item.
-********************************************************************************/
-TempSeq_t SimpleStore::createTempSeq(store::Item_t& item)
-{
-  return new SimpleTempSeq(item);
-}
-
-
-#ifndef ZORBA_NO_FULL_TEXT
-void SimpleStore::setStemmerProvider( internal::StemmerProvider const *p ) 
-{
-  theStemmerProvider = p;
-}
-
-
-void SimpleStore::setTokenizerProvider( TokenizerProvider const *p ) 
-{
-  theTokenizerProvider = p;
-}
-
-
-internal::StemmerProvider const* SimpleStore::getStemmerProvider() const 
-{
-  return theStemmerProvider ?
-    theStemmerProvider : &internal::StemmerProvider::get_default();
-}
-
-
-TokenizerProvider const* SimpleStore::getTokenizerProvider() const 
-{
-  return theTokenizerProvider ?
-    theTokenizerProvider : &default_tokenizer_provider();
-}
-#endif /* ZORBA_NO_FULL_TEXT */
-
-} // namespace store
+} // namespace simplestore
 } // namespace zorba
-/* vim:set et sw=2 ts=2: */

=== modified file 'src/store/naive/simple_store.h'
--- src/store/naive/simple_store.h	2012-03-26 01:31:32 +0000
+++ src/store/naive/simple_store.h	2012-03-27 01:25:22 +0000
@@ -16,107 +16,21 @@
 #ifndef ZORBA_SIMPLE_STORE
 #define ZORBA_SIMPLE_STORE
 
-#include "shared_types.h"
-#include "store_defs.h"
-#include "hashmap_nodep.h"
-
-#if (defined (WIN32) || defined (WINCE))
-#include "node_items.h"
-#include "store/api/collection.h"
-#include "store/api/index.h"
-#include "store/api/ic.h"
-#endif
-
-#include "store/api/store.h"
-
-#include "store/util/hashmap_stringbuf.h"
-
-#include "zorbautils/mutex.h"
-#include "zorbautils/lock.h"
-#include "zorbautils/hashmap_itemp.h"
-#include "zorbautils/hashmap_zstring_nonserializable.h"
-
-namespace zorba
-{
-  class StoreManager;
-
-class XQueryDiagnostics;
-
-namespace store
-{
-  class IteratorFactory;
-  class ValueIndexSpecification;
-}
-
-namespace simplestore
-{
-
-class StringPool;
-class QNamePool;
-class XmlLoader;
-class FastXmlLoader;
-class Index;
-class BasicItemFactory;
-class NodeFactory;
-class PULPrimitiveFactory;
-
-typedef zorba::HashMapZString<XmlNode_t> DocumentSet;
-typedef ItemPointerHashMap<store::Index_t> IndexSet;
-typedef ItemPointerHashMap<store::IC_t> ICSet;
-
+#include "store.h"
+
+namespace zorba {
+namespace simplestore {
 
 
 /*******************************************************************************
-  theSchemaTypeNames:
-  -------------------
-  Maps each enum value from SchemaTypeNames (see store/api/xs_types_enum.h) to 
-  its associated QName item.
-
-  theSchemaTypeCodes:
-  -------------------
 
   theCollectionCounter:
   ---------------------
   Incremented every time a new collection is created. The current value of the  
   counter is then assigned as the id of the new collection.
 
-  theNamespacePool:
-  -----------------
-
-  theQNamePool:
-  -------------
-
-  theItemFactory:
-  ---------------
-  Factory to create items.
-
-  theIteratorFactory:
-  -------------------
-  Factory to create iterators.
-
-  theNodeFactory:
-  ---------------
-  Factory to create node items.
-
-  theDocuments:
-  -------------
-  A hashmap that for each xml tree that does not belong to any collection, maps
-  the URI of the tree to the root node of the tree.
-
-  theCollections:
-  ---------------
-  Container which contains the collections of the store. It includes a map that
-  maps the qname of each collection to the collection's container object.
-
-  theIndices:  
-  -----------
-  A hashmap that for each index, maps the qname of the index to the index 
-  container object.
-  
-  theICs:
-  -------
-  A hashmap the for each integrity constraint, maps the qname of the ic to the
-  ic's container object.
+  theTreeCounter:
+  ---------------
 
   theReferencesToNodeMap:
   -----------------------
@@ -127,307 +41,76 @@
   A hashmap that maps nodes into their references
 
 ********************************************************************************/
-class SimpleStore : public store::Store
+class SimpleStore : public Store
 {
   friend class zorba::StoreManager;
 
   typedef std::map<const zstring, const store::Item*> RefNodeMap;
   typedef NodePointerHashMap<zstring> NodeRefMap;
 
-public:
-  static const char* XS_URI;
-  static const char* XML_URI;
-  static const char* ZXSE_URI;
-
-  static const ulong XML_URI_LEN;
-
-protected:
-  static const ulong NAMESPACE_POOL_SIZE;
-  static const ulong DEFAULT_DOCUMENT_SET_SIZE;
-  static const ulong DEFAULT_URI_COLLECTION_SET_SIZE;
-  static const ulong DEFAULT_INDICES_SET_SIZE;
-  static const ulong DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE;
-
-public:
-  zstring                       theEmptyNs;
-  zstring                       theXmlSchemaNs;
-
-  std::vector<store::Item_t>    theSchemaTypeNames;
-  std::map<store::Item*, store::SchemaTypeCode> theSchemaTypeCodes;
-  store::Item_t                 XS_UNTYPED_QNAME;
-  store::Item_t                 XS_ANY_QNAME;
-  store::Item_t                 XS_ANY_SIMPLE_QNAME;
-
-protected:
-  ulong                         theNumUsers;
-
-  ulong                         theUriCounter;
-  SYNC_CODE(Mutex               theUriCounterMutex;)
-
+private:
   ulong                         theCollectionCounter;
   SYNC_CODE(Mutex               theCollectionCounterMutex;)
 
   ulong                         theTreeCounter;
   SYNC_CODE(Mutex               theTreeCounterMutex;)
 
-  StringPool                  * theNamespacePool;
-  QNamePool                   * theQNamePool;
-
-  BasicItemFactory            * theItemFactory;
-  store::IteratorFactory      * theIteratorFactory;
-  NodeFactory                 * theNodeFactory;
-  PULPrimitiveFactory         * thePULFactory;
-
-  DocumentSet                   theDocuments;
-  CollectionSet*                theCollections;
-  IndexSet                      theIndices;
-  ICSet                         theICs;
-  IndexSet                      theHashMaps;
-
-  SYNC_CODE(Lock                theGlobalLock;)
-
-  long                          theTraceLevel;
-
   RefNodeMap                    theReferencesToNodeMap;
   NodeRefMap                    theNodeToReferencesMap;
 
-#ifndef ZORBA_NO_FULL_TEXT
-  internal::StemmerProvider const * theStemmerProvider;
-  TokenizerProvider const     * theTokenizerProvider;
-#endif /* ZORBA_NO_FULL_TEXT */
-
 public:
-  void shutdown(bool soft = true);
-
-  store::ItemFactory* getItemFactory() const;
-
-  store::IteratorFactory* getIteratorFactory() const { return theIteratorFactory; }
-
-  NodeFactory& getNodeFactory() const { return *theNodeFactory; }
-
-  PULPrimitiveFactory& getPULFactory() const { return *thePULFactory; }
-
-  StringPool& getNamespacePool() const { return *theNamespacePool; }
-
-  QNamePool& getQNamePool() const { return *theQNamePool; }
-
-  SYNC_CODE(Lock& getGlobalLock() { return theGlobalLock; })
-
-  long getTraceLevel() const { return theTraceLevel; }
-
-  XmlLoader* getXmlLoader(
-      XQueryDiagnostics*,
-      const store::LoadProperties& loadProperties);
-
+  ulong createTreeId();
+  
   ulong createCollectionId();
 
-  ulong createTreeId();
-
   store::Collection_t createCollection(
       const store::Item_t& aName,
       const std::vector<store::Annotation_t>& annotations,
       const store::Item_t& aNodeType,
       bool aDynamicCollection = false);
 
-  void deleteCollection(
-      const store::Item* aName,
-      bool aDynamicCollection = false);
-
-  store::Collection_t getCollection(
-      const store::Item* aName,
-      bool aDynamicCollection = false);
-
-  void addCollection(store::Collection_t& collection);
-
-  store::Iterator_t listCollectionNames(bool aDynamicCollections = false);
-
-  store::Index_t createIndex(
-      const store::Item_t& qname,
-      const store::IndexSpecification& spec,
-      store::Iterator* sourceIter);
-  
-  // needs to be virtual to allow implementation of additional stores
-  virtual void populateValueIndex(
-      const store::Index_t& index,
-      store::Iterator* sourceIter,
-      ulong numColumns);
-
-  // needs to be virtual to allow implementation of additional stores
-  virtual void populateGeneralIndex(
-      const store::Index_t& index,
-      store::Iterator* sourceIter,
-      ulong numColumns);
-
-  // needs to be virtual to allow implementation of additional stores
-  virtual store::Index_t refreshIndex(
-      const store::Item_t& qname,
-      const store::IndexSpecification& spec,
-      store::Iterator* sourceIter);
-
-  // needs to be virtual to allow implementation of additional stores
-  virtual const IndexSet& getIndices() const { return theIndices; }
-
-  void addIndex(store::Index_t& index);
-
-  store::Index* getIndex(const store::Item* qname);
-
-  void deleteIndex(const store::Item* qname);
-
-  store::Iterator_t listIndexNames();
-
-  store::IC_t activateIC(
-      const store::Item_t& icQName,
-      const store::Item_t& collectionQName,
-      bool& isApplied);
-  
-  store::IC_t activateForeignKeyIC(
-      const store::Item_t& icQName,
-      const store::Item_t& fromCollectionQName,
-      const store::Item_t& toCollectionQName,
-      bool& isApplied);
-
-  store::IC_t deactivateIC(
-      const store::Item_t& icQName,
-      bool& isApplied);
-
-  store::Iterator_t listActiveICNames();
-
-  store::IC* getIC(const store::Item* icQName);
-
-  /*****************************************************************************
-  
-  *****************************************************************************/
-  virtual store::Index* getMap(const store::Item* aQName) const;
-
-  virtual store::Iterator_t listMapNames();
-
-  /*****************************************************************************
-  
-  *****************************************************************************/
-  store::Item_t loadDocument(
-        const zstring& baseUri,
-        const zstring& docUri,
-        std::istream& stream,
-        const store::LoadProperties& loadProperties);
-
-  store::Item_t loadDocument(
-        const zstring& baseUri,
-        const zstring& docUri,
-        std::istream* stream,
-        const store::LoadProperties& loadProperties);
-
-  /*****************************************************************************
-  
-  *****************************************************************************/
-  void addNode(const zstring& uri, const store::Item_t& node);
-
-  store::Iterator_t getDocumentNames() const;
-
-  store::Item_t getDocument(const zstring& uri);
-
-  void deleteDocument(const zstring& uri);
-
-  void deleteAllDocuments();
-
-  /*****************************************************************************
-  
-  *****************************************************************************/
-  store::Index_t createHashMap(
-      const store::Item_t& aQName,
-      const store::IndexSpecification& aSpec);
-
-  store::Index_t destroyHashMap(const store::Item_t& aQName);
-
-  store::Index_t getHashMap(const store::Item_t& aQName) const;
-
-  void addHashMap(const store::Index_t& aMap);
-
-  /*****************************************************************************
-  
-  *****************************************************************************/
-  short compareNodes(store::Item* node1, store::Item* node2) const;
-
-  store::Iterator_t sortNodes(
-        store::Iterator* iterator,
-        bool ascendent,
-        bool duplicateElemination,
-        bool aAllowAtomics = false);
-
-  store::Iterator_t distinctNodes(store::Iterator* input, bool aAllowAtomics);
-
-  store::Iterator_t checkDistinctNodes(store::Iterator* input);
-
-  bool getStructuralInformation(store::Item_t& result, const store::Item* node);
-
-  bool getPathInfo(
-        const store::Item* docUri,
-        std::vector<const store::Item*>& contextPath,
-        std::vector<const store::Item*>& relativePath,
-        bool isAttrPath,
-        bool& found,
-        bool& unique);
-
-  /* ------------------------ Node Reference Management ---------------------------*/
-
-  bool getNodeReference(store::Item_t& result, const store::Item* node);
-
-  bool hasReference(const store::Item* node);
-
-  bool getNodeByReference(store::Item_t& result, const zstring& reference);
-
-  bool unregisterNode(XmlNode* node);
-
-  /* ------------------------ Temp Sequence Management ---------------------------*/
-
-  store::TempSeq_t createTempSeq(bool lazy);
-
-  store::TempSeq_t createTempSeq(const store::Iterator_t& iterator, bool lazy);
-
-  store::TempSeq_t createTempSeq(std::vector<store::Item_t>& item_v);
-
-  store::TempSeq_t createTempSeq(store::Item_t& item);
-
-#ifndef ZORBA_NO_FULL_TEXT
-  internal::StemmerProvider const* getStemmerProvider() const;
-
-  void setStemmerProvider(internal::StemmerProvider const*);
-#endif /* ZORBA_NO_FULL_TEXT */
-
 protected:
   SimpleStore();
 
   virtual ~SimpleStore();
-
+  
   void init();
-
-  void initTypeNames();
-
-  // Functions to create/destory the node and item factories. These functions
-  // are called from init and shutdown, respectively. Having this functionality
-  // factorized allows others to derive from the SimpleStore and provide their
-  // own factories.
-
-  virtual NodeFactory* createNodeFactory() const;
-
-  virtual void destroyNodeFactory(NodeFactory*) const;
-
-  virtual BasicItemFactory* createItemFactory() const;
-
-  virtual void destroyItemFactory(BasicItemFactory*) const;
-
-  virtual PULPrimitiveFactory* createPULPrimitiveFactory() const;
-
-  virtual void destroyPULPrimitiveFactory(PULPrimitiveFactory*) const;
-
-  virtual CollectionSet* createCollectionSet() const;
-
-  virtual void destroyCollectionSet(CollectionSet*) const;
-
-#ifndef ZORBA_NO_FULL_TEXT
-  TokenizerProvider const* getTokenizerProvider() const;
-
-  void setTokenizerProvider(TokenizerProvider const*);
-#endif /* ZORBA_NO_FULL_TEXT */
+  
+  void shutdown(bool soft);
+
+  NodeFactory* createNodeFactory() const;
+
+  void destroyNodeFactory(NodeFactory*) const;
+
+  store::ItemFactory* createItemFactory() const;
+
+  void destroyItemFactory(store::ItemFactory*) const;
+
+  store::IteratorFactory* createIteratorFactory() const;
+
+  void destroyIteratorFactory(store::IteratorFactory*) const;
+
+  PULPrimitiveFactory* createPULFactory() const;
+
+  void destroyPULFactory(PULPrimitiveFactory*) const;
+
+  CollectionSet* createCollectionSet() const;
+
+  void destroyCollectionSet(CollectionSet*) const;
+      
+  bool unregisterNode(XmlNode* node);
+
+  //
+  // Store api methods
+  //
+
+  bool getNodeReference(store::Item_t& result, const store::Item* node);
+
+  bool hasReference(const store::Item* node);
+
+  bool getNodeByReference(
+      store::Item_t& result,
+      const zstring& reference);
 };
 
 } // namespace store

=== added file 'src/store/naive/store.cpp'
--- src/store/naive/store.cpp	1970-01-01 00:00:00 +0000
+++ src/store/naive/store.cpp	2012-03-27 01:25:22 +0000
@@ -0,0 +1,1322 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "stdafx.h"
+
+#include <iostream>
+#include <climits>
+#include <memory>
+
+#include <libxml/parser.h>
+
+#include "zorbautils/hashfun.h"
+#include "zorbautils/fatal.h"
+#include "zorbatypes/rchandle.h"
+#include "diagnostics/xquery_diagnostics.h"
+#include "diagnostics/assert.h"
+#include "diagnostics/util_macros.h"
+
+#include "store/api/pul.h"
+#include "store/api/xs_type_codes.h"
+
+#include "properties.h"
+#include "string_pool.h"
+#include "store.h"
+#include "simple_temp_seq.h"
+#include "simple_lazy_temp_seq.h"
+#include "collection.h"
+#include "collection_set.h"
+#include "simple_index.h"
+#include "simple_index_value.h"
+#include "simple_index_general.h"
+#include "simple_ic.h"
+#include "qname_pool.h"
+#include "loader.h"
+#include "store_defs.h"
+#include "node_items.h"
+#include "dataguide.h"
+#include "node_iterators.h"
+#include "simple_item_factory.h"
+#include "simple_iterator_factory.h"
+#include "query_context.h"
+#include "item_iterator.h"
+#include "node_factory.h"
+#include "name_iterator.h"
+#include "document_name_iterator.h"
+#include "pul_primitive_factory.h"
+
+#include "util/cxx_util.h"
+#include "util/uuid/uuid.h"
+#include "zorbautils/string_util.h"
+
+#ifndef ZORBA_NO_FULL_TEXT
+#include "runtime/full_text/default_tokenizer.h"
+#include "runtime/full_text/stemmer.h"
+#endif /* ZORBA_NO_FULL_TEXT */
+
+namespace zorba
+{
+
+namespace simplestore
+{
+
+typedef rchandle<store::TempSeq> TempSeq_t;
+
+
+/*******************************************************************************
+  Store static data
+********************************************************************************/
+const ulong Store::NAMESPACE_POOL_SIZE = 128;
+const ulong Store::DEFAULT_DOCUMENT_SET_SIZE = 32;
+const ulong Store::DEFAULT_URI_COLLECTION_SET_SIZE = 32;
+const ulong Store::DEFAULT_INDICES_SET_SIZE = 32;
+const ulong Store::DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE = 32;
+
+const char* Store::XS_URI = "http://www.w3.org/2001/XMLSchema";
+const char* Store::XML_URI = "http://www.w3.org/2001/XML/1998/namespace";
+const char* Store::ZXSE_URI = "http://www.zorba-xquery.com/zorba/schema-extensions";
+
+const ulong Store::XML_URI_LEN = sizeof(Store::XML_URI);
+
+
+/*******************************************************************************
+
+********************************************************************************/
+Store::Store()
+  :
+  theNumUsers(0),
+  theNamespacePool(NULL),
+  theQNamePool(NULL),
+  theItemFactory(NULL),
+  theIteratorFactory(NULL),
+  theNodeFactory(NULL),
+  thePULFactory(NULL),
+  theDocuments(DEFAULT_DOCUMENT_SET_SIZE, true),
+  theCollections(0),
+  theIndices(0, NULL, DEFAULT_INDICES_SET_SIZE, true),
+  theICs(0, NULL, DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE, true),
+  theHashMaps(0, NULL, DEFAULT_INDICES_SET_SIZE, true),
+  theTraceLevel(0)
+#ifndef ZORBA_NO_FULL_TEXT
+  , theStemmerProvider( nullptr )
+  , theTokenizerProvider( nullptr )
+#endif /* ZORBA_NO_FULL_TEXT */
+{
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+Store::~Store()
+{
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::init()
+{
+  SYNC_CODE(AutoLock lock(getGlobalLock(), Lock::WRITE);)
+
+  if (theNumUsers == 0)
+  {
+    // This initializes the libxml2 library and checks potential ABI mismatches
+    // between the version it was compiled for and the actual  shared library used.
+    // Calling its init is done here because we also want to free it at the end,
+    // i.e. when the store is shutdown
+    LIBXML_TEST_VERSION
+
+    store::Properties::load(0, NULL);
+
+    theNamespacePool = new StringPool(NAMESPACE_POOL_SIZE);
+
+    theNamespacePool->insertc("", theEmptyNs);
+    theNamespacePool->insertc(XS_URI, theXmlSchemaNs);
+
+    theQNamePool = new QNamePool(QNamePool::MAX_CACHE_SIZE, theNamespacePool);
+
+    // createItemFactory uses theNamespacePool and theQNamePool
+    // they have to be created before this function is called
+    theItemFactory = createItemFactory();
+
+    initTypeNames();
+
+    theIteratorFactory = createIteratorFactory();
+
+    theNodeFactory = createNodeFactory();
+
+    thePULFactory = createPULFactory();
+
+    theTraceLevel = store::Properties::instance()->storeTraceLevel();
+
+    theCollections = createCollectionSet();
+
+    StoreManagerImpl::theStore = this;
+  }
+
+  ++theNumUsers;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::initTypeNames()
+{
+  const char* ns = XS_URI;
+  BasicItemFactory* f = static_cast<BasicItemFactory*>(theItemFactory);
+
+  theSchemaTypeNames.resize(store::XS_LAST);
+
+  f->createQName(XS_UNTYPED_QNAME, ns, "xs", "untyped");
+
+  f->createQName(XS_ANY_QNAME, ns, "xs", "anyType");
+
+  f->createQName(XS_ANY_SIMPLE_QNAME, ns, "xs", "anySimpleType");
+
+  f->createQName(theSchemaTypeNames[store::XS_ANY_ATOMIC],     ns, "xs", "anyAtomicType");
+
+  f->createQName(theSchemaTypeNames[store::XS_UNTYPED_ATOMIC], ns, "xs", "untypedAtomic");
+
+  f->createQName(theSchemaTypeNames[store::XS_ANY_URI],        ns, "xs", "anyURI");
+
+  f->createQName(theSchemaTypeNames[store::XS_QNAME],          ns, "xs", "QName");
+
+  f->createQName(theSchemaTypeNames[store::XS_NOTATION],       ns, "xs", "NOTATION");
+
+  f->createQName(theSchemaTypeNames[store::XS_STRING],         ns, "xs", "string");
+  f->createQName(theSchemaTypeNames[store::XS_NORMALIZED_STRING], ns, "xs", "normalizedString");
+  f->createQName(theSchemaTypeNames[store::XS_TOKEN],          ns, "xs", "token");
+  f->createQName(theSchemaTypeNames[store::XS_NMTOKEN],        ns, "xs", "NMTOKEN");
+  f->createQName(theSchemaTypeNames[store::XS_LANGUAGE],       ns, "xs", "language");
+  f->createQName(theSchemaTypeNames[store::XS_NAME],           ns, "xs", "Name");
+  f->createQName(theSchemaTypeNames[store::XS_NCNAME],         ns, "xs", "NCName");
+  f->createQName(theSchemaTypeNames[store::XS_ID],             ns, "xs", "ID");
+  f->createQName(theSchemaTypeNames[store::XS_IDREF],          ns, "xs", "IDREF");
+  f->createQName(theSchemaTypeNames[store::XS_ENTITY],         ns, "xs", "ENTITY");
+
+  f->createQName(theSchemaTypeNames[store::XS_DATETIME],       ns, "xs", "dateTime");
+  f->createQName(theSchemaTypeNames[store::XS_DATE],           ns, "xs", "date");
+  f->createQName(theSchemaTypeNames[store::XS_TIME],           ns, "xs", "time");
+  f->createQName(theSchemaTypeNames[store::XS_GYEAR_MONTH],    ns, "xs", "gYearMonth");
+  f->createQName(theSchemaTypeNames[store::XS_GYEAR],          ns, "xs", "gYear");
+  f->createQName(theSchemaTypeNames[store::XS_GMONTH_DAY],     ns, "xs", "gMonthDay");
+  f->createQName(theSchemaTypeNames[store::XS_GDAY],           ns, "xs", "gDay");
+  f->createQName(theSchemaTypeNames[store::XS_GMONTH],         ns, "xs", "gMonth");
+
+  f->createQName(theSchemaTypeNames[store::XS_DURATION],       ns, "xs", "duration");
+  f->createQName(theSchemaTypeNames[store::XS_DT_DURATION],    ns, "xs", "dayTimeDuration");
+  f->createQName(theSchemaTypeNames[store::XS_YM_DURATION],    ns, "xs", "yearMonthDuration");
+
+  f->createQName(theSchemaTypeNames[store::XS_FLOAT],          ns, "xs", "float");
+  f->createQName(theSchemaTypeNames[store::XS_DOUBLE],         ns, "xs", "double");
+  f->createQName(theSchemaTypeNames[store::XS_DECIMAL],        ns, "xs", "decimal");
+  f->createQName(theSchemaTypeNames[store::XS_INTEGER],        ns, "xs", "integer");
+  f->createQName(theSchemaTypeNames[store::XS_NON_POSITIVE_INTEGER], ns, "xs", "nonPositiveInteger");
+  f->createQName(theSchemaTypeNames[store::XS_NON_NEGATIVE_INTEGER], ns, "xs", "nonNegativeInteger");
+  f->createQName(theSchemaTypeNames[store::XS_NEGATIVE_INTEGER], ns, "xs", "negativeInteger");
+  f->createQName(theSchemaTypeNames[store::XS_POSITIVE_INTEGER], ns, "xs", "positiveInteger");
+
+  f->createQName(theSchemaTypeNames[store::XS_LONG],           ns, "xs", "long");
+  f->createQName(theSchemaTypeNames[store::XS_INT],            ns, "xs", "int");
+  f->createQName(theSchemaTypeNames[store::XS_SHORT],          ns, "xs", "short");
+  f->createQName(theSchemaTypeNames[store::XS_BYTE],           ns, "xs", "byte");
+  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_LONG],  ns, "xs", "unsignedLong");
+  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_INT],   ns, "xs", "unsignedInt");
+  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_SHORT], ns, "xs", "unsignedShort");
+  f->createQName(theSchemaTypeNames[store::XS_UNSIGNED_BYTE],  ns, "xs", "unsignedByte");
+
+  f->createQName(theSchemaTypeNames[store::XS_BASE64BINARY],   ns, "xs", "base64Binary");
+  f->createQName(theSchemaTypeNames[store::XS_HEXBINARY],      ns, "xs", "hexBinary");
+  f->createQName(theSchemaTypeNames[store::XS_BOOLEAN],        ns, "xs", "boolean");
+
+  for (ulong i = 0; i < store::XS_LAST; ++i)
+  {
+    theSchemaTypeCodes[theSchemaTypeNames[i].getp()] = 
+    static_cast<store::SchemaTypeCode>(i);
+  }
+}
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::shutdown(bool soft)
+{
+  SYNC_CODE(AutoLock lock(getGlobalLock(), Lock::WRITE);)
+
+  if (theNumUsers == 0)
+    return;
+
+  --theNumUsers;
+
+  if (theNumUsers == 0 || soft == false)
+  {
+    theIndices.clear();
+    theICs.clear();
+    theHashMaps.clear();
+
+    if (theCollections != NULL)
+    {
+      theCollections->clear();
+      destroyCollectionSet(theCollections);
+      theCollections = NULL;
+    }
+
+    theDocuments.clear();
+
+    if (thePULFactory != NULL)
+    {
+      destroyPULFactory(thePULFactory);
+      thePULFactory = NULL;
+    }
+
+    if (theNodeFactory != NULL)
+    {
+      destroyNodeFactory(theNodeFactory);
+      theNodeFactory = NULL;
+    }
+
+    if (theItemFactory != NULL)
+    {
+      destroyItemFactory(theItemFactory);
+      theItemFactory = NULL;
+    }
+
+    if (theIteratorFactory != NULL)
+    {
+      destroyIteratorFactory(theIteratorFactory);
+      theIteratorFactory = NULL;
+    }
+
+    if (theQNamePool != NULL)
+    {
+      csize numTypes = theSchemaTypeNames.size();
+      for (csize i = 0; i < numTypes; ++i)
+        theSchemaTypeNames[i] = NULL;
+
+      XS_UNTYPED_QNAME = NULL;
+      XS_ANY_QNAME = NULL;
+      XS_ANY_SIMPLE_QNAME = NULL;
+
+      delete theQNamePool;
+      theQNamePool = NULL;
+    }
+
+    if (theNamespacePool != NULL)
+    {
+      theEmptyNs.~zstring();
+      theXmlSchemaNs.~zstring();
+
+      delete theNamespacePool;
+      theNamespacePool = NULL;
+    }
+
+    if (theIteratorFactory != NULL)
+    {
+      delete theIteratorFactory;
+      theIteratorFactory = NULL;
+    }
+
+    if (theNodeFactory != NULL)
+    {
+      delete theNodeFactory;
+      theNodeFactory = NULL;
+    }
+
+    // do cleanup of the libxml2 library
+    // however, after that, a user will have to call
+    // LIBXML_TEST_VERSION if he wants to use libxml2
+    // beyond the lifecycle of zorba
+    xmlCleanupParser();
+
+    theNumUsers = 0;
+
+    StoreManagerImpl::theStore = NULL;
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+XmlLoader* Store::getXmlLoader(
+    XQueryDiagnostics* aXQueryDiagnostics,
+    const store::LoadProperties& loadProperties)
+{
+  if (loadProperties.getParseExternalParsedEntity())
+    return new FragmentXmlLoader(theItemFactory,
+                                 aXQueryDiagnostics,
+                                 loadProperties,
+                                 store::Properties::instance()->buildDataguide());
+
+  else if (loadProperties.getDTDValidate())
+    return new DtdXmlLoader(theItemFactory,
+                            aXQueryDiagnostics,
+                            loadProperties,
+                            store::Properties::instance()->buildDataguide());
+  else
+    return new FastXmlLoader(theItemFactory,
+                             aXQueryDiagnostics,
+                             loadProperties,
+                             store::Properties::instance()->buildDataguide());
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::addCollection(store::Collection_t& collection)
+{
+  const store::Item* lName = collection->getName();
+
+  bool inserted = theCollections->insert(lName, collection);
+
+  if (!inserted)
+  {
+    throw ZORBA_EXCEPTION(zerr::ZSTR0008_COLLECTION_ALREADY_EXISTS,
+    ERROR_PARAMS(lName->getStringValue()));
+  }
+}
+
+
+/*******************************************************************************
+  Delete the collection with the given QName. If there is no collection with
+  that QName, this method is a NOOP.
+********************************************************************************/
+void Store::deleteCollection(
+    const store::Item* aName,
+    bool aDynamicCollection)
+{
+  if (aName == NULL)
+    return;
+
+  if (!theCollections->remove(aName, aDynamicCollection))
+  {
+    throw ZORBA_EXCEPTION(zerr::ZSTR0009_COLLECTION_NOT_FOUND,
+    ERROR_PARAMS(aName->getStringValue()));
+  }
+}
+
+
+/*******************************************************************************
+  Return an rchandle to the Collection object corresponding to the given QName,
+  or NULL if there is no collection with that QName.
+********************************************************************************/
+store::Collection_t Store::getCollection(
+    const store::Item* aName,
+    bool aDynamicCollection)
+{
+  if (aName == NULL)
+    return NULL;
+
+  store::Collection_t collection;
+  if (theCollections->get(aName, collection, aDynamicCollection)) 
+  {
+    return collection;
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+
+/*******************************************************************************
+  Returns an iterator that lists the QName's of all the available collections.
+********************************************************************************/
+store::Iterator_t Store::listCollectionNames(bool aDynamicCollections)
+{
+  return theCollections->names(aDynamicCollections);
+}
+
+
+/*******************************************************************************
+  Create an index with a given URI and return an rchandle to the index object.
+  If an index with the given URI exists already and the index we want to create
+  is not a temporary one, raise an error.
+********************************************************************************/
+store::Index_t Store::createIndex(
+    const store::Item_t& qname,
+    const store::IndexSpecification& spec,
+    store::Iterator* sourceIter)
+{
+  store::Item* qname2 = const_cast<store::Item*>(qname.getp());
+  store::Index_t index;
+
+  if (!spec.theIsTemp && theIndices.get(qname.getp(), index))
+  {
+    throw ZORBA_EXCEPTION(zerr::ZSTR0001_INDEX_ALREADY_EXISTS,
+    ERROR_PARAMS(qname->getStringValue()));
+  }
+
+  if (spec.theIsGeneral && spec.theIsSorted)
+  {
+    index = new GeneralTreeIndex(qname, spec);
+    populateGeneralIndex(index, sourceIter, spec.getNumColumns());
+  }
+  else if (spec.theIsSorted)
+  {
+    index = new ValueTreeIndex(qname, spec);
+    populateValueIndex(index, sourceIter, spec.getNumColumns());
+  }
+  else if (spec.theIsGeneral)
+  {
+    index = new GeneralHashIndex(qname, spec);
+    populateGeneralIndex(index, sourceIter, spec.getNumColumns());
+  }
+  else
+  {
+    index = new ValueHashIndex(qname, spec);
+    populateValueIndex(index, sourceIter, spec.getNumColumns());
+  }
+
+  if (!spec.theIsTemp)
+  {
+    theIndices.insert(qname2, index);
+  }
+
+  return index;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::populateValueIndex(
+    const store::Index_t& aIndex,
+    store::Iterator* aSourceIter,
+    ulong aNumColumns)
+{
+  if (!aSourceIter)
+    return;
+
+  store::Item_t domainItem;
+  store::IndexKey* key = NULL;
+
+  ValueIndex* index = static_cast<ValueIndex*>(aIndex.getp());
+
+  aSourceIter->open();
+
+  try
+  {
+    while (aSourceIter->next(domainItem))
+    {
+      if (domainItem->isNode() &&
+          domainItem->getCollection() == NULL &&
+          !index->isTemporary())
+      {
+        RAISE_ERROR_NO_LOC(zerr::ZDDY0020_INDEX_DOMAIN_NODE_NOT_IN_COLLECTION,
+        ERROR_PARAMS(index->getName()->getStringValue()));
+      }
+
+      if (key == NULL)
+        key = new store::IndexKey(aNumColumns);
+
+      for (ulong i = 0; i < aNumColumns; ++i)
+      {
+        if (!aSourceIter->next((*key)[i]))
+        {
+          // The source iter is a ValueIndexEntryBuilderIterator, whose next()
+          // method is guaranteed to return true exactly once. The result from
+          // this single successful next() may be a NULL item.
+          RAISE_ERROR_NO_LOC(zerr::ZXQP0003_INTERNAL_ERROR,
+          ERROR_PARAMS(ZED(IncompleteKeyInIndexBuild)));
+        }
+      }
+
+      index->insert(key, domainItem);
+    }
+  }
+  catch(...)
+  {
+    if (key != NULL)
+      delete key;
+
+    aSourceIter->close();
+    throw;
+  }
+
+  if (key != NULL)
+    delete key;
+
+  aSourceIter->close();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::populateGeneralIndex(
+    const store::Index_t& idx,
+    store::Iterator* sourceIter,
+    ulong numColumns)
+{
+  store::Item_t domainNode;
+  store::Item_t firstKeyItem;
+  store::Item_t keyItem;
+
+  GeneralIndex* index = static_cast<GeneralIndex*>(idx.getp());
+
+  sourceIter->open();
+
+  try
+  {
+    if (sourceIter->next(domainNode))
+    {
+      bool more = true;
+
+      assert(domainNode->isNode());
+      assert(keyItem == NULL);
+
+      // Compute the keys associated with the current domain node. Note: We
+      // must check whether the domain node has more than one key, before we
+      // do any insertions in the index.
+      while (more)
+      {
+        if (domainNode->getCollection() == NULL && !index->isTemporary())
+        {
+          RAISE_ERROR_NO_LOC(zerr::ZDDY0020_INDEX_DOMAIN_NODE_NOT_IN_COLLECTION,
+          ERROR_PARAMS(index->getName()->getStringValue()));
+        }
+
+        // Compute 1st key, or next domain node
+        more = sourceIter->next(firstKeyItem);
+
+        // If current node has no keys, put it in the "null" entry and continue
+        // with the next domain node, if nay.
+        if (!more || firstKeyItem->isNode())
+        {
+          index->insert(keyItem, domainNode);
+
+          domainNode.transfer(firstKeyItem);
+          continue;
+        }
+
+        // Compute 2nd key, or next domain node
+        more = sourceIter->next(keyItem);
+
+        // If current domain node has exactly 1 key, insert it in the index
+        // and continue with next domain node, if any.
+        if (!more || keyItem->isNode())
+        {
+          index->insert(firstKeyItem, domainNode);
+
+          domainNode.transfer(keyItem);
+          continue;
+        }
+
+        // Current domain node has at least 2 keys. So insert them in the index.
+        // Note: we have to copy the domainNode rchandle because index->insert()
+        // will transfer the given node.
+        index->setMultiKey();
+
+        store::Item_t node = domainNode;
+        index->insert(firstKeyItem, node);
+        node = domainNode;
+        index->insert(keyItem, node);
+
+        // Compute next keys or next domain node.
+        while ((more = sourceIter->next(keyItem)))
+        {
+          if (keyItem->isNode())
+          {
+            domainNode.transfer(keyItem);
+            break;
+          }
+
+          node = domainNode;
+          index->insert(keyItem, node);
+        }
+      }
+    }
+  }
+  catch(...)
+  {
+    sourceIter->close();
+
+    throw;
+  }
+
+  sourceIter->close();
+}
+
+
+/*******************************************************************************
+  Refreshes an index with a given URI and return an rchandle to the index object.
+  If an index with the given URI exists already and the index we want to create
+  is not a temporary one, raise an error.
+********************************************************************************/
+store::Index_t Store::refreshIndex(
+    const store::Item_t& qname,
+    const store::IndexSpecification& spec,
+    store::Iterator* sourceIter)
+{
+  store::Index_t index;
+  store::Item* non_const_items = const_cast<store::Item*>(qname.getp());
+
+  if (!theIndices.get(non_const_items, index))
+  {
+    throw ZORBA_EXCEPTION(
+      zerr::ZSTR0002_INDEX_DOES_NOT_EXIST,
+      ERROR_PARAMS( qname->getStringValue() )
+    );
+  }
+
+  deleteIndex(qname);
+
+  try
+  {
+    createIndex(qname, index->getSpecification(), sourceIter);
+  }
+  catch (...)
+  {
+    addIndex(index);
+    throw;
+  }
+
+  return index;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::addIndex(store::Index_t& index)
+{
+  if (index == NULL)
+    return;
+
+  store::Item* qname = const_cast<store::Item*>(index->getName());
+
+  theIndices.insert(qname, index);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Store::deleteIndex(const store::Item* qname)
+{
+  if (qname == NULL)
+    return;
+
+  store::Item* qname2 = const_cast<store::Item*>(qname);
+
+  theIndices.erase(qname2);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Index* Store::getIndex(const store::Item* qname)
+{
+  if (qname == NULL)
+    return NULL;
+
+  store::Item* qname2 = const_cast<store::Item*>(qname);
+  store::Index_t index;
+
+  if (theIndices.get(qname2, index))
+    return index.getp();
+
+  return NULL;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Iterator_t Store::listIndexNames()
+{
+  return new NameIterator<IndexSet>(theIndices);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::IC_t Store::activateIC(
+    const store::Item_t& icQName,
+    const store::Item_t& collectionQName,
+    bool& isApplied)
+{
+  ZORBA_ASSERT(icQName != NULL);
+
+  store::Item* qname = icQName.getp();
+
+  store::IC_t ic;
+
+  if (theICs.get(qname, ic))
+  {
+    return ic; // already activated => noop
+  }
+
+  ic = new ICCollectionImpl(icQName, collectionQName);
+
+  theICs.insert(qname, ic);
+
+  isApplied=true;
+  return ic;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::IC_t Store::activateForeignKeyIC(
+    const store::Item_t& icQName,
+    const store::Item_t& fromCollectionQName,
+    const store::Item_t& toCollectionQName,
+    bool& isApplied)
+{
+  ZORBA_ASSERT(icQName != NULL);
+
+  store::Item* qname = const_cast<store::Item*>(icQName.getp());
+
+  store::IC_t ic;
+
+  if (theICs.get(qname, ic))
+  {
+    return ic; // already activated => noop
+  }
+
+  ic = new ICForeignKeyImpl(qname, fromCollectionQName, toCollectionQName);
+
+  theICs.insert(qname, ic);
+
+  isApplied=true;
+  return ic;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::IC_t
+Store::deactivateIC(const store::Item_t& icQName,
+    bool& isApplied)
+{
+  ZORBA_ASSERT(icQName != NULL);
+
+  store::IC_t ic;
+
+  if (!theICs.get(icQName.getp(), ic))
+  {
+    return ic; // already deactivated in the same PUL => noop
+  }
+
+  theICs.erase(icQName.getp());
+  isApplied=true;
+  return ic;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Iterator_t Store::listActiveICNames()
+{
+  return new NameIterator<ICSet>(theICs);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::IC* Store::getIC(const store::Item* icQName)
+{
+  store::Item* qname = const_cast<store::Item*>(icQName);
+  store::IC_t ic;
+  theICs.get(qname, ic);
+
+  return ic.getp();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Index_t
+Store::createHashMap(
+    const store::Item_t& aQName,
+    const store::IndexSpecification& aSpec)
+{
+  store::Index_t lIndex;
+
+  if (theHashMaps.get(aQName.getp(), lIndex))
+  {
+    throw ZORBA_EXCEPTION(
+      zerr::ZSTR0001_INDEX_ALREADY_EXISTS,
+      ERROR_PARAMS( aQName->getStringValue() )
+    );
+  }
+
+  lIndex = new ValueHashIndex(aQName, aSpec);
+
+  addHashMap(lIndex);
+
+  return lIndex;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Index_t
+Store::destroyHashMap(const store::Item_t& aQName)
+{
+  store::Index_t lIndex;
+  if (!theHashMaps.get(aQName.getp(), lIndex))
+  {
+    throw ZORBA_EXCEPTION(
+      zerr::ZDDY0023_INDEX_DOES_NOT_EXIST,
+      ERROR_PARAMS( aQName->getStringValue() )
+    );
+  }
+
+  theHashMaps.erase(aQName.getp());
+  return lIndex;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Index*
+Store::getMap(const store::Item* aQName) const
+{
+  store::Item* lQName = const_cast<store::Item*>(aQName);
+
+  store::Index_t lIndex;
+  const_cast<IndexSet*>(&theHashMaps)->get(lQName, lIndex);
+
+  return lIndex.getp();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Index_t
+Store::getHashMap(const store::Item_t& aQName) const
+{
+  store::Index_t lIndex;
+  if (const_cast<IndexSet*>(&theHashMaps)->get(aQName.getp(), lIndex))
+  {
+    return lIndex;
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void
+Store::addHashMap(const store::Index_t& aIndex)
+{
+  store::Item* lName = aIndex->getName();
+  store::Index_t lIndex = aIndex;
+  theHashMaps.insert(lName, lIndex);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Iterator_t Store::listMapNames()
+{
+  return new NameIterator<IndexSet>(theHashMaps);
+}
+
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Item_t Store::loadDocument(
+    const zstring& baseUri,
+    const zstring& docUri,
+    std::istream& stream,
+    const store::LoadProperties& loadProperties)
+{
+  zstring_b urib;
+
+  if (!docUri.empty())
+    urib.wrap_memory(docUri.data(), docUri.size());
+
+  XmlNode_t root;
+  bool found = theDocuments.get(urib, root);
+
+  if (found)
+  {
+    return root.getp();
+  }
+
+  XQueryDiagnostics lXQueryDiagnostics;
+  std::auto_ptr<XmlLoader> loader(getXmlLoader(&lXQueryDiagnostics, loadProperties));
+
+  root = loader->loadXml(baseUri, docUri, stream);
+
+  if (!lXQueryDiagnostics.errors().empty())
+  {
+    lXQueryDiagnostics.errors().front()->polymorphic_throw();
+  }
+
+  if (root != NULL && loadProperties.getStoreDocument())
+    theDocuments.insert(urib, root);
+
+  return root.getp();
+}
+
+
+/*******************************************************************************
+  For lazy loading...
+  Param stream is a heap pointer to an input stream. This is to be deallocated
+  by Zorba.
+********************************************************************************/
+store::Item_t Store::loadDocument(
+    const zstring& baseUri,
+    const zstring& docUri,
+    std::istream* stream,
+    const store::LoadProperties& loadProperties)
+{
+  store::Item_t docitem;
+  try
+  {
+    //do full loading for now
+    docitem = loadDocument(baseUri, docUri, *stream, loadProperties);
+    delete stream;
+  }
+  catch(...)
+  {
+    delete stream;
+  }
+  return docitem;
+}
+
+
+/*******************************************************************************
+  Add the given node with the given uri to the store. Essentially, this method
+  establishes an association between a uri and a node. If the given uri is
+  already associated to another node, the method raises an error. If the given
+  uri is already associated to the given node, this method is a noop.
+********************************************************************************/
+void Store::addNode(const zstring& uri, const store::Item_t& node)
+{
+  ZORBA_ASSERT(!uri.empty());
+
+  if (node == NULL || !node->isNode())
+  {
+    RAISE_ERROR_NO_LOC(zerr::ZAPI0021_ITEM_TO_LOAD_IS_NOT_NODE, ERROR_PARAMS(uri));
+  }
+
+  XmlNode_t root = reinterpret_cast<XmlNode*>(node.getp());
+
+  bool inserted = theDocuments.insert(uri, root);
+
+  if (!inserted && node.getp() != root.getp())
+  {
+    RAISE_ERROR_NO_LOC(zerr::ZAPI0020_DOCUMENT_ALREADY_EXISTS, ERROR_PARAMS(uri));
+  }
+
+  ZORBA_FATAL(node.getp() == root.getp(), "");
+}
+
+
+/*******************************************************************************
+  Return an rchandle to an iterator over the set of documents in the store
+********************************************************************************/
+store::Iterator_t Store::getDocumentNames() const
+{
+  return new DocumentNameIterator<DocumentSet>(theDocuments);
+}
+
+
+/*******************************************************************************
+  Return an rchandle to the root node of the document corresponding to the given
+  URI, or NULL if there is no document with that URI.
+********************************************************************************/
+store::Item_t Store::getDocument(const zstring& uri)
+{
+  if (uri.empty())
+    return NULL;
+
+  XmlNode_t root;
+
+  bool found = theDocuments.get(uri, root);
+
+  if (found)
+    return root.getp();
+
+  return NULL;
+}
+
+
+/*******************************************************************************
+  Delete the document with the given URI. If there is no document with that
+  URI, this method is a NOOP.
+********************************************************************************/
+void Store::deleteDocument(const zstring& uri)
+{
+  if (uri.empty())
+    return;
+
+  theDocuments.erase(uri);
+}
+
+
+/*******************************************************************************
+  Delete all the documents.
+********************************************************************************/
+void Store::deleteAllDocuments()
+{
+  theDocuments.clear();
+}
+
+
+/*******************************************************************************
+  Compare two nodes, based on their node id. Return -1 if node1 < node2, 0, if
+  node1 == node2, or 1 if node1 > node2.
+********************************************************************************/
+short Store::compareNodes(store::Item* node1, store::Item* node2) const
+{
+  ZORBA_FATAL(node1->isNode(), "");
+  ZORBA_FATAL(node2->isNode(), "");
+
+  if (node1 == node2)
+    return 0;
+
+  XmlNode* n1 = static_cast<XmlNode*>(node1);
+  XmlNode* n2 = static_cast<XmlNode*>(node2);
+
+  return (short)n1->compare2(n2);
+}
+
+
+/*******************************************************************************
+  Sorts the items of the passed iterator
+
+  @param iterator to sort
+  @param ascendent true for ascendent and false for descendant
+  @param duplicate duplicate elemination should be applied
+  @return iterator which produces the sorted items
+********************************************************************************/
+store::Iterator_t Store::sortNodes(
+    store::Iterator* input,
+    bool ascendent,
+    bool duplicateElemination,
+    bool aAllowAtomics)
+{
+  if (aAllowAtomics)
+    return new StoreNodeSortOrAtomicIterator(input, ascendent, duplicateElemination);
+  else
+    return new StoreNodeSortIterator(input, ascendent, duplicateElemination);
+}
+
+
+/*******************************************************************************
+  Create an iterator that eliminates the duplicate nodes in the set of items
+  which is produced by the passed iterator
+********************************************************************************/
+store::Iterator_t Store::distinctNodes(
+    store::Iterator* input,
+    bool aAllowAtomics)
+{
+  if (aAllowAtomics)
+    return new StoreNodeDistinctOrAtomicIterator(input);
+  else
+    return new StoreNodeDistinctIterator(input, false);
+}
+
+
+/*******************************************************************************
+  Create an iterator that checks for duplicate nodes in the set of nodes which
+  is produced by the passed iterator, and raises an error if any duplicates
+  are found. If no duplicates are found, the iterator simply passes on the
+  input nodes to its consumer.
+********************************************************************************/
+store::Iterator_t Store::checkDistinctNodes(store::Iterator* input)
+{
+  return new StoreNodeDistinctIterator(input, true);
+}
+
+
+/*******************************************************************************
+  Computes the Structural Reference for the given node.
+********************************************************************************/
+bool Store::getStructuralInformation(
+    store::Item_t& result, 
+    const store::Item* node)
+{
+#ifdef TEXT_ORDPATH
+  const OrdPathNode* n = static_cast<const OrdPathNode*>(node);
+
+  return theItemFactory->createStructuralAnyURI(result,
+                                                n->getCollectionId(),
+                                                n->getTreeId(),
+                                                n->getNodeKind(),
+                                                n->getOrdPath());
+#else
+  if (node->getNodeKind() == store::StoreConsts::textNode)
+  {
+    OrdPath ordPath;
+    const TextNode* n = static_cast<const TextNode*>(node);
+    n->getOrdPath(ordPath);
+
+    return GET_FACTORY().createStructuralAnyURI(result,
+                                                n->getCollectionId(),
+                                                n->getTreeId(),
+                                                store::StoreConsts::textNode,
+                                                ordPath);
+  }
+  else
+  {
+    const OrdPathNode* n = static_cast<const OrdPathNode*>(node);
+
+    return GET_FACTORY().createStructuralAnyURI(result,
+                                                n->getCollectionId(),
+                                                n->getTreeId(),
+                                                n->getNodeKind(),
+                                                n->getOrdPath());
+  }
+#endif
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+bool Store::getPathInfo(
+    const store::Item*               docUriItem,
+    std::vector<const store::Item*>& contextPath,
+    std::vector<const store::Item*>& relativePath,
+    bool                             isAttrPath,
+    bool&                            found,
+    bool&                            unique)
+{
+  zstring docUri;
+  docUriItem->getStringValue2(docUri);
+
+  XmlNode_t docRoot = BASE_NODE(getDocument(docUri));
+
+  if (docRoot == NULL)
+    return false;
+
+#ifdef DATAGUIDE
+  GuideNode* guideRoot = docRoot->getDataGuide();
+
+  if (!guideRoot)
+    return false;
+
+  guideRoot->getPathInfo(contextPath, relativePath, isAttrPath, found, unique);
+#endif
+  return true;
+}
+
+
+/*******************************************************************************
+  Creates a new TempSeq. The instance can be used, e.g. for variable bindings
+
+  @param iterator   The source for the XMDInstance
+  @param lazy       Hint for the store. If possible a XMDInstance should be
+                    evaluated lazily. For XQueryP it might be necassary to set
+                    this to false.
+********************************************************************************/
+TempSeq_t Store::createTempSeq(const store::Iterator_t& iterator, bool lazy)
+{
+  if(lazy)
+  {
+    //tempSeq = new SimpleTempSeq(iterator, copyNodes);
+    return new SimpleLazyTempSeq(iterator);
+  }
+  else
+  {
+    return new SimpleTempSeq(iterator);
+  }
+}
+
+
+/*******************************************************************************
+  Creates an empty TempSeq.
+********************************************************************************/
+TempSeq_t Store::createTempSeq(bool lazy)
+{
+  if (lazy)
+  {
+    return new SimpleLazyTempSeq();
+  }
+  else
+  {
+    return new SimpleTempSeq();
+  }
+}
+
+
+/*******************************************************************************
+  Creates a temp seq initialized by the given vector.
+  @param item_v - The vector to use to initialize the seq.
+********************************************************************************/
+TempSeq_t Store::createTempSeq(std::vector<store::Item_t>& items)
+{
+  return new SimpleTempSeq(items);
+}
+
+
+/*******************************************************************************
+  Creates a temp seq initialized by the given item.
+********************************************************************************/
+TempSeq_t Store::createTempSeq(store::Item_t& item)
+{
+  return new SimpleTempSeq(item);
+}
+
+
+#ifndef ZORBA_NO_FULL_TEXT
+void Store::setStemmerProvider( internal::StemmerProvider const *p ) 
+{
+  theStemmerProvider = p;
+}
+
+
+void Store::setTokenizerProvider( TokenizerProvider const *p ) 
+{
+  theTokenizerProvider = p;
+}
+
+
+internal::StemmerProvider const* Store::getStemmerProvider() const 
+{
+  return theStemmerProvider ?
+    theStemmerProvider : &internal::StemmerProvider::get_default();
+}
+
+
+TokenizerProvider const* Store::getTokenizerProvider() const 
+{
+  return theTokenizerProvider ?
+    theTokenizerProvider : &default_tokenizer_provider();
+}
+#endif /* ZORBA_NO_FULL_TEXT */
+
+} // namespace store
+} // namespace zorba
+/* vim:set et sw=2 ts=2: */

=== added file 'src/store/naive/store.h'
--- src/store/naive/store.h	1970-01-01 00:00:00 +0000
+++ src/store/naive/store.h	2012-03-27 01:25:22 +0000
@@ -0,0 +1,419 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ZORBA_SIMPLESTORE_STORE_H
+#define ZORBA_SIMPLESTORE_STORE_H
+
+#include "shared_types.h"
+#include "store_defs.h"
+#include "hashmap_nodep.h"
+
+#if (defined (WIN32) || defined (WINCE))
+#include "node_items.h"
+#include "store/api/collection.h"
+#include "store/api/index.h"
+#include "store/api/ic.h"
+#endif
+
+#include "store/api/store.h"
+
+#include "store/util/hashmap_stringbuf.h"
+
+#include "zorbautils/mutex.h"
+#include "zorbautils/lock.h"
+#include "zorbautils/hashmap_itemp.h"
+#include "zorbautils/hashmap_zstring_nonserializable.h"
+
+namespace zorba
+{
+  class StoreManager;
+
+class XQueryDiagnostics;
+
+namespace store
+{
+  class IteratorFactory;
+  class ValueIndexSpecification;
+}
+
+namespace simplestore
+{
+
+class StringPool;
+class QNamePool;
+class XmlLoader;
+class FastXmlLoader;
+class Index;
+class BasicItemFactory;
+class NodeFactory;
+class PULPrimitiveFactory;
+
+typedef zorba::HashMapZString<XmlNode_t> DocumentSet;
+typedef ItemPointerHashMap<store::Index_t> IndexSet;
+typedef ItemPointerHashMap<store::IC_t> ICSet;
+
+
+
+/*******************************************************************************
+  theSchemaTypeNames:
+  -------------------
+  Maps each enum value from SchemaTypeNames (see store/api/xs_types_enum.h) to 
+  its associated QName item.
+
+  theSchemaTypeCodes:
+  -------------------
+
+  theNamespacePool:
+  -----------------
+
+  theQNamePool:
+  -------------
+
+  theItemFactory:
+  ---------------
+  Factory to create items.
+
+  theIteratorFactory:
+  -------------------
+  Factory to create iterators.
+
+  theNodeFactory:
+  ---------------
+  Factory to create node items.
+
+  theDocuments:
+  -------------
+  A hashmap that for each xml tree that does not belong to any collection, maps
+  the URI of the tree to the root node of the tree.
+
+  theCollections:
+  ---------------
+  Container which contains the collections of the store. It includes a map that
+  maps the qname of each collection to the collection's container object.
+
+  theIndices:  
+  -----------
+  A hashmap that for each index, maps the qname of the index to the index 
+  container object.
+  
+  theICs:
+  -------
+  A hashmap the for each integrity constraint, maps the qname of the ic to the
+  ic's container object.
+
+********************************************************************************/
+class Store : public zorba::store::Store
+{
+public:
+  static const char* XS_URI;
+  static const char* XML_URI;
+  static const char* ZXSE_URI;
+
+  static const ulong XML_URI_LEN;
+
+protected:
+  static const ulong NAMESPACE_POOL_SIZE;
+  static const ulong DEFAULT_DOCUMENT_SET_SIZE;
+  static const ulong DEFAULT_URI_COLLECTION_SET_SIZE;
+  static const ulong DEFAULT_INDICES_SET_SIZE;
+  static const ulong DEFAULT_INTEGRITY_CONSTRAINT_SET_SIZE;
+
+public:
+  zstring                       theEmptyNs;
+  zstring                       theXmlSchemaNs;
+
+  std::vector<store::Item_t>    theSchemaTypeNames;
+  std::map<store::Item*, store::SchemaTypeCode> theSchemaTypeCodes;
+  store::Item_t                 XS_UNTYPED_QNAME;
+  store::Item_t                 XS_ANY_QNAME;
+  store::Item_t                 XS_ANY_SIMPLE_QNAME;
+
+protected:
+  ulong                         theNumUsers;
+
+  StringPool                  * theNamespacePool;
+  QNamePool                   * theQNamePool;
+
+  store::ItemFactory          * theItemFactory;
+  store::IteratorFactory      * theIteratorFactory;
+  NodeFactory                 * theNodeFactory;
+  PULPrimitiveFactory         * thePULFactory;
+
+  DocumentSet                   theDocuments;
+  CollectionSet*                theCollections;
+  IndexSet                      theIndices;
+  ICSet                         theICs;
+  IndexSet                      theHashMaps;
+
+  SYNC_CODE(Lock                theGlobalLock;)
+
+  long                          theTraceLevel;
+
+#ifndef ZORBA_NO_FULL_TEXT
+  internal::StemmerProvider const * theStemmerProvider;
+  TokenizerProvider const     * theTokenizerProvider;
+#endif /* ZORBA_NO_FULL_TEXT */
+
+/*----------------------- Initialization, shutdown ---------------------------*/
+protected:
+  Store();
+
+  virtual ~Store();
+
+  virtual void init();
+
+  void initTypeNames();
+
+public:
+  virtual void shutdown(bool soft = true);
+
+  SYNC_CODE(Lock& getGlobalLock() { return theGlobalLock; })
+
+  long getTraceLevel() const { return theTraceLevel; }
+
+  XmlLoader* getXmlLoader(
+      XQueryDiagnostics*,
+      const store::LoadProperties& loadProperties);
+      
+/*------------------------------ Factories -----------------------------------*/
+public:
+  store::ItemFactory* getItemFactory() const { return theItemFactory; }
+
+  store::IteratorFactory* getIteratorFactory() const
+  {
+    return theIteratorFactory; 
+  }
+
+  NodeFactory& getNodeFactory() const { return *theNodeFactory; }
+
+  PULPrimitiveFactory& getPULFactory() const { return *thePULFactory; }
+
+  StringPool& getNamespacePool() const { return *theNamespacePool; }
+
+  QNamePool& getQNamePool() const { return *theQNamePool; }
+  
+protected:
+  // Functions to create/destory the node and item factories. These functions
+  // are called from init and shutdown, respectively. Having this functionality
+  // factorized allows others to derive from the SimpleStore and provide their
+  // own factories.
+
+  virtual NodeFactory* createNodeFactory() const = 0;
+
+  virtual void destroyNodeFactory(NodeFactory*) const = 0;
+
+  virtual store::ItemFactory* createItemFactory() const = 0;
+
+  virtual void destroyItemFactory(store::ItemFactory*) const = 0;
+
+  virtual store::IteratorFactory* createIteratorFactory() const = 0;
+
+  virtual void destroyIteratorFactory(store::IteratorFactory*) const = 0;
+
+  virtual PULPrimitiveFactory* createPULFactory() const = 0;
+
+  virtual void destroyPULFactory(PULPrimitiveFactory*) const = 0;
+
+  virtual CollectionSet* createCollectionSet() const = 0;
+
+  virtual void destroyCollectionSet(CollectionSet*) const = 0;
+
+/*---------------------------- Collections -----------------------------------*/
+public:
+  virtual ulong createCollectionId() = 0;
+
+  virtual ulong createTreeId() = 0;
+
+  virtual store::Collection_t createCollection(
+      const store::Item_t& aName,
+      const std::vector<store::Annotation_t>& annotations,
+      const store::Item_t& aNodeType,
+      bool aDynamicCollection = false) = 0;
+
+  virtual void addCollection(store::Collection_t& collection);
+
+  virtual void deleteCollection(
+      const store::Item* aName,
+      bool aDynamicCollection = false);
+
+  virtual store::Collection_t getCollection(
+      const store::Item* aName,
+      bool aDynamicCollection = false);
+
+  virtual store::Iterator_t listCollectionNames(bool aDynamicCollections = false);
+
+/*-------------------------------- Indices -----------------------------------*/
+public:
+  virtual store::Index_t createIndex(
+      const store::Item_t& qname,
+      const store::IndexSpecification& spec,
+      store::Iterator* sourceIter);
+
+  virtual store::Index_t refreshIndex(
+      const store::Item_t& qname,
+      const store::IndexSpecification& spec,
+      store::Iterator* sourceIter);
+
+  virtual void addIndex(store::Index_t& index);
+
+  virtual void deleteIndex(const store::Item* qname);
+
+  virtual store::Index* getIndex(const store::Item* qname);
+
+  virtual store::Iterator_t listIndexNames();
+
+  const IndexSet& getIndices() const { return theIndices; }
+
+protected:
+  virtual void populateValueIndex(
+      const store::Index_t& index,
+      store::Iterator* sourceIter,
+      ulong numColumns);
+
+  virtual void populateGeneralIndex(
+      const store::Index_t& index,
+      store::Iterator* sourceIter,
+      ulong numColumns);
+
+/*------------------------- Integrity constraints ----------------------------*/
+public:
+  virtual store::IC_t activateIC(
+      const store::Item_t& icQName,
+      const store::Item_t& collectionQName,
+      bool& isApplied);
+  
+  virtual store::IC_t activateForeignKeyIC(
+      const store::Item_t& icQName,
+      const store::Item_t& fromCollectionQName,
+      const store::Item_t& toCollectionQName,
+      bool& isApplied);
+
+  virtual store::IC_t deactivateIC(
+      const store::Item_t& icQName,
+      bool& isApplied);
+
+  virtual store::Iterator_t listActiveICNames();
+
+  virtual store::IC* getIC(const store::Item* icQName);
+
+/*------------------------------------- Maps ---------------------------------*/
+public:
+  virtual store::Index_t createHashMap(
+      const store::Item_t& aQName,
+      const store::IndexSpecification& aSpec);
+
+  virtual store::Index_t destroyHashMap(const store::Item_t& aQName);
+
+  virtual store::Index* getMap(const store::Item* aQName) const;
+
+  virtual store::Index_t getHashMap(const store::Item_t& aQName) const;
+
+  virtual void addHashMap(const store::Index_t& aMap);
+
+  virtual store::Iterator_t listMapNames();
+
+/*-------------------------------- Documents ---------------------------------*/
+public:
+  virtual store::Item_t loadDocument(
+      const zstring& baseUri,
+      const zstring& docUri,
+      std::istream& stream,
+      const store::LoadProperties& loadProperties);
+
+  virtual store::Item_t loadDocument(
+      const zstring& baseUri,
+      const zstring& docUri,
+      std::istream* stream,
+      const store::LoadProperties& loadProperties);
+
+  virtual void addNode(const zstring& uri, const store::Item_t& node);
+
+  virtual store::Iterator_t getDocumentNames() const;
+
+  virtual store::Item_t getDocument(const zstring& uri);
+
+  virtual void deleteDocument(const zstring& uri);
+
+  virtual void deleteAllDocuments();
+
+/*----------------------------- Node operations ------------------------------*/
+public:
+  virtual short compareNodes(
+      store::Item* node1,
+      store::Item* node2) const;
+
+  virtual store::Iterator_t sortNodes(
+      store::Iterator* iterator,
+      bool ascendent,
+      bool duplicateElemination,
+      bool aAllowAtomics = false);
+  
+  virtual store::Iterator_t distinctNodes(
+      store::Iterator* input,
+      bool aAllowAtomics);
+
+  virtual store::Iterator_t checkDistinctNodes(store::Iterator* input);
+
+  virtual bool getStructuralInformation(
+      store::Item_t& result,
+      const store::Item* node);
+
+  virtual bool getPathInfo(
+      const store::Item* docUri,
+      std::vector<const store::Item*>& contextPath,
+      std::vector<const store::Item*>& relativePath,
+      bool isAttrPath,
+      bool& found,
+      bool& unique);
+
+/*---------------------- Node Reference Management ---------------------------*/
+public:
+  virtual bool getNodeReference(store::Item_t& result, const store::Item* node) = 0;
+
+  virtual bool hasReference(const store::Item* node) = 0;
+
+  virtual bool getNodeByReference(store::Item_t& result, const zstring& ref) = 0;
+
+  virtual bool unregisterNode(XmlNode* node) = 0;
+
+/*----------------------- Temp Sequence Management ---------------------------*/
+public:
+  virtual store::TempSeq_t createTempSeq(bool lazy);
+
+  virtual store::TempSeq_t createTempSeq(const store::Iterator_t& iterator, bool lazy);
+
+  virtual store::TempSeq_t createTempSeq(std::vector<store::Item_t>& item_v);
+
+  virtual store::TempSeq_t createTempSeq(store::Item_t& item);
+
+/*--------------------------- Full Text Management ---------------------------*/
+public:
+#ifndef ZORBA_NO_FULL_TEXT
+  virtual internal::StemmerProvider const* getStemmerProvider() const;
+
+  virtual void setStemmerProvider(internal::StemmerProvider const*);
+
+protected:
+  virtual TokenizerProvider const* getTokenizerProvider() const;
+
+  virtual void setTokenizerProvider(TokenizerProvider const*);
+#endif /* ZORBA_NO_FULL_TEXT */
+};
+
+} // namespace simplestore
+} // namespace zorba
+
+#endif /* ZORBA_SIMPLESTORE_STORE_H */
+

=== modified file 'src/store/naive/store_manager_impl.h'
--- src/store/naive/store_manager_impl.h	2012-03-26 01:31:32 +0000
+++ src/store/naive/store_manager_impl.h	2012-03-27 01:25:22 +0000
@@ -25,7 +25,7 @@
 namespace simplestore
 {
 
-class SimpleStore;
+class Store;
 
 
 /*******************************************************************************
@@ -33,13 +33,13 @@
 ********************************************************************************/
 class StoreManagerImpl : public StoreManager
 {
-  friend class SimpleStore;
+  friend class Store;
 
  private:
-  static SimpleStore  * theStore;
+  static Store* theStore;
 
  public:
-  static SimpleStore* getStoreInternal() { return theStore; }
+  static Store* getStoreInternal() { return theStore; }
 };