Merge lp:~zorba-coders/zorba/bug931580 into lp:zorba

[Rodolfo Ochoa]

This upgrade supply the required objects and methods for basic XQJ support.

This upgrade supply the required objects and methods for basic XQJ support.

[Cezar Andrei (cezar-andrei)]

Looks good.

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-02-16T19-01-07.77Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/bug931580 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:274 (message):
  Validation queue job bug931580-2012-02-16T19-01-07.77Z is finished. The
  final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-02-17T00-45-00.129Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/bug931580 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:274 (message):
  Validation queue job bug931580-2012-02-17T00-45-00.129Z is finished. The
  final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Cezar Andrei (cezar-andrei)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-02-17T23-30-02.51Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug931580-2012-02-17T23-30-02.51Z 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. Got: 1 Approve, 2 Pending.

[Matthias Brantner (matthias-brantner)]

The change provides a great extension to all of Zorba's language bindings.

Two things:
- it currently doesn't build on my machine (Ubuntu 11.04 with gcc 4.5.2)

[ 97%] Building CXX object swig/python/CMakeFiles/_zorba_api_python.dir/zorba_apiPYTHON_wrap.cxx.o
In file included from /usr/include/python2.7/Python.h:8:0,
                 from /home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:158:
/usr/include/python2.7/pyconfig.h:1155:0: warning: "_POSIX_C_SOURCE" redefined
/usr/include/features.h:163:0: note: this is the location of the previous definition
/usr/include/python2.7/pyconfig.h:1177:0: warning: "_XOPEN_SOURCE" redefined
/usr/include/features.h:165:0: note: this is the location of the previous definition
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx: In function ‘PyTypeObject* _PySwigObject_type()’:
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:1855:7: warning: missing initializer for member ‘_typeobject::tp_version_tag’
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx: In function ‘PyTypeObject* _PySwigPacked_type()’:
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:2030:7: warning: missing initializer for member ‘_typeobject::tp_version_tag’
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx: In member function ‘int SAX2Attributes::getIndex(const char*, const char*) const’:
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:2894:14: warning: converting to non-pointer type ‘int’ from NULL
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx: In member function ‘int SAX2Attributes::getIndex(const char*) const’:
/home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:2902:14: warning: converting to non-pointer type ‘int’ from NULL
In file included from /home/mbrantner/zorba/build/swig/python/zorba_apiPYTHON_wrap.cxx:3471:0:
/home/mbrantner/zorba/build/swig/python/StaticContext.h: At global scope:
/home/mbrantner/zorba/build/swig/python/StaticContext.h:116:3: error: ‘TypeIdentifier’ does not name a type
/home/mbrantner/zorba/build/swig/python/StaticContext.h:117:3: error: ‘TypeIdentifier’ does not name a type
/home/mbrantner/zorba/build/swig/python/StaticContext.h:118:3: error: ‘TypeIdentifier’ does not name a type
/home/mbrantner/zorba/build/swig/python/StaticContext.h:120:39: error: ‘TypeIdentifier’ does not name a type
/home/mbrantner/zorba/build/swig/python/StaticContext.h:120:55: error: ISO C++ forbids declaration of ‘aType’ with no type

- Also, I'm a little bit worried about the absence of tests for the language bindings other than Java. We should at least have some testing for them (e.g. PHP, Python, and Ruby).

review: Needs Fixing

[Rodolfo Ochoa (rodolfo-ochoa)]

- Ruby, PHP and Python tests are working
- Python error is fixed

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-03-21T14-20-18.368Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/bug931580 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:274 (message):
  Validation queue job bug931580-2012-03-21T14-20-18.368Z is finished. The
  final status was:

  8 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-03-21T22-11-04.21Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug931580-2012-03-21T22-11-04.21Z 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: 2 Approve, 1 Needs Fixing.

[Matthias Brantner (matthias-brantner)]

- Why does the CollectionManager exist? It doesn't seem to be accessible from anywhere?
- The ChangeLog needs to be updated to reflect the new features.

review: Needs Fixing

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

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

text conflict in ChangeLog

[lp:~zorba-coders/zorba/bug931580]

10674. By Rodolfo Ochoa on 2012-03-26

-Solved conflict with Changelog

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug931580-2012-03-26T20-17-59.753Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug931580-2012-03-26T20-17-59.753Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2012-03-26 19:41:44 +0000
+++ ChangeLog	2012-03-26 20:16:18 +0000
@@ -1,10 +1,15 @@
 Zorba - The XQuery Processor
 
 version 2.5
+
+New Features:
+  * Extended API for Python, Java, PHP and Ruby.
+
+Bug Fixes/Other Changes:
   * Fixed bug in window iterator
   * Fixed bug #872234 (prevent a rewritting to take place in case of sequential expr)
 
-	
+
 version 2.2
 
 New Features:

=== modified file 'doc/php/examples/CMakeLists.txt'
--- doc/php/examples/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ doc/php/examples/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -18,7 +18,11 @@
 
   SET(phpPath ${CMAKE_BINARY_DIR}/swig/php)
   MESSAGE(STATUS "PHP Path:" ${phpPath})
-  SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php)
+  IF (MSVC_IDE)
+    SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php/@CMAKE_BUILD_TYPE@)
+  ELSE (MSVC_IDE)
+    SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php)
+  ENDIF (MSVC_IDE)
   MESSAGE(STATUS "PHP Extension Path: " ${phpExtensionPath})
   SET(phpIncludePath ${CMAKE_BINARY_DIR}/swig/php)
   MESSAGE(STATUS "PHP Include Path: " ${phpExtensionPath})

=== modified file 'doc/php/examples/zorba_api.php'
--- doc/php/examples/zorba_api.php	2012-03-23 17:32:07 +0000
+++ doc/php/examples/zorba_api.php	2012-03-26 20:16:18 +0000
@@ -18,7 +18,7 @@
 // Try to load our extension if it's not already loaded.
 if (!extension_loaded("zorba_api")) {
   if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {
-    if (!dl('php_zorba_api.dll')) return;
+    if (!dl('zorba_api.dll')) return;
   } else {
     // PHP_SHLIB_SUFFIX is available as of PHP 4.3.0, for older PHP assume 'so'.
     // It gives 'dylib' on MacOS X which is for libraries, modules are 'so'.

=== modified file 'doc/ruby/examples/CMakeLists.txt'
--- doc/ruby/examples/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ doc/ruby/examples/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -18,7 +18,12 @@
   IF (NOT RUBY_EXECUTABLE)
     MESSAGE(STATUS "Ruby test not added because Ruby Interpreter not found.")
   ELSE (NOT RUBY_EXECUTABLE)
-    SET(rubyPath ${CMAKE_BINARY_DIR}/swig/ruby)
+    MESSAGE(STATUS "RUBY_EXECUTABLE: " ${RUBY_EXECUTABLE})
+    IF (MSVC_IDE)
+      SET(rubyPath ${CMAKE_BINARY_DIR}/swig/ruby/@CMAKE_BUILD_TYPE@)
+    ELSE (MSVC_IDE)
+      SET(rubyPath ${CMAKE_BINARY_DIR}/swig/ruby)
+    ENDIF (MSVC_IDE)
     CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/ruby_test.rb.in ${CMAKE_CURRENT_BINARY_DIR}/ruby_test.rb)
     ADD_TEST("ruby" ${RUBY_EXECUTABLE} ruby_test.rb)
   ENDIF(NOT RUBY_EXECUTABLE)

=== added file 'swig/Collection.h'
--- swig/Collection.h	1970-01-01 00:00:00 +0000
+++ swig/Collection.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2006-2012 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 API_COLLECTION_H
+#define API_COLLECTION_H
+
+class Collection
+{
+private:
+  zorba::Collection* theCollection;
+
+public:
+  Collection() : theCollection(0) {}
+  Collection(const Collection& aMgr) : theCollection(aMgr.theCollection) {}
+  Collection(zorba::Collection* aMgr) : theCollection(aMgr) {}
+
+  ItemSequence contents();
+  void deleteNodeFirst();
+  void deleteNodeLast();
+  void deleteNodes(const ItemSequence &aNodes );
+  void deleteNodesFirst(unsigned long aNumNodes );
+  void deleteNodesLast(unsigned long aNumNodes );
+  //std::vector< Annotation > getAnnotations():
+  Item getName();
+  TypeIdentifier getType();
+  long long indexOf(const Item &aNode );
+  void insertNodesAfter(const Item &aTarget, const ItemSequence &aNodes );
+  void insertNodesBefore(const Item &aTarget, const ItemSequence &aNodes );
+  void insertNodesFirst(const ItemSequence &aNodes );
+  void insertNodesLast(const ItemSequence &aNodes );
+  bool isStatic();
+  //void  registerDiagnosticHandler(DiagnosticHandler *aDiagnosticHandler );
+};
+
+#endif
\ No newline at end of file

=== added file 'swig/Collection.i'
--- swig/Collection.i	1970-01-01 00:00:00 +0000
+++ swig/Collection.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2006-2012 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.
+ */
+
+%{  // start Implementation
+
+  ItemSequence Collection::contents()
+  {
+    return ItemSequence( theCollection->contents() );
+  }
+
+  void Collection::deleteNodeFirst()
+  {
+    theCollection->deleteNodeFirst();
+  }
+
+  void Collection::deleteNodeLast()
+  {
+    theCollection->deleteNodeLast();
+  }
+
+  void Collection::deleteNodes(const ItemSequence &aNodes )
+  {
+    theCollection->deleteNodes( aNodes.theItemSequence );
+  }
+
+  void Collection::deleteNodesFirst(unsigned long aNumNodes )
+  {
+    theCollection->deleteNodesFirst(aNumNodes);
+  }
+
+  void Collection::deleteNodesLast(unsigned long aNumNodes )
+  {
+    theCollection->deleteNodesLast(aNumNodes);
+  }
+
+  Item Collection::getName()
+  {
+    return Item( theCollection->getName() );
+  }
+
+  TypeIdentifier Collection::getType()
+  {
+    return TypeIdentifier( theCollection->getType() );
+  }
+
+  long long Collection::indexOf(const Item &aNode )
+  {
+    return theCollection->indexOf( aNode.theItem );
+  }
+
+  void Collection::insertNodesAfter(const Item &aTarget, const ItemSequence &aNodes )
+  {
+    theCollection->insertNodesAfter( aTarget.theItem, aNodes.theItemSequence );
+  }
+
+  void Collection::insertNodesBefore(const Item &aTarget, const ItemSequence &aNodes )
+  {
+    theCollection->insertNodesBefore( aTarget.theItem, aNodes.theItemSequence );
+  }
+
+  void Collection::insertNodesFirst(const ItemSequence &aNodes )
+  {
+    theCollection->insertNodesFirst( aNodes.theItemSequence );
+  }
+
+  void Collection::insertNodesLast(const ItemSequence &aNodes )
+  {
+    theCollection->insertNodesLast( aNodes.theItemSequence );
+  }
+
+  bool Collection::isStatic()
+  {
+    return theCollection->isStatic();
+  }
+
+%}  // end   Implementation
+
+%include "Collection.h"

=== added file 'swig/CollectionManager.h'
--- swig/CollectionManager.h	1970-01-01 00:00:00 +0000
+++ swig/CollectionManager.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2006-2012 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 API_COLLECTION_MANAGER_H
+#define API_COLLECTION_MANAGER_H
+
+class CollectionManager
+{
+private:
+  zorba::CollectionManager* theManager;
+
+public:
+  CollectionManager() : theManager(0) {}
+  CollectionManager(const CollectionManager& aMgr) : theManager(aMgr.theManager) {}
+  CollectionManager(zorba::CollectionManager* aMgr) : theManager(aMgr) {}
+
+  ItemSequence availableCollections();
+  void createCollection(const Item &aName );
+  void deleteCollection(const Item &aName );
+  Collection getCollection(const Item &aName );
+  bool isAvailableCollection(const Item &aName );
+  //virtual void  registerDiagnosticHandler(DiagnosticHandler *aDiagnosticHandler )
+};
+
+#endif
\ No newline at end of file

=== added file 'swig/CollectionManager.i'
--- swig/CollectionManager.i	1970-01-01 00:00:00 +0000
+++ swig/CollectionManager.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2006-2012 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.
+ */
+
+%{  // start Implementation
+
+  ItemSequence CollectionManager::availableCollections()
+  {
+    return ItemSequence( theManager->availableCollections() );
+  }
+
+  void CollectionManager::createCollection(const Item &aName )
+  {
+    theManager->createCollection(aName.theItem );
+  }
+
+  void CollectionManager::deleteCollection(const Item &aName )
+  {
+    theManager->deleteCollection(aName.theItem );
+  }
+  
+  Collection CollectionManager::getCollection(const Item &aName )
+  {
+    return Collection(theManager->getCollection(aName.theItem ));
+  }
+
+  bool CollectionManager::isAvailableCollection(const Item &aName )
+  {
+    return theManager->isAvailableCollection(aName.theItem );
+  }
+
+
+%}  // end   Implementation
+
+%include "CollectionManager.h"

=== added file 'swig/DocumentManager.h'
--- swig/DocumentManager.h	1970-01-01 00:00:00 +0000
+++ swig/DocumentManager.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2006-2012 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 API_DOCUMENT_MANAGER_H
+#define API_DOCUMENT_MANAGER_H
+
+class DocumentManager
+{
+private:
+  zorba::DocumentManager* theManager;
+
+public:
+  DocumentManager() : theManager(0) {}
+  DocumentManager(const DocumentManager& aMgr) : theManager(aMgr.theManager) {}
+  DocumentManager(zorba::DocumentManager* aMgr) : theManager(aMgr) {}
+
+  void put(const std::string& aName, Item aDoc);
+  void remove(const std::string& aName);
+  Item document(const std::string& aName);
+  bool isAvailableDocument(const std::string& aName);
+  ItemSequence availableDocuments();
+};
+
+#endif
\ No newline at end of file

=== added file 'swig/DocumentManager.i'
--- swig/DocumentManager.i	1970-01-01 00:00:00 +0000
+++ swig/DocumentManager.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2006-2012 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.
+ */
+
+%{  // start Implementation
+  void DocumentManager::put(const std::string& aName, Item aDoc)
+  {
+    theManager->put(aName, aDoc.theItem);
+  }
+
+  void DocumentManager::remove(const std::string& aName)
+  {
+    theManager->remove(aName);
+  }
+
+  Item DocumentManager::document(const std::string& aName)
+  {
+    return theManager->document(aName);
+  }
+
+  bool DocumentManager::isAvailableDocument(const std::string& aName)
+  {
+    return theManager->isAvailableDocument(aName);
+  }
+
+  ItemSequence DocumentManager::availableDocuments()
+  {
+    return ItemSequence( theManager->availableDocuments() );
+  }
+
+
+%}  // end   Implementation
+
+%include "DocumentManager.h"

=== added file 'swig/DynamicContext.h'
--- swig/DynamicContext.h	1970-01-01 00:00:00 +0000
+++ swig/DynamicContext.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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 API_DYNAMIC_CONTEXT_H
+#define API_DYNAMIC_CONTEXT_H
+
+class DynamicContext
+{
+private:
+  zorba::DynamicContext* theContext;
+public:
+
+  DynamicContext():theContext(0) {}
+  DynamicContext(const DynamicContext& aCtx):theContext(aCtx.theContext) {}
+  DynamicContext(zorba::DynamicContext* aCtx):theContext(aCtx) {}
+
+  bool 	getContextItem (Item& aItem);
+  Item 	getCurrentDateTime ();
+  Item 	getDefaultCollection ();
+  int 	getImplicitTimezone ();
+  bool 	getVariable (const std::string& aNamespace, const std::string& aLocalname, Item& aItem, Iterator& aIterator);
+  
+  bool setContextItem (Item& aItem);
+  bool setCurrentDateTime (Item& aDateTimeItem);
+  bool setDefaultCollection (Item& aCollectionUri);
+  bool setImplicitTimezone (int aTimezone);
+  bool setVariable (const std::string& aNamespace, const std::string& aLocalname, Iterator& aIter);
+  bool setVariable (const std::string& aQName, Item& aItem);
+  bool setVariable (const std::string& aQName, Iterator& aIterator);
+
+};
+
+#endif
\ No newline at end of file

=== added file 'swig/DynamicContext.i'
--- swig/DynamicContext.i	1970-01-01 00:00:00 +0000
+++ swig/DynamicContext.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+%{  // start Implementation
+
+  bool DynamicContext::getContextItem (Item& aItem) {
+    return theContext->getContextItem(aItem.theItem);
+  }
+  Item DynamicContext::getCurrentDateTime (){
+    return Item(theContext->getCurrentDateTime());
+  }
+  Item DynamicContext::getDefaultCollection () {
+    return Item(theContext->getDefaultCollection());
+  }
+  int 	DynamicContext::getImplicitTimezone (){
+    return theContext->getImplicitTimezone();
+  }
+  bool 	DynamicContext::getVariable (const std::string& aNamespace, const std::string& aLocalname, Item& aItem, Iterator& aIterator) {
+    return theContext->getVariable(aNamespace, aLocalname, aItem.theItem, aIterator.theIterator);
+  }
+
+  bool DynamicContext::setContextItem (Item& aItem) {
+    return theContext->setContextItem(aItem.theItem);
+  }
+  bool DynamicContext::setCurrentDateTime (Item& aDateTimeItem) {
+    return theContext->setCurrentDateTime(aDateTimeItem.theItem);
+  }
+  bool DynamicContext::setDefaultCollection (Item& aCollectionUri) {
+    return theContext->setDefaultCollection(aCollectionUri.theItem);
+  }
+  bool DynamicContext::setImplicitTimezone (int aTimezone) {
+    return theContext->setImplicitTimezone(aTimezone);
+  }
+  bool DynamicContext::setVariable(const std::string& aNamespace, const std::string& aLocalname, Iterator& aIter) {
+    return theContext->setVariable(aNamespace, aLocalname, aIter.theIterator);
+  }
+  bool DynamicContext::setVariable (const std::string& aQName, Item& aItem) {
+    return theContext->setVariable (aQName, aItem.theItem);
+  }
+  bool DynamicContext::setVariable (const std::string& aQName, Iterator& aIterator) {
+    return theContext->setVariable (aQName, aIterator.theIterator);
+  }
+
+%}  // end   Implementation
+
+%include "DynamicContext.h"

=== added file 'swig/Item.h'
--- swig/Item.h	1970-01-01 00:00:00 +0000
+++ swig/Item.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,68 @@
+/*
+ * 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 API_ITEM_H
+#define API_ITEM_H
+
+class Item 
+{
+  friend class Iterator;
+  friend class StaticContext;
+  friend class DocumentManager; 
+  friend class SingletonIterator;
+  friend class DynamicContext;
+  friend class ItemFactory;
+  friend class Collection;
+  friend class CollectionManager;
+private:
+  zorba::Item theItem;
+
+public: 
+  Item() {}
+  Item(const Item& aItem) : theItem(aItem.theItem) {}
+  Item(const zorba::Item& aZItem) : theItem(aZItem) {}
+
+  static Item createEmptyItem();
+  std::string getStringValue() const;
+  std::string serialize() const;
+  std::string serialize(SerializationOptions serOptions) const;
+  Iterator getAtomizationValue () const;
+  Iterator getAttributes () const;
+  bool getBooleanValue () const;
+  Iterator getChildren () const;
+  Item getEBV () const;
+  int getIntValue () const;
+  double 	getDoubleValue () const;
+  long long getLongValue () const;
+  std::string getLocalName () const;
+  std::string getNamespace () const;
+  bool getNodeName (Item &aNodeName) const;
+  Item 	getParent () const;
+  std::string getPrefix () const;
+  Item getType () const;
+  unsigned int getUnsignedIntValue () const;
+
+  int getNodeKind() const;
+  bool isAtomic () const;
+  bool isNaN () const;
+  bool isNode () const;
+  bool isNull () const;
+  bool isPosOrNegInf () const;
+  
+  void close();
+}; // class Item
+
+#endif

=== added file 'swig/Item.i'
--- swig/Item.i	1970-01-01 00:00:00 +0000
+++ swig/Item.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+%{  // start Implementation
+
+  Item Item::createEmptyItem()
+  {  return Item();  }
+
+  std::string Item::getStringValue() const 
+  {  return std::string(theItem.getStringValue().c_str());  }
+
+  std::string Item::serialize() const 
+  {
+    std::stringstream lStream;
+    Zorba_SerializerOptions_t lOptions;
+    lOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;
+    zorba::Serializer_t lSerializer = zorba::Serializer::createSerializer(lOptions);
+    zorba::SingletonItemSequence lSequence(theItem);
+    lSerializer->serialize(&lSequence, lStream);
+    return lStream.str();
+  }
+  std::string Item::serialize(SerializationOptions serOptions) const 
+  {
+    std::stringstream lStream;
+    serOptions.lOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;
+    zorba::Serializer_t lSerializer = zorba::Serializer::createSerializer(serOptions.lOptions);
+    zorba::SingletonItemSequence lSequence(theItem);
+    lSerializer->serialize(&lSequence, lStream);
+    return lStream.str();
+  }
+
+  Iterator Item::getAtomizationValue () const
+  { return Iterator(theItem.getAtomizationValue()); }
+
+  Iterator Item::getAttributes () const
+  { return Iterator(theItem.getAttributes()); }
+
+  bool Item::getBooleanValue () const
+  { return theItem.getBooleanValue(); }
+
+  Iterator Item::getChildren () const
+  { return Iterator(theItem.getChildren()); }
+
+  Item Item::getEBV () const
+  { return Item(theItem.getEBV()); }
+
+  int Item::getIntValue () const
+  { return theItem.getIntValue(); }
+
+  double 	Item::getDoubleValue () const
+  { return theItem.getDoubleValue(); }
+
+  long long Item::getLongValue () const
+  { return theItem.getLongValue(); }
+
+  std::string Item::getLocalName () const
+  { return std::string(theItem.getLocalName().c_str()); }
+
+  std::string Item::getNamespace () const
+  { return std::string(theItem.getNamespace().c_str()); }
+
+  bool Item::getNodeName (Item &aNodeName) const
+  { return theItem.getNodeName( aNodeName.theItem ); }
+
+  Item 	Item::getParent () const
+  { return theItem.getParent(); }
+
+  std::string Item::getPrefix () const
+  { return std::string(theItem.getPrefix().c_str()); }
+
+  Item Item::getType () const
+  { return Item( theItem.getType() ); }
+
+  unsigned int Item::getUnsignedIntValue () const
+  { return theItem.getUnsignedIntValue(); }
+
+  bool Item::isAtomic () const
+  { return theItem.isAtomic(); }
+
+  bool Item::isNaN () const
+  { return theItem.isNaN(); }
+
+  bool Item::isNode () const
+  { return theItem.isNode(); }
+
+  bool Item::isNull () const
+  { return theItem.isNull(); }
+
+  bool Item::isPosOrNegInf () const
+  { return theItem.isPosOrNegInf(); }
+
+  int Item::getNodeKind () const
+  { return theItem.getNodeKind(); }
+  
+  void Item::close()
+  { theItem.close(); }
+
+%}  // end   Implementation
+
+
+%include "Item.h"

=== modified file 'swig/ItemFactory.h'
--- swig/ItemFactory.h	2012-03-23 17:32:07 +0000
+++ swig/ItemFactory.h	2012-03-26 20:16:18 +0000
@@ -1,4 +1,21 @@
-// Interface
+/*
+ * 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 API_ITEM_FACTORY_H
+#define API_ITEM_FACTORY_H
 
 class ItemFactory
 {
@@ -11,13 +28,16 @@
     ItemFactory(const ItemFactory& aItemFactory) : theItemFactory(aItemFactory.theItemFactory) {}
 
     Item 	createAnyURI (const std::string &aURI);
-    Item 	createAttributeNode (Item aParent, Item aNodeName, Item aTypeName, Item aTypedValue);
-    Item 	createAttributeNode (Item aParent, Item aNodeName, Item aTypeName, std::vector< Item > aTypedValue);
+    Item 	createAttributeNode (Item& aParent, Item& aNodeName, Item& aTypeName, Item& aTypedValue);
+#ifndef SWIGRUBY
+    Item 	createAttributeNode (Item& aParent, Item& aNodeName, Item& aTypeName, std::vector< Item > aTypedValue);
+#endif
     Item 	createBase64Binary (const char *aBinData, size_t aLength);
     Item 	createBase64Binary (std::istream &aStream);
     Item 	createBase64Binary (const unsigned char *aBinData, size_t aLength);
     Item 	createBoolean (bool aValue);
     Item 	createByte (char aByte);
+    Item 	createCommentNode (Item &aParent, const std::string &aContent);
     Item 	createDate (const std::string &aDate);
     Item 	createDate (short aYear, short aMonth, short aDay);
     Item 	createDateTime (const std::string &aDateTimeValue);
@@ -29,7 +49,13 @@
     Item 	createDouble (double aValue);
     Item 	createDuration (const std::string &aValue);
     Item 	createDuration (short aYear, short aMonths, short aDays, short aHours, short aMinutes, double aSeconds);
-    //Item 	createElementNode (Item &aParent, Item aNodeName, Item aTypeName, bool aHasTypedValue, bool aHasEmptyValue, std::vector< std::pair< std::string, std::string > > aNsBindings);
+    Item 	createDayTimeDuration (const std::string &aValue);
+    Item 	createYearMonthDuration (const std::string &aValue);
+    Item 	createDocumentNode (const std::string &aBaseUri, const std::string &aDocUri);
+#ifndef SWIGRUBY
+    Item 	createElementNode (Item &aParent, Item &aNodeName, Item &aTypeName, bool aHasTypedValue, bool aHasEmptyValue, std::vector< std::pair< std::string, std::string > > aNsBindings);
+#endif
+    Item 	createElementNode (Item &aParent, Item &aNodeName, Item &aTypeName, bool aHasTypedValue, bool aHasEmptyValue);
     Item 	createFloat (const std::string &aValue);
     Item 	createFloat (float aValue);
     Item 	createGDay (const std::string &aValue);
@@ -51,6 +77,7 @@
     Item 	createNegativeInteger (long long aValue);
     Item 	createNonNegativeInteger (unsigned long long aValue);
     Item 	createNonPositiveInteger (long long aValue);
+    Item 	createPiNode (Item &aParent, const std::string &aTarget, const std::string &aContent, const std::string &aBaseUri);
     Item 	createPositiveInteger (unsigned long long aValue);
     Item 	createQName (const std::string &aNamespace, const std::string &aPrefix, const std::string &aLocalname);
     Item 	createQName (const std::string &aNamespace, const std::string &aLocalname);
@@ -58,7 +85,7 @@
     Item 	createShort (short aShort);
     //Item 	createStreamableString (std::istream &stream, StreamReleaser streamReleaser, bool seekable=false);
     Item 	createString (const std::string &aString);
-    Item 	createTextNode (Item parent, std::string content);
+    Item 	createTextNode (Item &aParent, const std::string &aContent);
     Item 	createTime (short aHour, short aMinute, double aSecond, short aTimeZone_hours);
     Item 	createTime (short aHour, short aMinute, double aSecond);
     Item 	createTime (const std::string &aValue);
@@ -67,3 +94,5 @@
     Item 	createUnsignedLong (unsigned long long aValue);
     Item 	createUnsignedShort (unsigned short aValue);
 }; // class ItemFactory
+
+#endif
\ No newline at end of file

=== modified file 'swig/ItemFactory.i'
--- swig/ItemFactory.i	2012-03-23 17:32:07 +0000
+++ swig/ItemFactory.i	2012-03-26 20:16:18 +0000
@@ -7,11 +7,12 @@
     return Item(theItemFactory->createAnyURI(aURI));
   }
   
-  Item 	ItemFactory::createAttributeNode (Item aParent, Item aNodeName, Item aTypeName, Item aTypedValue){
+  Item 	ItemFactory::createAttributeNode (Item& aParent, Item& aNodeName, Item& aTypeName, Item& aTypedValue){
     return Item( theItemFactory->createAttributeNode( aParent.theItem, aNodeName.theItem, aTypeName.theItem, aTypedValue.theItem ));
   }
   
-  Item 	ItemFactory::createAttributeNode (Item aParent, Item aNodeName, Item aTypeName, std::vector< Item > aTypedValue){
+#ifndef SWIGRUBY
+  Item 	ItemFactory::createAttributeNode (Item& aParent, Item& aNodeName, Item& aTypeName, std::vector< Item > aTypedValue){
 
     std::vector< zorba::Item > typedValue;
     typedValue.reserve(aTypedValue.size());
@@ -21,6 +22,7 @@
     }
     return Item( theItemFactory->createAttributeNode (aParent.theItem, aNodeName.theItem, aTypeName.theItem, typedValue ));
   }
+#endif
   
   Item 	ItemFactory::createBase64Binary (const char *aBinData, size_t aLength){
     return Item( theItemFactory->createBase64Binary(aBinData, aLength));
@@ -37,6 +39,10 @@
   Item 	ItemFactory::createByte (char aByte){
     return Item( theItemFactory->createByte(aByte));
   }
+  Item 	ItemFactory::createCommentNode (Item &aParent, const std::string &aContent){
+    zorba::String lContent = zorba::String(aContent);
+    return Item( theItemFactory->createCommentNode (aParent.theItem, lContent));
+  }
   Item 	ItemFactory::createDate (const std::string &aDate){
     return Item( theItemFactory->createDate(aDate));
   }
@@ -70,11 +76,32 @@
   Item 	ItemFactory::createDuration (short aYear, short aMonths, short aDays, short aHours, short aMinutes, double aSeconds){
     return Item( theItemFactory->createDuration (aYear, aMonths, aDays, aHours, aMinutes, aSeconds));
   }
-  /*
-  Item 	ItemFactory::createElementNode (Item &aParent, Item aNodeName, Item aTypeName, bool aHasTypedValue, bool aHasEmptyValue, std::vector< std::pair< std::string, std::string > > aNsBindings){
-    return Item( theItemFactory->createElementNode (aParent.theItem, aNodeName.theItem, aTypeName.theItem, aHasTypedValue, aHasEmptyValue, aNsBindings));
-  }
-  */
+  Item 	ItemFactory::createDayTimeDuration (const std::string &aValue){
+    return Item( theItemFactory->createDayTimeDuration (aValue));
+  }
+  Item 	ItemFactory::createYearMonthDuration (const std::string &aValue){
+    return Item( theItemFactory->createYearMonthDuration (aValue));
+  }
+  Item 	ItemFactory::createDocumentNode (const std::string &aBaseUri, const std::string &aDocUri){
+    return Item( theItemFactory->createDocumentNode (aBaseUri, aDocUri));
+  }
+#ifndef SWIGRUBY
+  Item 	ItemFactory::createElementNode (Item &aParent, Item& aNodeName, Item& aTypeName, bool aHasTypedValue, bool aHasEmptyValue, std::vector< std::pair< std::string, std::string > > aNsBindings){
+    std::vector< std::pair< zorba::String, zorba::String > > items;
+    items.reserve(aNsBindings.size());
+    std::vector< std::pair< std::string, std::string > >::iterator iter;
+    for(iter = aNsBindings.begin(); iter != aNsBindings.end(); iter++) {
+      std::pair< zorba::String, zorba::String > pair;
+      pair.first = (*iter).first;
+      pair.second = (*iter).second;
+      items.push_back(pair);
+    }
+    return Item( theItemFactory->createElementNode (aParent.theItem, aNodeName.theItem, aTypeName.theItem, aHasTypedValue, aHasEmptyValue, items));
+  }
+#endif
+  Item 	ItemFactory::createElementNode (Item &aParent, Item& aNodeName, Item& aTypeName, bool aHasTypedValue, bool aHasEmptyValue){
+    return Item( theItemFactory->createElementNode (aParent.theItem, aNodeName.theItem, aTypeName.theItem, aHasTypedValue, aHasEmptyValue, std::vector<std::pair<zorba::String, zorba::String> >()));
+  }
   Item 	ItemFactory::createFloat (const std::string &aValue){
     return Item( theItemFactory->createFloat (aValue));
   }
@@ -138,6 +165,12 @@
   Item 	ItemFactory::createNonPositiveInteger (long long aValue){
     return Item( theItemFactory->createNonPositiveInteger (aValue));
   }
+  Item 	ItemFactory::createPiNode (Item &aParent, const std::string &aTarget, const std::string &aContent, const std::string &aBaseUri){
+    zorba::String lTarget = zorba::String(aTarget);
+    zorba::String lContent = zorba::String(aContent);
+    zorba::String lBaseUri = zorba::String(aBaseUri);
+    return Item( theItemFactory->createPiNode (aParent.theItem, lTarget, lContent, lBaseUri));
+  }
   Item 	ItemFactory::createPositiveInteger (unsigned long long aValue){
     return Item( theItemFactory->createPositiveInteger (aValue));
   }
@@ -161,8 +194,9 @@
   Item 	ItemFactory::createString (const std::string &aString){
     return Item( theItemFactory->createString (aString));
   }
-  Item 	ItemFactory::createTextNode (Item parent, std::string content){
-    return Item( theItemFactory->createTextNode (parent.theItem, content));
+  Item 	ItemFactory::createTextNode (Item &aParent, const std::string &aContent){
+    zorba::String lContent = zorba::String(aContent);
+    return Item( theItemFactory->createTextNode (aParent.theItem, lContent));
   }
   Item 	ItemFactory::createTime (short aHour, short aMinute, double aSecond, short aTimeZone_hours){
     return Item( theItemFactory->createTime (aHour, aMinute, aSecond, aTimeZone_hours));
@@ -189,4 +223,4 @@
 
 %}  // end Implementation
 
-%include "ItemFactory.h"
\ No newline at end of file
+%include "ItemFactory.h"

=== added file 'swig/ItemSequence.h'
--- swig/ItemSequence.h	1970-01-01 00:00:00 +0000
+++ swig/ItemSequence.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2006-2012 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 API_ITEM_SEQUENCE_H
+#define API_ITEM_SEQUENCE_H
+
+class ItemSequence
+{
+  friend class Collection;
+private:
+  zorba::ItemSequence_t theItemSequence;
+
+public:
+  ItemSequence(const ItemSequence& aItemSequence) : theItemSequence(aItemSequence.theItemSequence) {}
+  ItemSequence(zorba::ItemSequence_t aItemSequence) : theItemSequence(aItemSequence) {}
+  Iterator getIterator();
+
+};
+
+#endif
\ No newline at end of file

=== added file 'swig/ItemSequence.i'
--- swig/ItemSequence.i	1970-01-01 00:00:00 +0000
+++ swig/ItemSequence.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2006-2012 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.
+ */
+
+%{  // start Implementation
+
+  Iterator ItemSequence::getIterator()
+  {
+    return Iterator( theItemSequence->getIterator() );
+  }
+
+%}  // end   Implementation
+
+%include "ItemSequence.h"

=== added file 'swig/Iterator.h'
--- swig/Iterator.h	1970-01-01 00:00:00 +0000
+++ swig/Iterator.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,57 @@
+/*
+ * 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 API_ITERATOR_H
+#define API_ITERATOR_H
+
+class Iterator 
+{
+protected:
+  friend class DynamicContext;
+  friend class DocumentManager;
+  friend class CollectionManager;
+  friend class Collection;
+  friend class StaticContext;
+  friend class XQuery;
+  friend class ItemSequence;
+  zorba::Iterator_t theIterator;
+  zorba::Item theItem;
+  bool theConsumed;
+public:
+  // constructors
+  Iterator() {}
+  Iterator(const Iterator& anIterator)
+    : theIterator(anIterator.theIterator),
+      theItem(anIterator.theItem),
+      theConsumed(false)
+  {}
+  Iterator(zorba::Iterator_t anIterator)
+    : theIterator(anIterator),
+      theConsumed(false)
+  {}
+  Iterator(zorba::Item& aItem)
+    : theIterator(0),
+      theItem(aItem),
+      theConsumed(false)
+  {}
+
+  void open();
+  bool isOpen();
+  bool next(Item&);
+  void close();
+  void destroy();
+}; // class Iterator
+
+#endif
\ No newline at end of file

=== added file 'swig/Iterator.i'
--- swig/Iterator.i	1970-01-01 00:00:00 +0000
+++ swig/Iterator.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+%{  // start Implementation
+
+  void Iterator::open()
+  {
+    if (theIterator)
+      theIterator->open();
+    theConsumed = false;
+  }
+
+  bool Iterator::isOpen()
+  {
+    if (theIterator)
+      return theIterator->isOpen();
+    else 
+      return !theConsumed;
+  }
+
+  void Iterator::close()
+  {
+    if (theIterator)
+      theIterator->close();
+    theConsumed = true;
+  }
+
+  void Iterator::destroy()
+  {
+    theIterator = 0;
+  }
+
+  bool Iterator::next(Item& aItem)
+  {
+    if (theIterator)
+    {
+      return theIterator->next(aItem.theItem);
+    }
+    else
+    {
+      if (!theConsumed)
+      {
+        aItem = theItem;
+        return true;
+      }
+      else
+      {
+        return false;
+      }
+    }
+  }
+
+
+%}  // end   Implementation
+
+%include "Iterator.h"

=== added file 'swig/SerializationOptions.h'
--- swig/SerializationOptions.h	1970-01-01 00:00:00 +0000
+++ swig/SerializationOptions.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,114 @@
+/*
+ * 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 API_SERIALIZATION_OPTIONS_H
+#define API_SERIALIZATION_OPTIONS_H
+
+class SerializationOptions
+{
+friend class Item;
+
+public:
+  typedef enum 
+  {
+    ZORBA_API_SERIALIZATION_METHOD_XML,
+    ZORBA_API_SERIALIZATION_METHOD_HTML,
+    ZORBA_API_SERIALIZATION_METHOD_XHTML,
+    ZORBA_API_SERIALIZATION_METHOD_TEXT,
+    ZORBA_API_SERIALIZATION_METHOD_BINARY
+  } SerializationMethod;
+
+  typedef enum 
+  {
+    ZORBA_API_BYTE_ORDER_MARK_YES,
+    ZORBA_API_BYTE_ORDER_MARK_NO
+  } ByteOrderMark;
+
+
+  typedef enum 
+  {
+    ZORBA_API_ESCAPE_URI_ATTRIBUTES_YES,
+    ZORBA_API_ESCAPE_URI_ATTRIBUTES_NO
+  } EscapeUriAttributes;
+
+  typedef enum {
+    ZORBA_API_INCLUDE_CONTENT_TYPE_YES,
+    ZORBA_API_INCLUDE_CONTENT_TYPE_NO
+  } IncludeContentType;
+
+  typedef enum {
+    ZORBA_API_INDENT_YES,
+    ZORBA_API_INDENT_NO
+  } Indent;
+
+  typedef enum {
+    ZORBA_API_NORMALIZATION_FORM_NFC,
+    ZORBA_API_NORMALIZATION_FORM_NFD,
+    ZORBA_API_NORMALIZATION_FORM_NFKC,
+    ZORBA_API_NORMALIZATION_FORM_NFKD,
+    ZORBA_API_NORMALIZATION_FORM_FULLY_normalized,
+    ZORBA_API_NORMALIZATION_FORM_NONE
+  } NormalizationForm;
+
+  typedef enum {
+    ZORBA_API_OMIT_XML_DECLARATION_YES,
+    ZORBA_API_OMIT_XML_DECLARATION_NO
+  } OmitXMLDeclaration;
+
+  typedef enum {
+    ZORBA_API_STANDALONE_YES,
+    ZORBA_API_STANDALONE_NO,
+    ZORBA_API_STANDALONE_OMIT
+  } Standalone;
+
+  typedef enum {
+    ZORBA_API_UNDECLARE_PREFIXES_YES,
+    ZORBA_API_UNDECLARE_PREFIXES_NO
+  } UndeclarePrefixes;
+
+
+private:
+  Zorba_SerializerOptions_t lOptions;
+  
+public:
+  /*
+   * Default values:
+   *   - serialization method: XML
+   *   - byte order mark: NO
+   *   - esacpe uri attributes: NO
+   *   - include content type: NO
+   *   - indent: NO
+   *   - normalization form: none
+   *   - omit xml declaration: NO
+   *   - standalone: omit
+   *   - undeclare prefixes: NO
+   */
+
+
+  void setSerializationMethod ( SerializationMethod aSerializationMethod );
+  void setByteOrderMark ( ByteOrderMark aByteOrderMark );
+  void setEscapeUriAttributes ( EscapeUriAttributes aEscapeUriAttributes );
+  void setIncludeContentType ( IncludeContentType aIncludeContentType );
+  void setIndent ( Indent aIndent );
+  void setNormalizationForm ( NormalizationForm aNormalizationForm );
+  void setOmitXMLDeclaration ( OmitXMLDeclaration aOmitXMLDeclaration );
+  void setStandalone ( Standalone aStandalone );
+  void setUndeclarePrefixes ( UndeclarePrefixes aUndeclarePrefixes );
+  void setSerializerOption(const std::string &parameter, const std::string &value);
+
+}; // class SerializationOptions
+
+#endif

=== added file 'swig/SerializationOptions.i'
--- swig/SerializationOptions.i	1970-01-01 00:00:00 +0000
+++ swig/SerializationOptions.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,125 @@
+/*
+ * 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.
+ */
+
+%{  // start Implementation
+
+  void SerializationOptions::setSerializationMethod ( SerializationMethod aSerializationMethod ) {
+    switch (aSerializationMethod) {
+      case ZORBA_API_SERIALIZATION_METHOD_HTML:
+        lOptions.ser_method = ZORBA_SERIALIZATION_METHOD_HTML;
+        break;
+      case ZORBA_API_SERIALIZATION_METHOD_XHTML:
+        lOptions.ser_method = ZORBA_SERIALIZATION_METHOD_XHTML;
+        break;
+      case ZORBA_API_SERIALIZATION_METHOD_TEXT:
+        lOptions.ser_method = ZORBA_SERIALIZATION_METHOD_TEXT;
+        break;
+      case ZORBA_API_SERIALIZATION_METHOD_BINARY:
+        lOptions.ser_method = ZORBA_SERIALIZATION_METHOD_BINARY;
+        break;
+      case ZORBA_API_SERIALIZATION_METHOD_XML:
+      default:
+        lOptions.ser_method = ZORBA_SERIALIZATION_METHOD_XML;
+        break;
+    }
+  }
+  void SerializationOptions::setByteOrderMark ( ByteOrderMark aByteOrderMark ) {
+    if (aByteOrderMark == ZORBA_API_BYTE_ORDER_MARK_YES) {
+      lOptions.byte_order_mark = ZORBA_BYTE_ORDER_MARK_YES;
+    } else {
+      lOptions.byte_order_mark = ZORBA_BYTE_ORDER_MARK_NO;
+    }
+  }
+  void SerializationOptions::setEscapeUriAttributes ( EscapeUriAttributes aEscapeUriAttributes ) {
+    if (aEscapeUriAttributes == ZORBA_API_ESCAPE_URI_ATTRIBUTES_YES) {
+      lOptions.escape_uri_attributes = ZORBA_ESCAPE_URI_ATTRIBUTES_YES;
+    } else {
+      lOptions.escape_uri_attributes = ZORBA_ESCAPE_URI_ATTRIBUTES_NO;
+    }
+  }
+  void SerializationOptions::setIncludeContentType ( IncludeContentType aIncludeContentType ) {
+    if (aIncludeContentType == ZORBA_API_INCLUDE_CONTENT_TYPE_YES) {
+      lOptions.include_content_type = ZORBA_INCLUDE_CONTENT_TYPE_YES;
+    } else {
+      lOptions.include_content_type = ZORBA_INCLUDE_CONTENT_TYPE_NO;
+    }
+  }
+  void SerializationOptions::setIndent ( Indent aIndent ) {
+    if (aIndent == ZORBA_API_INDENT_YES) {
+      lOptions.indent = ZORBA_INDENT_YES;
+    } else {
+      lOptions.indent = ZORBA_INDENT_NO;
+    }
+  }
+  void SerializationOptions::setNormalizationForm ( NormalizationForm aNormalizationForm ) {
+    switch (aNormalizationForm) {
+      case ZORBA_API_NORMALIZATION_FORM_NFC:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_NFC;
+        break;
+      case ZORBA_API_NORMALIZATION_FORM_NFD:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_NFD;
+        break;
+      case ZORBA_API_NORMALIZATION_FORM_NFKC:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_NFKC;
+        break;
+      case ZORBA_API_NORMALIZATION_FORM_NFKD:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_NFKD;
+        break;
+      case ZORBA_API_NORMALIZATION_FORM_FULLY_normalized:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_FULLY_normalized;
+        break;
+      case ZORBA_API_NORMALIZATION_FORM_NONE:
+      default:
+        lOptions.normalization_form = ZORBA_NORMALIZATION_FORM_NONE;
+        break;
+    }
+  }
+  void SerializationOptions::setOmitXMLDeclaration ( OmitXMLDeclaration aOmitXMLDeclaration ) {
+    if (aOmitXMLDeclaration == ZORBA_API_OMIT_XML_DECLARATION_YES) {
+      lOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;
+    } else {
+      lOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_NO;
+    }
+  }
+  void SerializationOptions::setStandalone ( Standalone aStandalone ) {
+    switch (aStandalone) {
+      case ZORBA_API_STANDALONE_YES:
+        lOptions.standalone = ZORBA_STANDALONE_YES;
+        break;
+      case ZORBA_API_STANDALONE_NO:
+        lOptions.standalone = ZORBA_STANDALONE_NO;
+        break;
+      case ZORBA_API_STANDALONE_OMIT:
+      default:
+        lOptions.standalone = ZORBA_STANDALONE_OMIT;
+        break;
+    }
+  }
+  void SerializationOptions::setUndeclarePrefixes ( UndeclarePrefixes aUndeclarePrefixes ) {
+    if (aUndeclarePrefixes == ZORBA_API_UNDECLARE_PREFIXES_YES) {
+      lOptions.undeclare_prefixes = ZORBA_UNDECLARE_PREFIXES_YES;
+    } else {
+      lOptions.undeclare_prefixes = ZORBA_UNDECLARE_PREFIXES_NO;
+    }
+  }
+
+  void SerializationOptions::setSerializerOption(const std::string &parameter, const std::string &value) {
+    lOptions.SetSerializerOption(parameter.c_str(), value.c_str());
+  }
+  
+%}  // end Implementation
+
+%include "SerializationOptions.h"

=== modified file 'swig/StaticContext.h'
--- swig/StaticContext.h	2012-03-23 17:32:07 +0000
+++ swig/StaticContext.h	2012-03-26 20:16:18 +0000
@@ -1,5 +1,69 @@
+/*
+ * 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 API_STATIC_CONTEXT_H
+#define API_STATIC_CONTEXT_H
+
 #include <zorba/static_context_consts.h>
 
+class ZorbaConstants
+{
+public:
+  typedef enum {
+    PRESERVE,
+    NO_PRESERVE
+  } PreserveMode;
+
+  typedef enum {
+    INHERIT,
+    NO_INHERIT
+  } InheritMode;
+
+  typedef enum {
+    PRESERVE_SPACE,
+    STRIP_SPACE
+  } BoundarySpaceMode;
+
+  typedef enum {
+    PRESERVE_CONSTRUCTION,
+    STRIP_CONSTRUCTION
+  } ConstructionMode;
+
+  typedef enum {
+    EMPTY_GREATEST,
+    EMPTY_LEAST
+  } OrderEmptyMode;
+
+  typedef enum {
+    ORDERED,
+    UNORDERED
+  } OrderingMode;
+
+  typedef enum {
+    VALIDATE_SKIP,
+    VALIDATE_LAX,
+    VALIDATE_STRICT
+  } RevalidationMode;
+
+  typedef enum {
+    XPATH2_0,
+    XPATH1_0
+  } XPath1_0CompatibleMode;
+
+}; // ZorbaConstants
+
 class StaticContext 
 {
 friend class Zorba;
@@ -8,62 +72,73 @@
 private:
   zorba::StaticContext_t theStaticContext;
 public:
-  StaticContext();
+
   StaticContext(const StaticContext& aStaticContext);
   StaticContext(zorba::StaticContext_t aStaticContext);
   
-  virtual void addColation(const std::string& aURI); 
-  virtual bool addNamespace(const std::string& aPrefix,
+  void addColation(const std::string& aURI); 
+  bool addNamespace(const std::string& aPrefix,
                             const std::string& aURI);
-  void addReference() const;
-  virtual bool containsFunction(const std::string &aFnNameUri, 
+
+  bool containsFunction(const std::string &aFnNameUri, 
                                 const std::string &aFnNameLocal, 
                                 int arity) const;
 
-  virtual StaticContext createChildContext() const;
-  virtual void declareOption(const Item &aQName, 
+  StaticContext createChildContext() const;
+  void declareOption(const Item &aQName, 
                              const std::string &aOptionVal);
-  virtual void disableFunction(const Item &aQName, int arity);
-
-  virtual void free ();
-  virtual std::string getBaseURI () const;
-  virtual zorba::boundary_space_mode_t getBoundarySpacePolicy () const;
-
-  virtual zorba::construction_mode_t getConstructionMode () const;
-  virtual void getCopyNamespacesMode (zorba::preserve_mode_t &aPreserve, zorba::inherit_mode_t &aInherit) const;
-  virtual std::string getDefaultCollation () const;
-  virtual std::string getDefaultElementAndTypeNamespace () const;
-  virtual std::string getDefaultFunctionNamespace () const;
-  virtual zorba::order_empty_mode_t getDefaultOrderForEmptySequences () const;
-
-  virtual std::string getNamespaceURIByPrefix(const std::string &aPrefix) const;
-  virtual bool getOption(const Item &aQName, std::string &aOptionValue) const;
-  virtual zorba::ordering_mode_t getOrderingMode() const;
-  long getRefCount() const;
-  virtual zorba::validation_mode_t getRevalidationMode();
-  virtual zorba::xpath1_0compatib_mode_t getXPath1_0CompatibMode () const;
-  virtual void loadProlog (const std::string & aProlog, 
-                           const CompilerHints &hints);
-
-  void removeReference ();
-  virtual void resetTraceStream ();
-  virtual bool setBaseURI (const std::string &aBaseURI);
-  virtual bool setBoundarySpacePolicy (zorba::boundary_space_mode_t aMode);
-
-  virtual bool setConstructionMode (zorba::construction_mode_t aMode);
-
-  virtual bool setCopyNamespacesMode (zorba::preserve_mode_t aPreserve, 
-                                      zorba::inherit_mode_t aInherit);
-  virtual void setDefaultCollation (const std::string &aURI);
-  virtual bool setDefaultElementAndTypeNamespace (const std::string &aURI);
-  virtual bool setDefaultFunctionNamespace (const std::string &aURI);
-  virtual bool setDefaultOrderForEmptySequences (zorba::order_empty_mode_t aMode);
-
-  virtual bool setOrderingMode (zorba::ordering_mode_t aMode);
-  virtual void setRevalidationMode (zorba::validation_mode_t aMode);
-
-  virtual bool setXPath1_0CompatibMode (zorba::xpath1_0compatib_mode_t aMode);
+  void disableFunction(const Item &aQName, int arity);
+
+  std::string getBaseURI () const;
+
+  ZorbaConstants::BoundarySpaceMode getBoundarySpacePolicy ();
+  ZorbaConstants::ConstructionMode  getConstructionMode();
+  ZorbaConstants::PreserveMode getCopyNamespacesModePreserve();
+  ZorbaConstants::InheritMode  getCopyNamespacesModeInherit();
+  ZorbaConstants::OrderEmptyMode getDefaultOrderForEmptySequences();
+  ZorbaConstants::OrderingMode getOrderingMode();
+  ZorbaConstants::RevalidationMode getRevalidationMode();
+  ZorbaConstants::XPath1_0CompatibleMode getXPath1_0CompatibMode();
+
+  std::string getDefaultCollation () const;
+  std::string getDefaultElementAndTypeNamespace () const;
+  std::string getDefaultFunctionNamespace () const;
+  
+  std::vector< std::pair< std::string, std::string > > getNamespaceBindings ();
+
+  std::string getNamespaceURIByPrefix(const std::string &aPrefix) const;
+  bool getOption(const Item &aQName, std::string &aOptionValue) const;
+  void loadProlog (const std::string & aProlog, const CompilerHints &hints);
+
+  void getExternalVariables(Iterator& vars) const;
+  
+  TypeIdentifier getCollectionType(const std::string &aCollectionUri);
+  TypeIdentifier getDocumentType(const std::string &aDocUri);
+  TypeIdentifier getContextItemStaticType();
+
+  void setContextItemStaticType(const TypeIdentifier &aType);
+  
+  void resetTraceStream ();
+  bool setBaseURI (const std::string &aBaseURI);
+
+  bool setBoundarySpacePolicy (ZorbaConstants::BoundarySpaceMode aMode);
+  bool setConstructionMode (ZorbaConstants::ConstructionMode aMode);
+  bool setCopyNamespacesMode (ZorbaConstants::PreserveMode aPreserve, ZorbaConstants::InheritMode aInherit);
+  bool setDefaultOrderForEmptySequences (ZorbaConstants::OrderEmptyMode aMode);
+  bool setOrderingMode (ZorbaConstants::OrderingMode aMode);
+  void setRevalidationMode (ZorbaConstants::RevalidationMode aMode);
+
+  void setURIPath(std::vector< std::string > &aURIPath );
+  void setLIBPath(std::vector< std::string > &aLIBPath );
+  void setModulePath(std::vector< std::string > &aModulePath );
+
+  bool setXPath1_0CompatibMode (ZorbaConstants::XPath1_0CompatibleMode aMode);
+  
+  void setDefaultCollation (const std::string &aURI);
+  bool setDefaultElementAndTypeNamespace (const std::string &aURI);
+  bool setDefaultFunctionNamespace (const std::string &aURI);
 
   void destroy();
 }; // class StaticContext
 
+#endif
\ No newline at end of file

=== modified file 'swig/StaticContext.i'
--- swig/StaticContext.i	2012-03-23 17:32:07 +0000
+++ swig/StaticContext.i	2012-03-26 20:16:18 +0000
@@ -20,8 +20,6 @@
 #include <zorba/static_context_consts.h>
 
 
-StaticContext::StaticContext() {}
-
 StaticContext::StaticContext(const StaticContext& aStaticContext) : 
     theStaticContext(aStaticContext.theStaticContext) {}
     
@@ -31,65 +29,94 @@
 void StaticContext::addColation(const std::string& aURI)
   { theStaticContext->addCollation(aURI); }
 
-bool StaticContext::addNamespace(const std::string& aPrefix, 
-                            const std::string& aURI)
+bool StaticContext::addNamespace(const std::string& aPrefix, const std::string& aURI)
   { return theStaticContext->addNamespace(aPrefix, aURI); }
 
-void StaticContext::addReference() const
-  { theStaticContext->addReference(); }
-  
-bool StaticContext::containsFunction(const std::string &aFnNameUri, 
-                                const std::string &aFnNameLocal, 
-                                int arity) const 
-  { return theStaticContext->containsFunction(aFnNameUri, aFnNameLocal,
-                                              arity); }
+bool StaticContext::containsFunction(const std::string &aFnNameUri, const std::string &aFnNameLocal, int arity) const 
+  { return theStaticContext->containsFunction(aFnNameUri, aFnNameLocal, arity); }
 
 StaticContext	StaticContext::createChildContext() const
   { return StaticContext(theStaticContext->createChildContext()); }
   
-void 	StaticContext::declareOption (const Item &aQName, 
-                               const std::string &aOptionVal)
+void 	StaticContext::declareOption (const Item &aQName, const std::string &aOptionVal)
   { return theStaticContext->declareOption(aQName.theItem, aOptionVal); }
 
 void 	StaticContext::disableFunction (const Item &aQName, int arity)
   { theStaticContext->disableFunction( aQName.theItem, arity); }
 
-void 	StaticContext::free ()
-  { theStaticContext->free(); }
-
 std::string StaticContext::getBaseURI () const
   { return std::string(theStaticContext->getBaseURI().c_str()); }
 
-zorba::boundary_space_mode_t StaticContext::getBoundarySpacePolicy() const
-  { return theStaticContext->getBoundarySpacePolicy(); }
-
-zorba::construction_mode_t StaticContext::getConstructionMode () const 
-  { return theStaticContext->getConstructionMode(); }		
-
-void 	StaticContext::getCopyNamespacesMode (zorba::preserve_mode_t &aPreserve, zorba::inherit_mode_t &aInherit) const
-  { return theStaticContext->getCopyNamespacesMode(aPreserve, aInherit); }		
+ZorbaConstants::BoundarySpaceMode StaticContext::getBoundarySpacePolicy()
+  { 
+    ZorbaConstants::BoundarySpaceMode result = ZorbaConstants::PRESERVE_SPACE;
+    zorba::boundary_space_mode_t boundary = theStaticContext->getBoundarySpacePolicy();
+    if (boundary == zorba::strip_space) {
+      result = ZorbaConstants::STRIP_SPACE;
+    }
+    return result;
+  }
+
+ZorbaConstants::ConstructionMode StaticContext::getConstructionMode() 
+  { 
+    ZorbaConstants::ConstructionMode result = ZorbaConstants::STRIP_CONSTRUCTION;
+    zorba::construction_mode_t construction = theStaticContext->getConstructionMode();
+    if (construction == zorba::preserve_cons) {
+      result = ZorbaConstants::PRESERVE_CONSTRUCTION;
+    }
+    return result;
+  }		
+
+ZorbaConstants::PreserveMode StaticContext::getCopyNamespacesModePreserve()
+  { 
+    zorba::preserve_mode_t lPreserve;
+    zorba::inherit_mode_t lInherit;
+    ZorbaConstants::PreserveMode aPreserve = ZorbaConstants::NO_PRESERVE;
+    theStaticContext->getCopyNamespacesMode(lPreserve, lInherit); 
+    if (lPreserve==zorba::preserve_ns) {
+      aPreserve = ZorbaConstants::PRESERVE;
+    }
+    return aPreserve;
+  }
+
+ZorbaConstants::InheritMode StaticContext::getCopyNamespacesModeInherit()
+  { 
+    zorba::preserve_mode_t lPreserve;
+    zorba::inherit_mode_t lInherit;
+    ZorbaConstants::InheritMode aInherit = ZorbaConstants::NO_INHERIT;
+    theStaticContext->getCopyNamespacesMode(lPreserve, lInherit); 
+    if (lInherit==zorba::inherit_ns) {
+      aInherit = ZorbaConstants::INHERIT;
+    }
+    return aInherit;
+  }
 
 std::string StaticContext::getDefaultCollation () const 
   { return std::string(theStaticContext->getDefaultCollation().c_str()); }
 
 std::string StaticContext::getDefaultElementAndTypeNamespace () const 
   { 
-    return std::string(theStaticContext->getDefaultElementAndTypeNamespace().
-                       c_str()); 
+    return std::string( theStaticContext->getDefaultElementAndTypeNamespace().c_str() ); 
   }
 
 std::string StaticContext::getDefaultFunctionNamespace () const 
   { 
-    return std::string(theStaticContext->getDefaultFunctionNamespace().c_str());
+    return std::string( theStaticContext->getDefaultFunctionNamespace().c_str() );
   }
 
-zorba::order_empty_mode_t StaticContext::getDefaultOrderForEmptySequences() const
-  { return theStaticContext->getDefaultOrderForEmptySequences(); }
+ZorbaConstants::OrderEmptyMode StaticContext::getDefaultOrderForEmptySequences()
+  { 
+    ZorbaConstants::OrderEmptyMode result = ZorbaConstants::EMPTY_GREATEST;
+    zorba::order_empty_mode_t order = theStaticContext->getDefaultOrderForEmptySequences();
+    if (order == zorba::empty_least) {
+      result = ZorbaConstants::EMPTY_LEAST;
+    }
+    return result;
+  }
 
 std::string StaticContext::getNamespaceURIByPrefix(const std::string &aPrefix) const
   {
-    return std::string(theStaticContext->getNamespaceURIByPrefix(aPrefix).
-                       c_str());
+    return std::string( theStaticContext->getNamespaceURIByPrefix(aPrefix).c_str() );
   }
 
 bool StaticContext::getOption(const Item &aQName, std::string &aOptionValue) const
@@ -98,40 +125,108 @@
     return theStaticContext->getOption(aQName.theItem, optVal); 
   }
 
-zorba::ordering_mode_t StaticContext::getOrderingMode () const
-  { return theStaticContext->getOrderingMode(); }
-
-long StaticContext::getRefCount () const
-  { return theStaticContext->getRefCount(); }
-
-zorba::validation_mode_t StaticContext::getRevalidationMode ()
-  { return theStaticContext->getRevalidationMode(); }
-
-zorba::xpath1_0compatib_mode_t StaticContext::getXPath1_0CompatibMode () const
-  { return theStaticContext->getXPath1_0CompatibMode(); } 
-
-void StaticContext::loadProlog (const std::string & aProlog, 
-                           const CompilerHints &hints)
+ZorbaConstants::OrderingMode StaticContext::getOrderingMode ()
+  { 
+    ZorbaConstants::OrderingMode result = ZorbaConstants::ORDERED;
+    zorba::ordering_mode_t order = theStaticContext->getOrderingMode();
+    if (order == zorba::unordered) {
+      result = ZorbaConstants::UNORDERED;
+    }
+    return result;
+  }
+
+ZorbaConstants::RevalidationMode StaticContext::getRevalidationMode ()
+  { 
+    ZorbaConstants::RevalidationMode result = ZorbaConstants::VALIDATE_SKIP;
+    zorba::validation_mode_t revalidation = theStaticContext->getRevalidationMode();
+    if (revalidation == zorba::validate_lax) {
+      result = ZorbaConstants::VALIDATE_LAX;
+    } else if (revalidation == zorba::validate_strict) {
+      result = ZorbaConstants::VALIDATE_STRICT;
+    }
+    return result;
+  }
+
+ZorbaConstants::XPath1_0CompatibleMode StaticContext::getXPath1_0CompatibMode ()
+  { 
+    ZorbaConstants::XPath1_0CompatibleMode result = ZorbaConstants::XPATH2_0;
+    zorba::xpath1_0compatib_mode_t comp = theStaticContext->getXPath1_0CompatibMode();
+    if (comp == zorba::xpath1_0) {
+      result = ZorbaConstants::XPATH1_0;
+    }
+    return result;
+  }
+
+void StaticContext::loadProlog (const std::string & aProlog, const CompilerHints &hints)
   { theStaticContext->loadProlog( aProlog, hints.theCompilerHints); }
 
-void StaticContext::removeReference ()
-  { theStaticContext->removeReference(); }
-
+void StaticContext::getExternalVariables(Iterator& vars) const 
+  { theStaticContext->getExternalVariables( vars.theIterator ); }
+
+TypeIdentifier StaticContext::getCollectionType(const std::string & aCollectionUri)
+  { return TypeIdentifier(theStaticContext->getCollectionType(aCollectionUri)); }
+  
+TypeIdentifier StaticContext::getDocumentType(const std::string &aDocUri)
+  { return TypeIdentifier(theStaticContext->getDocumentType(aDocUri)); }
+  
+TypeIdentifier StaticContext::getContextItemStaticType()
+  { return TypeIdentifier(theStaticContext->getContextItemStaticType()); }
+
+std::vector< std::pair< std::string, std::string > > StaticContext::getNamespaceBindings () {
+  std::vector< std::pair< zorba::String, zorba::String > > items;
+  std::vector< std::pair< std::string, std::string > > result;
+  theStaticContext->getNamespaceBindings(items);
+  std::vector< std::pair< zorba::String, zorba::String > >::iterator iter;
+  for(iter = items.begin(); iter != items.end(); iter++) {
+    std::pair< std::string, std::string > pair;
+    pair.first = (*iter).first.c_str();
+    pair.second = (*iter).second.c_str();
+    result.push_back(pair);
+  }
+  return result;
+}
+  
+  
+  
+void StaticContext::setContextItemStaticType(const TypeIdentifier &aType)
+  { theStaticContext->setContextItemStaticType(aType.theTypeIdentifier); }
+  
 void StaticContext::resetTraceStream ()
   { theStaticContext->resetTraceStream(); }
 
 bool StaticContext::setBaseURI (const std::string &aBaseURI)
   { return theStaticContext->setBaseURI(aBaseURI); }
 
-bool StaticContext::setBoundarySpacePolicy (zorba::boundary_space_mode_t aMode)
-  { return theStaticContext->setBoundarySpacePolicy(aMode); } 
-
-bool StaticContext::setConstructionMode (zorba::construction_mode_t aMode)
-  { return theStaticContext->setConstructionMode(aMode); } 
-
-bool StaticContext::setCopyNamespacesMode (zorba::preserve_mode_t aPreserve, 
-    zorba::inherit_mode_t aInherit)
-  { return theStaticContext->setCopyNamespacesMode(aPreserve, aInherit); }   
+bool StaticContext::setBoundarySpacePolicy (ZorbaConstants::BoundarySpaceMode aMode)
+  {
+    zorba::boundary_space_mode_t lMode = zorba::strip_space;
+    if (aMode == ZorbaConstants::PRESERVE_SPACE) {
+      lMode = zorba::preserve_space;
+    }
+    return theStaticContext->setBoundarySpacePolicy(lMode);
+  }
+
+bool StaticContext::setConstructionMode (ZorbaConstants::ConstructionMode aMode)
+  {
+    zorba::construction_mode_t lMode = zorba::preserve_cons;
+    if (aMode == ZorbaConstants::STRIP_CONSTRUCTION) {
+      lMode = zorba::strip_cons;
+    }
+    return theStaticContext->setConstructionMode(lMode);
+  }
+
+bool StaticContext::setCopyNamespacesMode (ZorbaConstants::PreserveMode aPreserve, ZorbaConstants::InheritMode aInherit)
+  {
+    zorba::preserve_mode_t lPreserve = zorba::no_preserve_ns;
+    zorba::inherit_mode_t lInherit = zorba::no_inherit_ns;
+    if (aPreserve == ZorbaConstants::PRESERVE) {
+      lPreserve = zorba::preserve_ns;
+    }
+    if (aInherit == ZorbaConstants::INHERIT) {
+      lInherit = zorba::inherit_ns;
+    }
+    return theStaticContext->setCopyNamespacesMode(lPreserve, lInherit);
+  }   
 
 void StaticContext::setDefaultCollation (const std::string &aURI)
   { theStaticContext->setDefaultCollation(aURI); }
@@ -142,17 +237,76 @@
 bool StaticContext::setDefaultFunctionNamespace (const std::string &aURI)
   { return theStaticContext->setDefaultFunctionNamespace(aURI); }
 
-bool StaticContext::setDefaultOrderForEmptySequences (zorba::order_empty_mode_t aMode)
-  { return theStaticContext->setDefaultOrderForEmptySequences(aMode); } 
-
-bool StaticContext::setOrderingMode (zorba::ordering_mode_t aMode)
-  { return theStaticContext->setOrderingMode(aMode); } 
-
-void StaticContext::setRevalidationMode (zorba::validation_mode_t aMode)
-  { return theStaticContext->setRevalidationMode(aMode); } 
-
-bool StaticContext::setXPath1_0CompatibMode (zorba::xpath1_0compatib_mode_t aMode)
-  { return theStaticContext->setXPath1_0CompatibMode(aMode); }
+bool StaticContext::setDefaultOrderForEmptySequences (ZorbaConstants::OrderEmptyMode aMode)
+  {
+    zorba::order_empty_mode_t lMode = zorba::empty_greatest;
+    if (aMode == ZorbaConstants::EMPTY_LEAST) {
+      lMode = zorba::empty_least;
+    }
+    return theStaticContext->setDefaultOrderForEmptySequences(lMode);
+  }
+
+bool StaticContext::setOrderingMode (ZorbaConstants::OrderingMode aMode)
+  {
+    zorba::ordering_mode_t lMode = zorba::ordered;
+    if (aMode == ZorbaConstants::UNORDERED) {
+      lMode = zorba::unordered;
+    }
+    return theStaticContext->setOrderingMode(lMode);
+  }
+
+void StaticContext::setRevalidationMode (ZorbaConstants::RevalidationMode aMode)
+  {
+    zorba::validation_mode_t lMode = zorba::validate_skip;
+    if (aMode == ZorbaConstants::VALIDATE_LAX) {
+      lMode = zorba::validate_lax;
+    } else if (aMode == ZorbaConstants::VALIDATE_STRICT) {
+      lMode = zorba::validate_strict;
+    }
+    return theStaticContext->setRevalidationMode(lMode);
+  }
+
+void StaticContext::setURIPath(std::vector< std::string > &aURIPath )
+  {
+    std::vector< zorba::String > lURIPath;
+    lURIPath.reserve(aURIPath.size());
+    std::vector< std::string >::iterator iter;
+    for(iter = aURIPath.begin(); iter != aURIPath.end(); iter++) {
+      lURIPath.push_back((*iter));
+    }    
+    theStaticContext->setURIPath(lURIPath);
+  }
+
+void StaticContext::setLIBPath(std::vector< std::string > &aLIBPath )
+  {
+    std::vector< zorba::String > lLIBPath;
+    lLIBPath.reserve(aLIBPath.size());
+    std::vector< std::string >::iterator iter;
+    for(iter = aLIBPath.begin(); iter != aLIBPath.end(); iter++) {
+      lLIBPath.push_back((*iter));
+    }    
+    theStaticContext->setLibPath(lLIBPath);
+  }
+
+void StaticContext::setModulePath(std::vector< std::string > &aModulePath )
+  {
+    std::vector< zorba::String > lModulePath;
+    lModulePath.reserve(aModulePath.size());
+    std::vector< std::string >::iterator iter;
+    for(iter = aModulePath.begin(); iter != aModulePath.end(); iter++) {
+      lModulePath.push_back((*iter));
+    }    
+    theStaticContext->setModulePaths(lModulePath);
+  }
+
+bool StaticContext::setXPath1_0CompatibMode (ZorbaConstants::XPath1_0CompatibleMode aMode)
+  {
+    zorba::xpath1_0compatib_mode_t lMode = zorba::xpath2_0;
+    if (aMode == ZorbaConstants::XPATH1_0) {
+      lMode = zorba::xpath1_0;
+    }
+    return theStaticContext->setXPath1_0CompatibMode(lMode);
+  }
 
 void StaticContext::destroy() 
   { theStaticContext = 0; }
@@ -165,7 +319,7 @@
 %}  // end Implementation
 
 
-    // Interface
+// Interface
 
 %rename(XPath1_0CompatibModeEnum) zorba::xpath1_0compatib_mode_t;
 %rename(XPATH2_0) xpath2_0;

=== modified file 'swig/Store.i'
--- swig/Store.i	2012-03-23 17:32:07 +0000
+++ swig/Store.i	2012-03-26 20:16:18 +0000
@@ -15,6 +15,8 @@
  */
 
 %{  // start Implementation
+
+#include <zorba/store_consts.h>
  
 class Store 
 {

=== added file 'swig/TypeIdentifier.h'
--- swig/TypeIdentifier.h	1970-01-01 00:00:00 +0000
+++ swig/TypeIdentifier.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,97 @@
+/*
+ * 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 API_TYPE_IDENTIFIER_H
+#define API_TYPE_IDENTIFIER_H
+
+class IdentTypes {
+public:
+  typedef enum {
+    NAMED_TYPE,
+    ELEMENT_TYPE,
+    ATTRIBUTE_TYPE,
+    DOCUMENT_TYPE,
+    PI_TYPE,
+    TEXT_TYPE,
+    COMMENT_TYPE,
+    ANY_NODE_TYPE,
+    ITEM_TYPE,
+    EMPTY_TYPE,
+    INVALID_TYPE,
+  } Kind;
+
+  typedef enum {
+    QUANT_ONE,
+    QUANT_QUESTION,
+    QUANT_PLUS,
+    QUANT_STAR,
+  } Quantifier;
+};
+
+class TypeIdentifier 
+{
+  friend class StaticContext;
+private:
+  zorba::TypeIdentifier_t theTypeIdentifier;
+  static zorba::IdentTypes::quantifier_t convertQuantifier(IdentTypes::Quantifier quantifier);
+
+public: 
+  TypeIdentifier (const TypeIdentifier& aTypeIdentifier) : theTypeIdentifier(aTypeIdentifier.theTypeIdentifier) {}
+  TypeIdentifier (const zorba::TypeIdentifier_t& aZTypeIdentifier) : theTypeIdentifier(aZTypeIdentifier) {}
+
+  TypeIdentifier getContentType();
+  IdentTypes::Kind getKind();
+  const std::string getLocalName();
+  IdentTypes::Quantifier getQuantifier();
+  long getRefCount();
+  const std::string getUri();
+  bool isLocalNameWildcard();
+  bool isUriWildcard();
+
+  static TypeIdentifier 
+  createAnyNodeType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createAttributeType (const std::string &uri, bool uriWildcard, const std::string &localNameName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createCommentType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createDocumentType (TypeIdentifier contentType, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createElementType (const std::string &uri, bool uriWildcard, const std::string &localName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createEmptyType();
+  
+  static TypeIdentifier 
+  createItemType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createNamedType (const std::string &uri, const std::string &localName, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createPIType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+  static TypeIdentifier 
+  createTextType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
+  
+}; // class TypeIdentifier
+
+
+#endif
\ No newline at end of file

=== added file 'swig/TypeIdentifier.i'
--- swig/TypeIdentifier.i	1970-01-01 00:00:00 +0000
+++ swig/TypeIdentifier.i	2012-03-26 20:16:18 +0000
@@ -0,0 +1,197 @@
+/*
+ * 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.
+ */
+
+%{  // start Implementation
+
+  zorba::IdentTypes::quantifier_t 
+  TypeIdentifier::convertQuantifier(IdentTypes::Quantifier quantifier)
+  {
+    zorba::IdentTypes::quantifier_t result;
+    switch (quantifier) {
+      case IdentTypes::QUANT_ONE:
+        result = zorba::IdentTypes::QUANT_ONE;
+        break;
+      case IdentTypes::QUANT_QUESTION:
+        result = zorba::IdentTypes::QUANT_QUESTION;
+        break;
+      case IdentTypes::QUANT_PLUS:
+        result = zorba::IdentTypes::QUANT_PLUS;
+        break;
+      case IdentTypes::QUANT_STAR:
+        result = zorba::IdentTypes::QUANT_STAR;
+        break;
+    }
+    return result;
+  }
+
+  TypeIdentifier TypeIdentifier::getContentType()
+  {
+    return TypeIdentifier(theTypeIdentifier->getContentType());
+  }
+  IdentTypes::Kind TypeIdentifier::getKind()
+  {
+    zorba::IdentTypes::kind_t lKind = theTypeIdentifier->getKind();
+    IdentTypes::Kind result;
+    switch (lKind) {
+      case zorba::IdentTypes::NAMED_TYPE:
+        result = IdentTypes::NAMED_TYPE;
+        break;
+      case zorba::IdentTypes::ELEMENT_TYPE:
+        result = IdentTypes::ELEMENT_TYPE;
+        break;
+      case zorba::IdentTypes::ATTRIBUTE_TYPE:
+        result = IdentTypes::ATTRIBUTE_TYPE;
+        break;
+      case zorba::IdentTypes::DOCUMENT_TYPE:
+        result = IdentTypes::DOCUMENT_TYPE;
+        break;
+      case zorba::IdentTypes::PI_TYPE:
+        result = IdentTypes::PI_TYPE;
+        break;
+      case zorba::IdentTypes::TEXT_TYPE:
+        result = IdentTypes::TEXT_TYPE;
+        break;
+      case zorba::IdentTypes::COMMENT_TYPE:
+        result = IdentTypes::COMMENT_TYPE;
+        break;
+      case zorba::IdentTypes::ANY_NODE_TYPE:
+        result = IdentTypes::ANY_NODE_TYPE;
+        break;
+      case zorba::IdentTypes::ITEM_TYPE:
+        result = IdentTypes::ITEM_TYPE;
+        break;
+      case zorba::IdentTypes::EMPTY_TYPE:
+        result = IdentTypes::EMPTY_TYPE;
+        break;
+      case zorba::IdentTypes::INVALID_TYPE:
+        result = IdentTypes::INVALID_TYPE;
+        break;
+      default:
+        result = IdentTypes::ANY_NODE_TYPE;
+        break;
+    }
+    return result;
+  }
+  const std::string TypeIdentifier::getLocalName()
+  {
+    return std::string(theTypeIdentifier->getLocalName().c_str());
+  }
+  IdentTypes::Quantifier TypeIdentifier::getQuantifier()
+  {
+    zorba::IdentTypes::quantifier_t lQuantifier = theTypeIdentifier->getQuantifier();
+    IdentTypes::Quantifier result;
+    switch (lQuantifier) {
+      case zorba::IdentTypes::QUANT_ONE:
+        result = IdentTypes::QUANT_ONE;
+        break;
+      case zorba::IdentTypes::QUANT_QUESTION:
+        result = IdentTypes::QUANT_QUESTION;
+        break;
+      case zorba::IdentTypes::QUANT_PLUS:
+        result = IdentTypes::QUANT_PLUS;
+        break;
+      case zorba::IdentTypes::QUANT_STAR:
+        result = IdentTypes::QUANT_STAR;
+        break;
+    }
+    return result;
+  }
+  long TypeIdentifier::getRefCount()
+  {
+    return theTypeIdentifier->getRefCount();
+  }
+  const std::string TypeIdentifier::getUri()
+  {
+    return std::string(theTypeIdentifier->getUri().c_str());
+  }
+  bool TypeIdentifier::isLocalNameWildcard()
+  {
+    return theTypeIdentifier->isLocalNameWildcard();
+  }
+  bool TypeIdentifier::isUriWildcard()
+  {
+    return theTypeIdentifier->isUriWildcard();
+  }
+  
+
+  //  STATIC METHODS
+  TypeIdentifier 
+  TypeIdentifier::createAnyNodeType (IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createAnyNodeType ( convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createAttributeType (const std::string &uri, bool uriWildcard, const std::string &localNameName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createAttributeType( uri, uriWildcard, localNameName, localNameWildcard, contentType.theTypeIdentifier,  convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createCommentType (IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createCommentType ( convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createDocumentType (TypeIdentifier contentType, IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createDocumentType(contentType.theTypeIdentifier, convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createElementType (const std::string &uri, bool uriWildcard, const std::string &localName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createElementType(uri, uriWildcard, localName, localNameWildcard, contentType.theTypeIdentifier, convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier
+  TypeIdentifier::createEmptyType()
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createEmptyType() );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createItemType (IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createItemType( convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createNamedType (const std::string &uri, const std::string &localName, IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createNamedType( uri, localName, convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createPIType (IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createPIType( convertQuantifier(quantifier) ) );
+  }
+
+  TypeIdentifier 
+  TypeIdentifier::createTextType (IdentTypes::Quantifier quantifier)
+  {
+    return TypeIdentifier( zorba::TypeIdentifier::createTextType( convertQuantifier(quantifier) ) );
+  }
+  
+  // END OF STATIC METHODS
+
+
+%}  // end   Implementation
+
+
+%include "TypeIdentifier.h"

=== added file 'swig/XQuery.h'
--- swig/XQuery.h	1970-01-01 00:00:00 +0000
+++ swig/XQuery.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,47 @@
+/*
+ * 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 API_XQUERY_H
+#define API_XQUERY_H
+
+class XQuery 
+{
+private:
+  zorba::XQuery_t theQuery;
+  bool closed;
+
+public:
+  XQuery():closed(false) {}
+  XQuery(const XQuery& aXQuery) : theQuery(aXQuery.theQuery), closed(aXQuery.closed) {}
+  XQuery(zorba::XQuery_t aQuery) : theQuery(aQuery), closed(false) {}
+
+  std::string execute();
+  std::string printPlanAsXML();
+  std::string printPlanAsDOT();
+  void compile (const std::string &aQuery);
+  void compile (const std::string &aQuery, StaticContext &aStaticContext);
+
+#ifdef SWIGPYTHON
+  void executeSAX(SAX2ContentHandlerProxy* contentHandlerProxy);
+#endif
+
+  void destroy();
+  Iterator iterator();
+  DynamicContext getDynamicContext();
+  StaticContext getStaticContext();
+  void getExternalVariables(Iterator& vars) const;
+}; // class XQuery
+
+#endif
\ No newline at end of file

=== modified file 'swig/XQuery.i'
--- swig/XQuery.i	2012-03-23 17:32:07 +0000
+++ swig/XQuery.i	2012-03-26 20:16:18 +0000
@@ -16,332 +16,60 @@
 
 %{  // start Implementation
 
-class Iterator 
-{
-protected:
-  friend class DynamicContext;
-  zorba::Iterator_t theIterator;
-  zorba::Item theItem;
-  bool theConsumed;
-
-public:
-  Iterator() {}
-  Iterator(const Iterator& anIterator)
-    : theIterator(anIterator.theIterator),
-      theItem(anIterator.theItem),
-      theConsumed(false)
-  {}
-
-  Iterator(zorba::Iterator_t anIterator)
-    : theIterator(anIterator),
-      theConsumed(false)
-  {}
-
-  Iterator(zorba::Item& aItem)
-    : theIterator(0),
-      theItem(aItem),
-      theConsumed(false)
-  {}
-
-  void open()
-  {
-    if (theIterator)
-      theIterator->open();
-    theConsumed = false;
-  }
-
-  bool next(Item& aItem);
-
-  void close()
-  {
-    if (theIterator)
-      theIterator->close();
-    theConsumed = true;
-  }
-
-  void destroy()
-  {
-    theIterator = 0;
-  }
-
-}; // class Iterator
-
-
-class Item 
-{
-  friend class Iterator;
-  friend class StaticContext;
-  friend class DocumentManager; 
-  friend class SingletonIterator;
-  friend class DynamicContext;
-  friend class ItemFactory;
-
-private:
-  zorba::Item theItem;
-
-public:
-  Item() {}
-  Item(const Item& aItem) : theItem(aItem.theItem) {}
-  Item(const zorba::Item& aZItem) : theItem(aZItem) {}
-
-  static Item createEmptyItem() 
-  { return Item(); }
-
-  std::string getStringValue() const 
-  { return std::string(theItem.getStringValue().c_str()); }
-  
-  std::string serialize() const 
-  {
-    std::stringstream lStream; 
-    Zorba_SerializerOptions_t lOptions; 
-    zorba::Serializer_t lSerializer = zorba::Serializer::createSerializer(lOptions); 
-    zorba::SingletonItemSequence lSequence(theItem); 
-    lSerializer->serialize(&lSequence, lStream); 
-    return lStream.str();
-  }
-  
-  Iterator getAtomizationValue () const
-  { return Iterator(theItem.getAtomizationValue()); }
-  
-  Iterator getAttributes () const
-  { return Iterator(theItem.getAttributes()); }
-  
-  bool getBooleanValue () const
-  { return theItem.getBooleanValue(); }
-
-  Iterator getChildren () const
-  { return Iterator(theItem.getChildren()); }
-
-  Item getEBV () const
-  { return Item(theItem.getEBV()); }
-
-  int getIntValue () const
-  { return theItem.getIntValue(); }
-  
-  std::string getLocalName () const
-  { return std::string(theItem.getLocalName().c_str()); }
-
-  std::string getNamespace () const
-  { return std::string(theItem.getNamespace().c_str()); }
-
-  bool getNodeName (Item &aNodeName) const
-  { return theItem.getNodeName( aNodeName.theItem ); }
-
-  std::string getPrefix () const
-  { return std::string(theItem.getPrefix().c_str()); }
-
-  Item getType () const
-  { return Item( theItem.getType() ); }
-
-  unsigned int getUnsignedIntValue () const
-  { return theItem.getUnsignedIntValue(); }
-
-  bool isAtomic () const
-  { return theItem.isAtomic(); }
-
-  bool isNaN () const
-  { return theItem.isNaN(); }
-
-  bool isNode () const
-  { return theItem.isNode(); }
-
-  bool isNull () const
-  { return theItem.isNull(); }
-
-  bool isPosOrNegInf () const
-  { return theItem.isPosOrNegInf(); }
-  
-  int getNodeKind () const
-  { return theItem.getNodeKind(); }
-
-}; // class Item
-
-class DynamicContext
-{
-private:
-  zorba::DynamicContext* theContext;
-
-public:
-  DynamicContext()
-    : theContext(0)
-  {
-  }
-
-  DynamicContext(const DynamicContext& aCtx)
-    : theContext(aCtx.theContext)
-  {
-  }
-
-  DynamicContext(zorba::DynamicContext* aCtx)
-    : theContext(aCtx)
-  {
-  }
-
-  void
-  setVariable(
-    const std::string& aNamespace,
-    const std::string& aLocalname,
-    Iterator aIter)
-  {
-    theContext->setVariable(aNamespace, aLocalname, aIter.theIterator);
-  }
-
-  void
-  setContextItem(Item aItem)
-  {
-    theContext->setContextItem(aItem.theItem);
-  }
-};
-
-class XQuery 
-{
-private:
-  zorba::XQuery_t theQuery;
-
-public:
-  XQuery() {}
-  XQuery(const XQuery& aXQuery) : theQuery(aXQuery.theQuery) {}
-  XQuery(zorba::XQuery_t aQuery) : theQuery(aQuery) {}
-
-  std::string execute()
+  std::string XQuery::execute()
   {
     std::stringstream lStream;
     lStream << theQuery;
-    return lStream.str();
+    std::string str = lStream.str();
+    return str;
   }
-
-  void compile (const std::string &aQuery)
+  
+  void XQuery::compile (const std::string &aQuery)
   {
     theQuery->compile(aQuery);
   }
 
-  void compile (const std::string &aQuery, StaticContext &aStaticContext )
+  void XQuery::compile (const std::string &aQuery, StaticContext &aStaticContext )
   {
     Zorba_CompilerHints_t hints;
     theQuery->compile(aQuery, aStaticContext.theStaticContext, hints);
   }
-
-  std::string printPlanAsXML()
+  
+  std::string XQuery::printPlanAsXML()
   {
     std::ostringstream lStream;
     theQuery->printPlan(lStream);
     return lStream.str();
   }
 
-  std::string printPlanAsDOT()
+  std::string XQuery::printPlanAsDOT()
   {
     std::ostringstream lStream;
     theQuery->printPlan(lStream, true);
     return lStream.str();
   }
-
-  DynamicContext
-  getDynamicContext()
+  
+  DynamicContext XQuery::getDynamicContext()
   {
     return DynamicContext(theQuery->getDynamicContext());
   }
 
+  StaticContext XQuery::getStaticContext()
+  {
+    return StaticContext( zorba::StaticContext_t( const_cast<zorba::StaticContext *>(theQuery->getStaticContext()) ) );
+  }
+
+  void XQuery::getExternalVariables(Iterator& vars) const 
+  { theQuery->getExternalVariables( vars.theIterator ); }
+
 #ifdef SWIGPYTHON
-  void executeSAX(SAX2ContentHandlerProxy* contentHandlerProxy)
+  void XQuery::executeSAX(SAX2ContentHandlerProxy* contentHandlerProxy)
   { theQuery->executeSAX(contentHandlerProxy); }
 #endif
 
-  void destroy() { theQuery = 0; }
-  Iterator iterator() { return Iterator(theQuery->iterator()); }
-}; // class XQuery
-
-
-// remaining method definitions from Iterator
-bool
-Iterator::next(Item& aItem)
-{
-  if (theIterator)
-  {
-    return theIterator->next(aItem.theItem);
-  }
-  else
-  {
-    if (!theConsumed)
-    {
-      aItem = theItem;
-      return true;
-    }
-    else
-    {
-      return false;
-    }
-  }
-}
-
+  void XQuery::destroy() { theQuery = 0; }
+  Iterator XQuery::iterator() { return Iterator(theQuery->iterator()); }
 
 %}  // end   Implementation
 
-
-// Interfaces
-
-class DynamicContext
-{
-public:
-  void
-  setVariable(
-    const std::string& aNamespace,
-    const std::string& aLocalname,
-    Iterator);
-
-  void
-  setContextItem(Item);
-};
-
-class Item 
-{
-public: 
-  static Item createEmptyItem();
-  std::string getStringValue() const;
-  std::string serialize() const;
-  Iterator getAtomizationValue () const;
-  Iterator getAttributes () const;
-  bool getBooleanValue () const;
-  Iterator getChildren () const;
-  Item getEBV () const;
-  int getIntValue () const;
-  std::string getLocalName () const;
-  std::string getNamespace () const;
-  bool getNodeName (Item &aNodeName) const;
-  std::string getPrefix () const;
-  Item getType () const;
-  unsigned int getUnsignedIntValue () const;
-
-  int getNodeKind() const;
-  bool isAtomic () const;
-  bool isNaN () const;
-  bool isNode () const;
-  bool isNull () const;
-  bool isPosOrNegInf () const;
-}; // class Item
-
-class Iterator 
-{
-public:
-  void open();
-  bool next(Item&);
-  void close();
-  void destroy();
-}; // class Iterator
-
-class XQuery 
-{
-public:
-  std::string execute();
-  std::string printPlanAsXML();
-  std::string printPlanAsDOT();
-  void compile (const std::string &aQuery);
-  void compile (const std::string &aQuery, StaticContext &aStaticContext);
-
-#ifdef SWIGPYTHON
-  void executeSAX(SAX2ContentHandlerProxy* contentHandlerProxy);
-#endif
-
-  void destroy();
-  Iterator iterator();
-  DynamicContext getDynamicContext();
-}; // class XQuery
+%include "XQuery.h"
\ No newline at end of file

=== added file 'swig/XmlDataManager.h'
--- swig/XmlDataManager.h	1970-01-01 00:00:00 +0000
+++ swig/XmlDataManager.h	2012-03-26 20:16:18 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2006-2012 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 API_XML_DATA_MANAGER_H
+#define API_XML_DATA_MANAGER_H
+
+class XmlDataManager
+{
+private:
+  zorba::XmlDataManager* theManager;
+
+public:
+  XmlDataManager() : theManager(0) {}
+  XmlDataManager(const XmlDataManager& aMgr) : theManager(aMgr.theManager) {}
+  XmlDataManager(zorba::XmlDataManager* aMgr) : theManager(aMgr) {}
+
+  DocumentManager getDocumentManager();
+  CollectionManager getCollectionManager();
+  CollectionManager getW3CCollectionManager();
+  Iterator parseXML(const std::string& aDoc);
+
+};
+#endif
\ No newline at end of file

=== modified file 'swig/XmlDataManager.i'
--- swig/XmlDataManager.i	2012-03-23 17:32:07 +0000
+++ swig/XmlDataManager.i	2012-03-26 20:16:18 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2008 The FLWOR Foundation.
+ * Copyright 2006-2012 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.
@@ -16,54 +16,20 @@
 
 %{  // start Implementation
 
-
-class DocumentManager
-{
-private:
-  zorba::DocumentManager* theManager;
-
-public:
-  DocumentManager() : theManager(0) {}
-  DocumentManager(const DocumentManager& aMgr) : theManager(aMgr.theManager) {}
-  DocumentManager(zorba::DocumentManager* aMgr) : theManager(aMgr) {}
-
-  void put(const std::string& aName, Item aDoc)
-  {
-    theManager->put(aName, aDoc.theItem);
-  }
-
-  void remove(const std::string& aName)
-  {
-    theManager->remove(aName);
-  }
-
-  Item document(const std::string& aName)
-  {
-    return theManager->document(aName);
-  }
-
-  bool isAvailableDocument(const std::string& aName)
-  {
-    return theManager->isAvailableDocument(aName);
-  }
-};
-
-class XmlDataManager
-{
-private:
-  zorba::XmlDataManager* theManager;
-
-public:
-  XmlDataManager() : theManager(0) {}
-  XmlDataManager(const XmlDataManager& aMgr) : theManager(aMgr.theManager) {}
-  XmlDataManager(zorba::XmlDataManager* aMgr) : theManager(aMgr) {}
-
-  DocumentManager getDocumentManager()
+  DocumentManager XmlDataManager::getDocumentManager()
   {
     return DocumentManager(theManager->getDocumentManager()); 
   }
+  CollectionManager XmlDataManager::getCollectionManager()
+  {
+    return CollectionManager(theManager->getCollectionManager()); 
+  }
+  CollectionManager XmlDataManager::getW3CCollectionManager()
+  {
+    return CollectionManager(theManager->getW3CCollectionManager()); 
+  }
 
-  Iterator parseXML(const std::string& aDoc)
+  Iterator XmlDataManager::parseXML(const std::string& aDoc)
   {
     std::stringstream lDoc;
     lDoc << aDoc;
@@ -71,28 +37,7 @@
     return Iterator(lItem);
   }
 
-};
 
 %}  // end   Implementation
 
-class DocumentManager
-{
-public:
-  void put(const std::string& aName, Item aDoc);
-
-  void remove(const std::string& aName);
-
-  Item document(const std::string& aName);
-
-  bool isAvailableDocument(const std::string& aName);
-};
-
-
-class XmlDataManager 
-{
-public:
-  DocumentManager getDocumentManager();
-
-  Iterator parseXML(const std::string& aDoc);
-   
-}; // class XmlDataManager
+%include "XmlDataManager.h"

=== modified file 'swig/Zorba.i'
--- swig/Zorba.i	2012-03-23 17:32:07 +0000
+++ swig/Zorba.i	2012-03-26 20:16:18 +0000
@@ -15,27 +15,26 @@
   {
     return Zorba(zorba::Zorba::getInstance(aStore.getStore()));
   }
-  
   ItemFactory getItemFactory()
   {
     return ItemFactory(theZorba->getItemFactory());
   }
-
+  
   StaticContext createStaticContext()
   {
     return StaticContext(theZorba->createStaticContext());
   }
   
+  XQuery createQuery() 
+  {
+    return XQuery(theZorba->createQuery());
+  }
+
   XQuery compileQuery(const std::string& aStr) 
   {
     return XQuery(theZorba->compileQuery(aStr));
   }
 
-  XQuery createQuery() 
-  {
-    return XQuery(theZorba->createQuery());
-  }
-
   XQuery compileQuery(
     const std::string& aStr,
     StaticContext &aStaticContext )
@@ -47,6 +46,22 @@
       )
     );
   }
+/*
+  XQuery compileQuery(const ZIStreamHelper& aZorbaStream)
+  {
+    zorbabuffer *buffer = new zorbabuffer(&const_cast<ZIStreamHelper &> (aZorbaStream));
+    std::istream stream = std::istream(buffer);
+    //zistream stream = zistream(buffer);
+    return XQuery(theZorba->compileQuery(stream));
+  }
+
+  XQuery compileQuery(const ZIStreamHelper& aZorbaStream, StaticContext &aStaticContext )
+  { 
+    zorbabuffer *buffer = new zorbabuffer(&const_cast<ZIStreamHelper &> (aZorbaStream));
+    std::istream stream = std::istream(buffer);
+    return XQuery(theZorba->compileQuery(stream, aStaticContext.theStaticContext));
+  }
+*/
 
   /*
   //--->> DiagnosticHandler implementations are postponed
@@ -95,6 +110,18 @@
   {
     theZorba->shutdown();
   }
+  std::string getVersion() {
+    return zorba::Zorba::version().getVersion();
+  }
+  int getMajorVersion() {
+    return zorba::Zorba::version().getMajorVersion();
+  }
+  int getMinorVersion() {
+    return zorba::Zorba::version().getMinorVersion();
+  }
+  int getPatchVersion() {
+    return zorba::Zorba::version().getPatchVersion();
+  }
 
 }; // class Zorba
 
@@ -111,8 +138,9 @@
   XQuery createQuery();
   XQuery compileQuery(const std::string& aStr);
   XQuery compileQuery(const std::string& aStr, StaticContext &aStaticContext );
+  //XQuery compileQuery(const ZIStreamHelper& aZorbaStream);
+  //XQuery compileQuery(const ZIStreamHelper& aZorbaStream, StaticContext &aStaticContext );
   ItemFactory getItemFactory();
-  
   /*
   XQuery compileQuery(const std::string& aStr, DiagnosticHandler* aDiagnosticHandler);
   XQuery compileQuery(const std::string& aStr, StaticContext &aStaticContext, 
@@ -122,5 +150,9 @@
   */
   XmlDataManager getXmlDataManager();
   void shutdown();
+  std::string getVersion();
+  int getMajorVersion();
+  int getMinorVersion();
+  int getPatchVersion();
 
 }; // class Zorba

=== modified file 'swig/java/CMakeLists.txt'
--- swig/java/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ swig/java/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -60,8 +60,21 @@
   MESSAGE(STATUS "Java module install path: " ${JAVA_SITEARCH_DIR})
 
   FILE(GLOB JAVA_SWIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/*.java")
-  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../StaticContext.h" "${CMAKE_CURRENT_BINARY_DIR}/StaticContext.h")
-  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemFactory.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemFactory.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../StaticContext.h"  "${CMAKE_CURRENT_BINARY_DIR}/StaticContext.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemFactory.h"    "${CMAKE_CURRENT_BINARY_DIR}/ItemFactory.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Item.h"           "${CMAKE_CURRENT_BINARY_DIR}/Item.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Iterator.h"       "${CMAKE_CURRENT_BINARY_DIR}/Iterator.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XQuery.h"         "${CMAKE_CURRENT_BINARY_DIR}/XQuery.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DynamicContext.h" "${CMAKE_CURRENT_BINARY_DIR}/DynamicContext.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XmlDataManager.h" "${CMAKE_CURRENT_BINARY_DIR}/XmlDataManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../TypeIdentifier.h" "${CMAKE_CURRENT_BINARY_DIR}/TypeIdentifier.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../SerializationOptions.h" "${CMAKE_CURRENT_BINARY_DIR}/SerializationOptions.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Collection.h" "${CMAKE_CURRENT_BINARY_DIR}/Collection.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../CollectionManager.h" "${CMAKE_CURRENT_BINARY_DIR}/CollectionManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DocumentManager.h" "${CMAKE_CURRENT_BINARY_DIR}/DocumentManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemSequence.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemSequence.h" COPYONLY)
+#  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ZInputStream.java"   "${CMAKE_CURRENT_BINARY_DIR}/ZInputStream.java" COPYONLY)
+#  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/zistream.java"       "${CMAKE_CURRENT_BINARY_DIR}/zistream.java" COPYONLY)
 
   IF ( APPLE )
     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${ZORBA_SWIG_LIB_PREFIX}libzorba_api.jnilib DESTINATION ${JAVA_SITEARCH_DIR})

=== modified file 'swig/java/zorba_api.i'
--- swig/java/zorba_api.i	2012-03-23 17:32:07 +0000
+++ swig/java/zorba_api.i	2012-03-26 20:16:18 +0000
@@ -20,5 +20,6 @@
 // don't do a JNI call for constants and enums.
 %javaconst(1);
 
+
+
 %include ../zorba_api.i
-

=== modified file 'swig/php/CMakeLists.txt'
--- swig/php/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ swig/php/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -35,6 +35,8 @@
   ENDIF (APPLE)
 
   IF (WIN32)
+    STRING(REGEX REPLACE "\\\\" "/" PHP5_LIBRARY "${PHP5_LIBRARY}")
+    MESSAGE (STATUS "SWIG PHP: Link library: " ${PHP5_LIBRARY})
     SWIG_LINK_LIBRARIES (zorba_api ${PHP5_LIBRARY})
   ENDIF (WIN32)
 
@@ -47,6 +49,17 @@
 
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../StaticContext.h" "${CMAKE_CURRENT_BINARY_DIR}/StaticContext.h")
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemFactory.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemFactory.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Item.h" "${CMAKE_CURRENT_BINARY_DIR}/Item.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Iterator.h" "${CMAKE_CURRENT_BINARY_DIR}/Iterator.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XQuery.h" "${CMAKE_CURRENT_BINARY_DIR}/XQuery.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DynamicContext.h" "${CMAKE_CURRENT_BINARY_DIR}/DynamicContext.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XmlDataManager.h" "${CMAKE_CURRENT_BINARY_DIR}/XmlDataManager.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../TypeIdentifier.h" "${CMAKE_CURRENT_BINARY_DIR}/TypeIdentifier.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../SerializationOptions.h" "${CMAKE_CURRENT_BINARY_DIR}/SerializationOptions.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Collection.h" "${CMAKE_CURRENT_BINARY_DIR}/Collection.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../CollectionManager.h" "${CMAKE_CURRENT_BINARY_DIR}/CollectionManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DocumentManager.h" "${CMAKE_CURRENT_BINARY_DIR}/DocumentManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemSequence.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemSequence.h" COPYONLY)
 
   # The following fix was added because of the changes in CMake 2.8, which have the
   # result of naming the java binding library "liblibzorba_api.so" instead of "libzorba_api.so"
@@ -84,4 +97,5 @@
         DESTINATION share/php )
     ENDIF (MSVC_IDE)
   ENDIF (NOT WIN32 OR CYGWIN)
+  ADD_SUBDIRECTORY (tests) 
 ENDIF (NOT PHP5_FOUND)

=== added directory 'swig/php/tests'
=== added file 'swig/php/tests/CMakeLists.txt'
--- swig/php/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ swig/php/tests/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -0,0 +1,90 @@
+# Copyright 2006-2011 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.
+MESSAGE(STATUS "Adding tests for PHP Binding")
+
+SET(phpPath ${CMAKE_BINARY_DIR}/swig/php)
+IF (MSVC_IDE)
+  SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php/@CMAKE_BUILD_TYPE@)
+ELSE (MSVC_IDE)
+  SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php)
+ENDIF (MSVC_IDE)
+SET(phpIncludePath ${CMAKE_BINARY_DIR}/swig/php)
+MESSAGE(STATUS "PHP Path:" ${phpPath})
+MESSAGE(STATUS "PHP Extension Path: " ${phpExtensionPath})
+MESSAGE(STATUS "PHP Include Path: " ${phpExtensionPath})
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/php.ini.in ${CMAKE_CURRENT_BINARY_DIR}/php.ini)
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/books.xml ${CMAKE_CURRENT_BINARY_DIR}/books.xml COPYONLY)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/compilerHints.xq ${CMAKE_CURRENT_BINARY_DIR}/compilerHints.xq COPYONLY)
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test01.php ${CMAKE_CURRENT_BINARY_DIR}/test01.php)
+ADD_TEST("php_test01" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test01.php)
+SET_TESTS_PROPERTIES("php_test01" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test02.php ${CMAKE_CURRENT_BINARY_DIR}/test02.php)
+ADD_TEST("php_test02" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test02.php)
+SET_TESTS_PROPERTIES("php_test02" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test03.php ${CMAKE_CURRENT_BINARY_DIR}/test03.php)
+#ADD_TEST("php_test03" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test03.php)
+#SET_TESTS_PROPERTIES("php_test03" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test04.php ${CMAKE_CURRENT_BINARY_DIR}/test04.php)
+ADD_TEST("php_test04" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test04.php)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test04.xq ${CMAKE_CURRENT_BINARY_DIR}/test04.xq COPYONLY)
+SET_TESTS_PROPERTIES("php_test04" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test05.php ${CMAKE_CURRENT_BINARY_DIR}/test05.php)
+ADD_TEST("php_test05" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test05.php)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test05.xq ${CMAKE_CURRENT_BINARY_DIR}/test05.xq COPYONLY)
+SET_TESTS_PROPERTIES("php_test05" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test06.php ${CMAKE_CURRENT_BINARY_DIR}/test06.php)
+ADD_TEST("php_test06" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test06.php)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test06.xq ${CMAKE_CURRENT_BINARY_DIR}/test06.xq COPYONLY)
+SET_TESTS_PROPERTIES("php_test06" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test07.php ${CMAKE_CURRENT_BINARY_DIR}/test07.php)
+ADD_TEST("php_test07" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test07.php)
+SET_TESTS_PROPERTIES("php_test07" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test08.php ${CMAKE_CURRENT_BINARY_DIR}/test08.php)
+ADD_TEST("php_test08" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test08.php)
+SET_TESTS_PROPERTIES("php_test08" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test09.php ${CMAKE_CURRENT_BINARY_DIR}/test09.php)
+#ADD_TEST("php_test09" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test09.php)
+#SET_TESTS_PROPERTIES("php_test09" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test10.php ${CMAKE_CURRENT_BINARY_DIR}/test10.php)
+ADD_TEST("php_test10" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test10.php)
+SET_TESTS_PROPERTIES("php_test10" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test11.php ${CMAKE_CURRENT_BINARY_DIR}/test11.php)
+#ADD_TEST("php_test11" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test11.php)
+#SET_TESTS_PROPERTIES("php_test11" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test12.php ${CMAKE_CURRENT_BINARY_DIR}/test12.php)
+#ADD_TEST("php_test12" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test12.php)
+#SET_TESTS_PROPERTIES("php_test12" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test13.php ${CMAKE_CURRENT_BINARY_DIR}/test13.php)
+#ADD_TEST("php_test13" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test13.php)
+#SET_TESTS_PROPERTIES("php_test13" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test14.php ${CMAKE_CURRENT_BINARY_DIR}/test14.php)
+#ADD_TEST("php_test14" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} test14.php)
+#SET_TESTS_PROPERTIES("php_test14" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+

=== added file 'swig/php/tests/books.xml'
--- swig/php/tests/books.xml	1970-01-01 00:00:00 +0000
+++ swig/php/tests/books.xml	2012-03-26 20:16:18 +0000
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<books>
+  <book>
+    <title>Book 1</title>
+    <author>Author 1</author>
+  </book>
+  <book featured="YES">
+    <title>Book 2</title>
+    <author>Author 2</author>
+  </book>
+</books>

=== added file 'swig/php/tests/compilerHints.xq'
--- swig/php/tests/compilerHints.xq	1970-01-01 00:00:00 +0000
+++ swig/php/tests/compilerHints.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,4 @@
+for tumbling window $w in (2, 4, 6, 8, 10, 12, 14)
+    start at $s when fn:true()
+    only end at $e when $e - $s eq 2
+return avg($w)

=== added file 'swig/php/tests/php.ini.in'
--- swig/php/tests/php.ini.in	1970-01-01 00:00:00 +0000
+++ swig/php/tests/php.ini.in	2012-03-26 20:16:18 +0000
@@ -0,0 +1,3 @@
+enable_dl=On
+extension_dir=@phpExtensionPath@
+include_path=".:@phpIncludePath@"
\ No newline at end of file

=== added file 'swig/php/tests/test01.php'
--- swig/php/tests/test01.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test01.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,29 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+print "Running: Get zorba instance and shutdown\n";
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+print "Success";
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test02.php'
--- swig/php/tests/test02.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test02.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,44 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  $lQuery = $aZorba->compileQuery("(1,2,3,4,5)");
+  $iter = $lQuery->iterator();
+  $iter->open();
+  $item = Item::createEmptyItem();
+  while ($iter->next($item)) {
+    print $item->getStringValue()."\n";
+  }
+  $iter->close();
+  $iter->destroy();
+  return true;
+}
+
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: Compile query string\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test03.php'
--- swig/php/tests/test03.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test03.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,48 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+class MyDiagnosticHandler(DiagnosticHandler handler) {
+  funtion error(self, *args) {
+    print "Error args: ", args;
+  }
+}
+
+function test(Zorba $aZorba)
+{
+  diagnosticHandler = MyDiagnosticHandler()
+  try {
+    xquery = zorba.compileQuery("1 div 0", diagnosticHandler);
+    print xquery.execute()
+  } catch (Exception e) {
+    print "Caught error: ";
+  }
+  return
+}
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: Compile query string using Diagnostic Handler"
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test04.php'
--- swig/php/tests/test04.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test04.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,43 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  #Read and write result
+  $filename = 'test04.xq';
+  print "Executing: $filename\n";
+  $f = fopen($filename, 'r');
+  $contents = fread($f, filesize($filename));
+  fclose($f);
+  $xquery = $aZorba->compileQuery($contents);
+  $result = $xquery->execute();
+  print $result."\n";
+  return;
+}
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test04.xq'
--- swig/php/tests/test04.xq	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test04.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,4 @@
+for tumbling window $w in (2, 4, 6, 8, 10, 12, 14)
+    start at $s when fn:true()
+    only end at $e when $e - $s eq 2
+return avg($w)

=== added file 'swig/php/tests/test05.php'
--- swig/php/tests/test05.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test05.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,43 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  #Read and write result
+  $filename = 'test05.xq';
+  print "Executing: $filename\n";
+  $f = fopen($filename, 'r');
+  $contents = fread($f, filesize($filename));
+  fclose($f);
+  $xquery = $aZorba->compileQuery($contents);
+  $result = $xquery->printPlanAsXML();
+  print $result."\n";
+  return;
+}
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute - printPlanAsXML\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test05.xq'
--- swig/php/tests/test05.xq	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test05.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,7 @@
+for $x in (5,6,7,1,2,3,4)
+where $x < 4
+for $y in (4,9,6,8,2)
+let $z := $x * $y
+where $z > 20
+return
+<value x="{$x}" y="{$y}">{$z}</value>
\ No newline at end of file

=== added file 'swig/php/tests/test06.php'
--- swig/php/tests/test06.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test06.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,43 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  #Read and write result
+  $filename = 'test06.xq';
+  print "Executing: $filename\n";
+  $f = fopen($filename, 'r');
+  $contents = fread($f, filesize($filename));
+  fclose($f);
+  $xquery = $aZorba->compileQuery($contents);
+  $result = $xquery->printPlanAsDOT();
+  print $result."\n";
+  return;
+}
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute - printPlanAsDOT\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test06.xq'
--- swig/php/tests/test06.xq	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test06.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,7 @@
+for $x in (5,6,7,1,2,3,4)
+where $x < 4
+for $y in (4,9,6,8,2)
+let $z := $x * $y
+where $z > 20
+return
+<value x="{$x}" y="{$y}">{$z}</value>
\ No newline at end of file

=== added file 'swig/php/tests/test07.php'
--- swig/php/tests/test07.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test07.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,56 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  $filename = 'books.xml';
+  $f = fopen($filename, 'r');
+  $contents = fread($f, filesize($filename));
+  fclose($f);
+   
+  $dataManager = $aZorba->getXmlDataManager();
+  $docIter = $dataManager->parseXML($contents);
+  $docIter->open(); 
+ 
+  $doc = Item::createEmptyItem();
+  $docIter->next($doc);
+ 
+  $docIter->close();
+  $docIter->destroy();
+ 
+  $docManager = $dataManager->getDocumentManager();
+  $docManager->put("my_fake_books.xml", $doc);
+  $xquery = $aZorba->compileQuery("doc('my_fake_books.xml')");
+   
+  $result = $xquery->execute();
+  print $result."\n";
+ 
+  return;
+}  
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute - parsing XML\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test08.php'
--- swig/php/tests/test08.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test08.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,120 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function println($string) {
+  print $string."\n";
+}
+
+function test(Zorba $aZorba) {
+  #Read and write result 
+  println ("Executing: test08.xq");
+  $lines = '(1, xs:int(2),"bla", <a><b att="{(3, xs:int(4),"foo", "bar")}"/>text<!--a comment--><?pi?></a>)';
+  $xquery = $aZorba->compileQuery($lines);
+  $result = $xquery->execute();
+  println ($result);
+ 
+  println ("Iterator:");
+  $iterator = $xquery->iterator();
+
+  printIterator($iterator, "");
+ 
+  $handle = fopen('test8_result.xml', 'w');
+  fwrite($handle, $result);
+  fclose($handle);
+  return;
+}
+
+function printIterator($iterator, $pre) {
+  $item = Item::createEmptyItem();
+  $iterator->open(); 
+  while ($iterator->next($item)) {
+    printItem($item, $pre);
+  }
+  $iterator->close();
+}
+ 
+function printItem($item, $pre) {
+  if ($item->isAtomic()) {
+    $typeItem = $item->getType();
+    println ($pre . "Leaf Atomic: '" . $item->getStringValue() . "' \ttype:" . $typeItem->getStringValue());
+    return;
+  }
+
+  if ($item->isNode()) {
+    $kind = $item->getNodeKind();
+  
+    if ($kind ==  0) { # anyNode
+      println ($pre . 'Any node');
+      println ($pre . "  Children:");
+      printIterator($item->getChildren() . $pre."    ");
+    }
+    if ($kind ==  1) { # doc
+      println ($pre . 'Doc');
+      println ($pre . "  Children:");
+      printIterator($item->getChildren() . $pre."    ");
+    }
+    if ($kind == 2) { # element
+      $nodeName = Item::createEmptyItem();
+      $item->getNodeName($nodeName);
+      $typeItem = $item->getType();
+      println ($pre . "Start Element: " . $nodeName->getStringValue() . " \ttype:" . $typeItem->getStringValue());
+      println ($pre . "  Attributes:");
+      printIterator($item->getAttributes(), $pre."    ");
+      println ($pre . "  Children:");
+      printIterator($item->getChildren(), $pre."    ");
+      println ($pre . "End  Element: " . $nodeName->getStringValue());
+    }
+    if ($kind == 3) { # attribute
+      $nodeName = Item::createEmptyItem();
+      $item->getNodeName($nodeName);
+      $typeItem = $item->getType();
+      println ($pre . "Attribute: " . $nodeName->getStringValue() . "= '" . $item->getStringValue() . " \ttype:" . $typeItem->getStringValue());
+      println ($pre."  Atomization value:");
+      printIterator($item->getAtomizationValue(), $pre."    ");
+    }
+    if ($kind == 4) { # text
+      $typeItem = $item->getType();
+      println ($pre . "Text: " . $item->getStringValue() . " \ttype:" . $typeItem->getStringValue());
+      println ($pre."  Atomization value:");
+      printIterator($item->getAtomizationValue(), $pre."    ");
+    }
+    if ($kind == 5) { # pi
+      $nodeName = Item::createEmptyItem();
+      $item->getNodeName($nodeName);
+      println ($pre . "Pi: " . $nodeName->getStringValue());
+    }
+    if ($kind == 6) { # comment
+      println ($pre . "Comment: " . $item->getStringValue());
+    }
+  } else {
+    println ($pre."Item not Node, not Atomic");
+  }
+}
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+println ("Running: XQuery execute - Get Iterator and println (info from its items\n");
+test($zorba);
+println ("Success");
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test09.php'
--- swig/php/tests/test09.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test09.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,92 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  $xquery = $aZorba->compileQuery("<a>text-a1<b at1='att1' at2='{1+2}'>text-b1</b>text-a2</a>");
+  
+  
+  $saxHandler = new SAX2ContentHandlerProxy();
+  $saxHandler->setStartDocumentHandler(startDocumentHandler);
+  $saxHandler->setEndDocumentHandler(endDocumentHandler);
+  $saxHandler->setStartElementHandler(startElementHandler);
+  $saxHandler->setEndElementHandler(endElementHandler);
+  $saxHandler->setCharactersHandler(charactersHandler);
+  $saxHandler->setProcessingInstructionHandler(processingInstructionHandler);
+  $saxHandler->setIgnorableWhitespaceHandler(ignorableWhitespaceHandler);
+  $saxHandler->setStartPrefixMappingHandler(startPrefixMappingHandler);
+  $saxHandler->setEndPrefixMappingHandler(endPrefixMappingHandler);
+  $saxHandler->setSkippedEntityHandler(skippedEntityHandler);
+  $xquery->executeSAX($saxHandler);
+
+  return;
+}
+
+function startDocumentHandler() {
+  print "Start Document";
+  return;
+}
+function endDocumentHandler() {
+  print "End Document";
+  return;
+}
+function startElementHandler($URI, $localName, $QName, $SAXAttributes) {
+  print "Start Element - " . $QName;
+  return;
+}
+function endElementHandler($URI, $localName, $QName) {
+  print "End Element - " . $QName;
+  return;
+}
+function charactersHandler($text) {
+  print "Characters - " . $text;
+  return;
+}
+function processingInstructionHandler($target, $data) {
+  print "Processing Instruction";
+  return;
+}
+function ignorableWhitespaceHandler($text) {
+  print "Ignorable Whitespace - " . $text;
+  return;
+}
+function startPrefixMappingHandler($prefix, $URI) {
+  print "Start Prefix Mapping - " . $prefix;
+  return;
+}
+function endPrefixMappingHandler($prefix) {
+  print "End Prefix Mapping - " . $prefix;
+  return;
+}
+function skippedEntityHandler($name) {
+  print "Skipped Entity - " . $name;
+  return;
+}
+
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute - executeSAX\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test10.php'
--- swig/php/tests/test10.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test10.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,55 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
+
+function test(Zorba $aZorba) {
+  $filename = 'books.xml';
+  $f = fopen($filename, 'r');
+  $contents = fread($f, filesize($filename));
+  fclose($f);
+
+  $dataManager = $aZorba->getXmlDataManager();
+  $docIter = $dataManager->parseXML($contents);
+  $docIter->open();
+
+  $doc = Item::createEmptyItem();
+  $docIter->next($doc);
+
+  $docIter->close();
+  $docIter->destroy();
+
+  $xquery = $aZorba->compileQuery(".");
+  $dynCtx = $xquery->getDynamicContext();
+  $dynCtx->setContextItem($doc);
+  print $xquery->execute()."\n";
+  
+  return;
+}
+
+
+$store = InMemoryStore::getInstance();
+$zorba = Zorba::getInstance($store);
+
+print "Running: XQuery execute - Get Iterator and print info from its items\n";
+test($zorba);
+print "Success";
+
+$zorba->shutdown();
+InMemoryStore::shutdown($store);
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test11.php'
--- swig/php/tests/test11.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test11.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,52 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+//require '@phpPath@/Zorba/zorba_api_wrapper.php';
+require 'C:/dev/zapi/build/swig/php/Zorba/zorba_api_wrapper.php';
+
+class MyDiagnosticHandler(zorba_api.DiagnosticHandler): 
+  def error(self, *args):
+    print "Error args: ", args
+
+def test(zorba):
+  #Read and write result
+  print 'Executing: compilerHints.xq'
+  f = open('compilerHints.xq', 'r')
+  lines = f.read()
+  f.close()
+  diagnosticHandler = MyDiagnosticHandler()
+  compilerHints = zorba_api.CompilerHints()
+  compilerHints.setOptimizationLevel(0)
+  xquery = zorba.compileQuery(lines, compilerHints, diagnosticHandler)
+  
+  result = xquery.execute()
+  print result
+  return
+
+
+store = zorba_api.InMemoryStore_getInstance()
+zorba = zorba_api.Zorba_getInstance(store)
+
+print "Running: CompileQuery string + Dignostinc handler + CompilerHint - with optimization 0"
+test(zorba)
+print "Success"
+
+
+zorba.shutdown()
+zorba_api.InMemoryStore_shutdown(store)
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test12.php'
--- swig/php/tests/test12.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test12.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,52 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+//require '@phpPath@/Zorba/zorba_api_wrapper.php';
+require 'C:/dev/zapi/build/swig/php/Zorba/zorba_api_wrapper.php';
+
+class MyDiagnosticHandler(zorba_api.DiagnosticHandler): 
+  def error(self, *args):
+    print "Error args: ", args
+
+def test(zorba):
+  #Read and write result
+  print 'Executing: compilerHints.xq'
+  f = open('compilerHints.xq', 'r')
+  lines = f.read()
+  f.close()
+  diagnosticHandler = MyDiagnosticHandler()
+  compilerHints = zorba_api.CompilerHints()
+  compilerHints.setOptimizationLevel(1)
+  xquery = zorba.compileQuery(lines, compilerHints, diagnosticHandler)
+  
+  result = xquery.execute()
+  print result
+  return
+
+
+store = zorba_api.InMemoryStore_getInstance()
+zorba = zorba_api.Zorba_getInstance(store)
+
+print "Running: CompileQuery string + Dignostinc handler + CompilerHint - with optimization 1"
+test(zorba)
+print "Success"
+
+
+zorba.shutdown()
+zorba_api.InMemoryStore_shutdown(store)
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test13.php'
--- swig/php/tests/test13.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test13.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,53 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+//require '@phpPath@/Zorba/zorba_api_wrapper.php';
+require 'C:/dev/zapi/build/swig/php/Zorba/zorba_api_wrapper.php';
+
+class MyDiagnosticHandler(zorba_api.DiagnosticHandler): 
+  def error(self, *args):
+    print "Error args: ", args
+
+def test(zorba):
+  #Read and write result
+  print 'Executing: compilerHints.xq'
+  f = open('compilerHints.xq', 'r')
+  lines = f.read()
+  f.close()
+  diagnosticHandler = MyDiagnosticHandler()
+  compilerHints = zorba_api.CompilerHints()
+  compilerHints.setLibModule(True)
+  compilerHints.setOptimizationLevel(0)
+  xquery = zorba.compileQuery(lines, compilerHints, diagnosticHandler)
+  
+  result = xquery.execute()
+  print result
+  return
+
+
+store = zorba_api.InMemoryStore_getInstance()
+zorba = zorba_api.Zorba_getInstance(store)
+
+print "Running: CompileQuery string + Dignostinc handler + CompilerHint - with optimization 0 - setLibModule(True)"
+test(zorba)
+print "Success"
+
+
+zorba.shutdown()
+zorba_api.InMemoryStore_shutdown(store)
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/test14.php'
--- swig/php/tests/test14.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/test14.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,53 @@
+<?
+/*
+ * Copyright 2006-2012 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.
+ */
+
+//require '@phpPath@/Zorba/zorba_api_wrapper.php';
+require 'C:/dev/zapi/build/swig/php/Zorba/zorba_api_wrapper.php';
+
+class MyDiagnosticHandler(zorba_api.DiagnosticHandler): 
+  def error(self, *args):
+    print "Error args: ", args
+
+def test(zorba):
+  #Read and write result
+  print 'Executing: compilerHints.xq'
+  f = open('compilerHints.xq', 'r')
+  lines = f.read()
+  f.close()
+  diagnosticHandler = MyDiagnosticHandler()
+  compilerHints = zorba_api.CompilerHints()
+  compilerHints.setLibModule(True)
+  compilerHints.setOptimizationLevel(1)
+  xquery = zorba.compileQuery(lines, compilerHints, diagnosticHandler)
+  
+  result = xquery.execute()
+  print result
+  return
+
+
+store = zorba_api.InMemoryStore_getInstance()
+zorba = zorba_api.Zorba_getInstance(store)
+
+print "Running: CompileQuery string + Dignostinc handler + CompilerHint - with optimization 1 - setLibModule(True)"
+test(zorba)
+print "Success"
+
+
+zorba.shutdown()
+zorba_api.InMemoryStore_shutdown(store)
+
+?>
\ No newline at end of file

=== added file 'swig/php/tests/zorba_api.php'
--- swig/php/tests/zorba_api.php	1970-01-01 00:00:00 +0000
+++ swig/php/tests/zorba_api.php	2012-03-26 20:16:18 +0000
@@ -0,0 +1,178 @@
+<?php
+/*
+ * Copyright 2006-2012 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.
+ */
+
+// Try to load our extension if it's not already loaded.
+if (!extension_loaded("zorba_api")) {
+  if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {
+    if (!dl('zorba_api.dll')) return;
+  } else {
+    // PHP_SHLIB_SUFFIX is available as of PHP 4.3.0, for older PHP assume 'so'.
+    // It gives 'dylib' on MacOS X which is for libraries, modules are 'so'.
+    if (PHP_SHLIB_SUFFIX === 'PHP_SHLIB_SUFFIX' || PHP_SHLIB_SUFFIX === 'dylib') {
+      if (!dl('zorba_api.so')) return;
+    } else {
+      if (!dl('zorba_api.'.PHP_SHLIB_SUFFIX)) return;
+    }
+  }
+}
+
+class Item {
+  public $_cPtr=null;
+
+  static function createEmptyItem() {
+    $r=Item_createEmptyItem();
+    return is_resource($r) ? new Item($r) : $r;
+  }
+
+  function getStringValue() {
+    return Item_getStringValue($this->_cPtr);
+  }
+
+  function __construct() {
+    $this->_cPtr=new_Item();
+  }
+}
+
+class Iterator {
+  public $_cPtr=null;
+
+  function open() {
+    Iterator_open($this->_cPtr);
+  }
+
+  function next($arg1) {
+    return Iterator_next($this->_cPtr,$arg1);
+  }
+
+  function close() {
+    Iterator_close($this->_cPtr);
+  }
+
+  function destroy() {
+    Iterator_destroy($this->_cPtr);
+  }
+
+  function __construct($cPtr) {
+    $this->_cPtr=$cPtr;
+  }
+
+  public function __destruct() {
+    $this->destroy();
+  }
+}
+
+class XQuery {
+  public $_cPtr=null;
+
+  function execute() {
+    return XQuery_execute($this->_cPtr);
+  }
+
+  function isUpdateQuery() {
+    return XQuery_isUpdateQuery($this->_cPtr);
+  }
+
+  function applyUpdates() {
+    XQuery_applyUpdates($this->_cPtr);
+  }
+
+  function destroy() {
+    XQuery_destroy($this->_cPtr);
+  }
+
+  function iterator() {
+    $r=XQuery_iterator($this->_cPtr);
+    return is_resource($r) ? new Iterator($r) : $r;
+  }
+
+  function __construct($cPtr) {
+    $this->_cPtr=$cPtr;
+  }
+
+  function __destruct() {
+    $this->destroy();
+  }
+}
+
+class Store {
+  //public $_cPtr=null;
+
+  //function __construct() {
+  //  $this->_cPtr=new_Store();
+  //}
+}
+
+class InMemoryStore extends Store {
+  public $_cPtr=null;
+
+  static function getInstance() {
+    $r=InMemoryStore_getInstance();
+    return is_resource($r) ? new InMemoryStore($r) : $r;
+  }
+
+  static function shutdown($arg1) {
+    InMemoryStore_shutdown($arg1);
+  }
+
+  private function __construct($cPtr) {
+    $this->_cPtr=$cPtr;
+  }
+}
+
+class XmlDataManager {
+  public $_cPtr=null;
+
+  function loadDocument($aName,$aContent) {
+    XmlDataManager_loadDocument($this->_cPtr,$aName,$aContent);
+  }
+
+  function deleteDocument($aName) {
+    return XmlDataManager_deleteDocument($this->_cPtr,$aName);
+  }
+
+  function __construct($cPtr) {
+    $this->_cPtr=$cPtr;
+  }
+}
+
+class Zorba {
+  public $_cPtr=null;
+
+  static function getInstance($arg1) {
+    $r=Zorba_getInstance($arg1->_cPtr);
+    return is_resource($r) ? new Zorba($r) : $r;
+  }
+
+  function compileQuery($aStr) {
+    $r=Zorba_compileQuery($this->_cPtr,$aStr);
+    return is_resource($r) ? new XQuery($r) : $r;
+  }
+
+  function getXmlDataManager() {
+    $r=Zorba_getXmlDataManager($this->_cPtr);
+    return is_resource($r) ? new XmlDataManager($r) : $r;
+  }
+
+  function shutdown() {
+    Zorba_shutdown($this->_cPtr);
+  }
+
+  private function __construct($cPtr) {
+    $this->_cPtr=$cPtr;
+  }
+}
+?>

=== modified file 'swig/python/CMakeLists.txt'
--- swig/python/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ swig/python/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -20,8 +20,13 @@
   SWIG_ADD_MODULE (zorba_api_python python zorba_api.i)
   SWIG_LINK_LIBRARIES (zorba_api_python zorba_simplestore ${PYTHON_LIBRARIES})
   SET_TARGET_PROPERTIES (_zorba_api_python PROPERTIES OUTPUT_NAME "_zorba_api")
-  SET_PROPERTY( TARGET _zorba_api_python PROPERTY PROJECT_LABEL "Api_Python" )
-
+  
+  IF (MSVC_IDE)
+    SET_PROPERTY( TARGET _zorba_api_python PROPERTY PROJECT_LABEL "Api_Python" )
+    SET_PROPERTY( TARGET _zorba_api_python PROPERTY LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/swig/python )
+    SET_PROPERTY( TARGET _zorba_api_python PROPERTY LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/swig/python )
+  ENDIF (MSVC_IDE)
+  
   EXECUTE_PROCESS (
     COMMAND ${PYTHON_EXECUTABLE} -c "from distutils import sysconfig;print sysconfig.get_python_lib(0)"
     OUTPUT_VARIABLE PYTHON_INSTALL_PATH
@@ -31,6 +36,18 @@
   SET (PYTHON_INSTALL_PATH "${CMAKE_INSTALL_PREFIX}/share/python")
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../StaticContext.h" "${CMAKE_CURRENT_BINARY_DIR}/StaticContext.h")
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemFactory.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemFactory.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Item.h" "${CMAKE_CURRENT_BINARY_DIR}/Item.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Iterator.h" "${CMAKE_CURRENT_BINARY_DIR}/Iterator.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XQuery.h" "${CMAKE_CURRENT_BINARY_DIR}/XQuery.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DynamicContext.h" "${CMAKE_CURRENT_BINARY_DIR}/DynamicContext.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XmlDataManager.h" "${CMAKE_CURRENT_BINARY_DIR}/XmlDataManager.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../TypeIdentifier.h" "${CMAKE_CURRENT_BINARY_DIR}/TypeIdentifier.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../SerializationOptions.h" "${CMAKE_CURRENT_BINARY_DIR}/SerializationOptions.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Collection.h" "${CMAKE_CURRENT_BINARY_DIR}/Collection.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../CollectionManager.h" "${CMAKE_CURRENT_BINARY_DIR}/CollectionManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DocumentManager.h" "${CMAKE_CURRENT_BINARY_DIR}/DocumentManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemSequence.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemSequence.h" COPYONLY)
+
   MESSAGE (STATUS "SWIG Python: Python module install path: " ${PYTHON_INSTALL_PATH})
 
   IF (NOT WIN32)   
@@ -41,17 +58,10 @@
       DESTINATION ${PYTHON_INSTALL_PATH}
     )
   ELSE(NOT WIN32)
-    IF (MSVC_IDE)
-      INSTALL ( FILES 
-      ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/_zorba_api.pyd
-      DESTINATION share/python
-      COMPONENT "python_swig" )
-    ELSE (MSVC_IDE)
       INSTALL ( FILES 
       ${CMAKE_CURRENT_BINARY_DIR}/_zorba_api.pyd
       DESTINATION share/python
       COMPONENT "python_swig" )
-    ENDIF (MSVC_IDE)
   ENDIF(NOT WIN32)
   
   ADD_SUBDIRECTORY (tests)

=== modified file 'swig/ruby/CMakeLists.txt'
--- swig/ruby/CMakeLists.txt	2012-03-23 17:32:07 +0000
+++ swig/ruby/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -23,8 +23,9 @@
   IF (WIN32)
     SWIG_ADD_MODULE(zorba_api_ruby ruby zorba_api.i)
     SWIG_LINK_LIBRARIES(zorba_api_ruby zorba_simplestore ${RUBY_LIBRARY})
-    SET_TARGET_PROPERTIES (zorba_api_ruby PROPERTIES OUTPUT_NAME "zorba_api")
+    SET_TARGET_PROPERTIES( zorba_api_ruby PROPERTIES OUTPUT_NAME "zorba_api")
     SET_TARGET_PROPERTIES( zorba_api_ruby PROPERTIES PROJECT_LABEL "Api_Ruby" )
+    SET_TARGET_PROPERTIES( zorba_api_ruby PROPERTIES SUFFIX ".so" )
   ELSE (WIN32)
     SWIG_ADD_MODULE(zorba_api ruby zorba_api.i)
     SWIG_LINK_LIBRARIES(zorba_api zorba_simplestore ${RUBY_LIBRARY})
@@ -52,7 +53,18 @@
   #STRING(REPLACE "/usr/" "" RUBY_SITEARCH_DIR "${RUBY_SITEARCH_DIR}" )
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../StaticContext.h" "${CMAKE_CURRENT_BINARY_DIR}/StaticContext.h")
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemFactory.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemFactory.h")
-  
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Item.h" "${CMAKE_CURRENT_BINARY_DIR}/Item.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Iterator.h" "${CMAKE_CURRENT_BINARY_DIR}/Iterator.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XQuery.h" "${CMAKE_CURRENT_BINARY_DIR}/XQuery.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DynamicContext.h" "${CMAKE_CURRENT_BINARY_DIR}/DynamicContext.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../XmlDataManager.h" "${CMAKE_CURRENT_BINARY_DIR}/XmlDataManager.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../TypeIdentifier.h" "${CMAKE_CURRENT_BINARY_DIR}/TypeIdentifier.h")
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../SerializationOptions.h" "${CMAKE_CURRENT_BINARY_DIR}/SerializationOptions.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../Collection.h" "${CMAKE_CURRENT_BINARY_DIR}/Collection.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../CollectionManager.h" "${CMAKE_CURRENT_BINARY_DIR}/CollectionManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../DocumentManager.h" "${CMAKE_CURRENT_BINARY_DIR}/DocumentManager.h" COPYONLY)
+  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/../ItemSequence.h" "${CMAKE_CURRENT_BINARY_DIR}/ItemSequence.h" COPYONLY)
+
   SET (RUBY_SITEARCH_DIR "${CMAKE_INSTALL_PREFIX}/share/ruby")
   
   IF ( APPLE )
@@ -77,6 +89,8 @@
     ENDIF ( LINUX )
   ENDIF ( APPLE )
 
+  ADD_SUBDIRECTORY (tests)
+
 ELSE (RUBY_LIBRARY AND RUBY_INCLUDE_PATH)
   MESSAGE(STATUS "SWIG Ruby: binding not generated because library and include files are not installed.")
 ENDIF (RUBY_LIBRARY AND RUBY_INCLUDE_PATH)

=== added directory 'swig/ruby/tests'
=== added file 'swig/ruby/tests/CMakeLists.txt'
--- swig/ruby/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/CMakeLists.txt	2012-03-26 20:16:18 +0000
@@ -0,0 +1,83 @@
+# Copyright 2006-2011 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.
+MESSAGE(STATUS "Adding tests for Ruby Binding")
+
+IF (MSVC_IDE)
+  SET(rubyPath ${CMAKE_BINARY_DIR}/swig/ruby/@CMAKE_BUILD_TYPE@)
+ELSE (MSVC_IDE)
+  SET(rubyPath ${CMAKE_BINARY_DIR}/swig/ruby)
+ENDIF (MSVC_IDE)
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/books.xml ${CMAKE_CURRENT_BINARY_DIR}/books.xml COPYONLY)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/compilerHints.xq ${CMAKE_CURRENT_BINARY_DIR}/compilerHints.xq COPYONLY)
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test01.rb ${CMAKE_CURRENT_BINARY_DIR}/test01.rb)
+ADD_TEST("ruby_test01" ${RUBY_EXECUTABLE} test01.rb)
+SET_TESTS_PROPERTIES("ruby_test01" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test02.rb ${CMAKE_CURRENT_BINARY_DIR}/test02.rb)
+ADD_TEST("ruby_test02" ${RUBY_EXECUTABLE} test02.rb)
+SET_TESTS_PROPERTIES("ruby_test02" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test03.rb ${CMAKE_CURRENT_BINARY_DIR}/test03.rb)
+#ADD_TEST("ruby_test03" ${RUBY_EXECUTABLE} test03.rb)
+#SET_TESTS_PROPERTIES("ruby_test03" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test04.rb ${CMAKE_CURRENT_BINARY_DIR}/test04.rb)
+ADD_TEST("ruby_test04" ${RUBY_EXECUTABLE} test04.rb)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test04.xq ${CMAKE_CURRENT_BINARY_DIR}/test04.xq COPYONLY)
+SET_TESTS_PROPERTIES("ruby_test04" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test05.rb ${CMAKE_CURRENT_BINARY_DIR}/test05.rb)
+ADD_TEST("ruby_test05" ${RUBY_EXECUTABLE} test05.rb)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test05.xq ${CMAKE_CURRENT_BINARY_DIR}/test05.xq COPYONLY)
+SET_TESTS_PROPERTIES("ruby_test05" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test06.rb ${CMAKE_CURRENT_BINARY_DIR}/test06.rb)
+ADD_TEST("ruby_test06" ${RUBY_EXECUTABLE} test06.rb)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test06.xq ${CMAKE_CURRENT_BINARY_DIR}/test06.xq COPYONLY)
+SET_TESTS_PROPERTIES("ruby_test06" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test07.rb ${CMAKE_CURRENT_BINARY_DIR}/test07.rb)
+ADD_TEST("ruby_test07" ${RUBY_EXECUTABLE} test07.rb)
+SET_TESTS_PROPERTIES("ruby_test07" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+# CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test08.rb ${CMAKE_CURRENT_BINARY_DIR}/test08.rb)
+# ADD_TEST("ruby_test08" ${RUBY_EXECUTABLE} test08.rb)
+# SET_TESTS_PROPERTIES("ruby_test08" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+# CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test09.rb ${CMAKE_CURRENT_BINARY_DIR}/test09.rb)
+# ADD_TEST("ruby_test09" ${RUBY_EXECUTABLE} test09.rb)
+# SET_TESTS_PROPERTIES("ruby_test09" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test10.rb ${CMAKE_CURRENT_BINARY_DIR}/test10.rb)
+ADD_TEST("ruby_test10" ${RUBY_EXECUTABLE} test10.rb)
+SET_TESTS_PROPERTIES("ruby_test10" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test11.rb ${CMAKE_CURRENT_BINARY_DIR}/test11.rb)
+#ADD_TEST("ruby_test11" ${RUBY_EXECUTABLE} test11.rb)
+#SET_TESTS_PROPERTIES("ruby_test11" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test12.rb ${CMAKE_CURRENT_BINARY_DIR}/test12.rb)
+#ADD_TEST("ruby_test12" ${RUBY_EXECUTABLE} test12.rb)
+#SET_TESTS_PROPERTIES("ruby_test12" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test13.rb ${CMAKE_CURRENT_BINARY_DIR}/test13.rb)
+#ADD_TEST("ruby_test13" ${RUBY_EXECUTABLE} test13.rb)
+#SET_TESTS_PROPERTIES("ruby_test13" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test14.rb ${CMAKE_CURRENT_BINARY_DIR}/test14.rb)
+#ADD_TEST("ruby_test14" ${RUBY_EXECUTABLE} test14.rb)
+#SET_TESTS_PROPERTIES("ruby_test14" PROPERTIES PASS_REGULAR_EXPRESSION "Success")
+

=== added file 'swig/ruby/tests/books.xml'
--- swig/ruby/tests/books.xml	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/books.xml	2012-03-26 20:16:18 +0000
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<books>
+  <book>
+    <title>Book 1</title>
+    <author>Author 1</author>
+  </book>
+  <book featured="YES">
+    <title>Book 2</title>
+    <author>Author 2</author>
+  </book>
+</books>

=== added file 'swig/ruby/tests/compilerHints.xq'
--- swig/ruby/tests/compilerHints.xq	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/compilerHints.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,4 @@
+for tumbling window $w in (2, 4, 6, 8, 10, 12, 14)
+    start at $s when fn:true()
+    only end at $e when $e - $s eq 2
+return avg($w)

=== added file 'swig/ruby/tests/test01.rb'
--- swig/ruby/tests/test01.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test01.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,24 @@
+# Copyright 2006-2012 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.
+
+require '@rubyPath@/zorba_api'
+
+print "Running: Get zorba instance and shutdown"
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)
+
+print "Success"

=== added file 'swig/ruby/tests/test02.rb'
--- swig/ruby/tests/test02.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test02.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,39 @@
+# Copyright 2006-2012 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  xquery = zorba.compileQuery("(1,2,3,4,5)")
+  iter = xquery.iterator()
+  iter.open()
+  item = Zorba_api::Item.createEmptyItem()
+  while iter.next(item) do
+    print item.getStringValue()
+    print "\n"
+  end
+  iter.close()
+  iter.destroy()
+  xquery.destroy()
+end
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: Compile query string"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test03.rb'
--- swig/ruby/tests/test03.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test03.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,43 @@
+# Copyright 2006-2012 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.
+
+require '@rubyPath@/zorba_api'
+
+class MyDiagnosticHandler < Zorba_api.DiagnosticHandler
+  def error(self, *args)
+    print "Error args: " + args
+  end
+end
+
+def test(zorba):
+  diagnosticHandler = MyDiagnosticHandler.new
+  begin
+    xquery = zorba.compileQuery("1 div 0", diagnosticHandler)
+    print xquery.execute()
+  rescue => e
+    print "Caught error: " + e.message
+  ensure
+    xquery.destroy()
+  end
+end
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: Capturing error with DiagnosticHandler"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test04.rb'
--- swig/ruby/tests/test04.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test04.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,35 @@
+# Copyright 2006-2012 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  print 'Executing: test04.xq'
+  file = File.open("test04.xq", "rb")
+  contents = file.read
+  xquery = zorba.compileQuery(contents)
+  result = xquery.execute()
+  print result
+  xquery.destroy()
+end
+  
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test04.xq'
--- swig/ruby/tests/test04.xq	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test04.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,4 @@
+for tumbling window $w in (2, 4, 6, 8, 10, 12, 14)
+    start at $s when fn:true()
+    only end at $e when $e - $s eq 2
+return avg($w)

=== added file 'swig/ruby/tests/test05.rb'
--- swig/ruby/tests/test05.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test05.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,35 @@
+# Copyright 2006-2011 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  print 'Executing: test05.xq'
+  file = File.open("test05.xq", "rb")
+  contents = file.read
+  xquery = zorba.compileQuery(contents)
+  result = xquery.printPlanAsXML()
+  print result
+  xquery.destroy()
+end
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute - printPlanAsXML"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test05.xq'
--- swig/ruby/tests/test05.xq	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test05.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,7 @@
+for $x in (5,6,7,1,2,3,4)
+where $x < 4
+for $y in (4,9,6,8,2)
+let $z := $x * $y
+where $z > 20
+return
+<value x="{$x}" y="{$y}">{$z}</value>
\ No newline at end of file

=== added file 'swig/ruby/tests/test06.rb'
--- swig/ruby/tests/test06.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test06.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,35 @@
+# Copyright 2006-2011 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  print 'Executing: test06.xq'
+  file = File.open("test06.xq", "rb")
+  contents = file.read
+  xquery = zorba.compileQuery(contents)
+  result = xquery.printPlanAsDOT()
+  print result
+  xquery.destroy()
+end
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute - printPlanAsDOT"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test06.xq'
--- swig/ruby/tests/test06.xq	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test06.xq	2012-03-26 20:16:18 +0000
@@ -0,0 +1,7 @@
+for $x in (5,6,7,1,2,3,4)
+where $x < 4
+for $y in (4,9,6,8,2)
+let $z := $x * $y
+where $z > 20
+return
+<value x="{$x}" y="{$y}">{$z}</value>
\ No newline at end of file

=== added file 'swig/ruby/tests/test07.rb'
--- swig/ruby/tests/test07.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test07.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,48 @@
+# Copyright 2006-2011 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  file = File.open("books.xml", "rb")
+  contents = file.read
+
+  dataManager = zorba.getXmlDataManager()
+  docIter = dataManager.parseXML(contents)
+  docIter.open()
+
+  doc = Zorba_api::Item.createEmptyItem()
+  docIter.next(doc)
+
+  docIter.close()
+  docIter.destroy()
+ 
+  docManager = dataManager.getDocumentManager()
+  docManager.put("my_fake_books.xml", doc)
+  xquery = zorba.compileQuery("doc('my_fake_books.xml')")
+
+  result = xquery.execute()
+  print result
+  xquery.destroy()
+end 
+  
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute - parsing XML"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test08.rb'
--- swig/ruby/tests/test08.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test08.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,108 @@
+# Copyright 2006-2011 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.
+
+require '@rubyPath@/zorba_api'
+ 
+def test(zorba)
+  print 'Executing: test08.xq'  + "\n"
+  lines = '(1, xs:int(2),"bla", <a><b att="{(3, xs:int(4),"foo", "bar")}"/>text<!--a comment--><?pi?></a>)' 
+  xquery = zorba.compileQuery(lines) 
+  result = xquery.execute() 
+  print result  + "\n"
+ 
+  print "Iterator:"  + "\n"
+  iterator = xquery.iterator() 
+  printIterator(iterator, "")
+  xquery.destroy()
+  
+end
+
+
+def printIterator(iterator, pre)
+  item = Zorba_api::Item.createEmptyItem()
+  iterator.open() 
+  while iterator.next(item)
+    printItem(item, pre)
+  end
+  iterator.close()
+  iterator.destroy()
+end
+ 
+def printItem(item, pre)
+  if item.isAtomic():
+    typeItem = item.getType()
+    print pre + "Leaf Atomic: '" + item.getStringValue() + "' \ttype:", typeItem.getStringValue() + "\n"
+    return
+  end
+  
+  if item.isNode():
+    kind = item.getNodeKind()
+  
+    if kind ==  0 # anyNode
+      print pre + 'Any node' + "\n"
+      print pre + "  Children:" + "\n"
+      printIterator(item.getChildren(), pre+"    ")
+    end
+    if kind ==  1 # doc
+      print pre + 'Doc' + "\n"
+      print pre + "  Children:" + "\n"
+      printIterator(item.getChildren(), pre+"    ")
+    end
+    if kind == 2 # element
+      nodeName = Zorba_api::Item.createEmptyItem()
+      item.getNodeName(nodeName)
+      typeItem = item.getType()              
+      print pre + "Start Element: ", nodeName.getStringValue() + " \ttype:", typeItem.getStringValue() + "\n"
+      print pre + "  Attributes:" + "\n"
+      printIterator(item.getAttributes(), pre+"    ")
+      print pre + "  Children:" + "\n"
+      printIterator(item.getChildren(), pre+"    ")
+      print pre + "End  Element: " + nodeName.getStringValue() + "\n"
+    end
+    if kind == 3 # attribute
+      nodeName = Zorba_api::Item.createEmptyItem()
+      item.getNodeName(nodeName)
+      typeItem = item.getType()              
+      print pre + "Attribute: " + nodeName.getStringValue() + "= '" + item.getStringValue() + "'"" \ttype:" + typeItem.getStringValue() + "\n"
+      print pre+"  Atomization value:" + "\n"
+      printIterator(item.getAtomizationValue(), pre+"    ")
+    end
+    if kind == 4 # text
+      typeItem = item.getType()              
+      print pre + "Text: " + item.getStringValue() + " \ttype:", typeItem.getStringValue() + "\n"
+      print pre+"  Atomization value:" + "\n"
+      printIterator(item.getAtomizationValue(), pre+"    ")
+    end
+    if kind == 5 # pi
+      nodeName = Zorba_api::Item.createEmptyItem()
+      item.getNodeName(nodeName)
+      print pre + "Pi: " + nodeName.getStringValue() + "\n"
+    end
+    if kind == 6 # comment
+      print pre + "Comment: " + item.getStringValue() + "\n"
+    end
+  else
+    print pre+"Item not Node, not Atomic" + "\n"
+  end
+end
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute - Get Iterator and print info from its items"  + "\n"
+test(zorba)
+print "Success" + "\n"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test09.rb'
--- swig/ruby/tests/test09.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test09.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,81 @@
+# Copyright 2006-2011 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.
+
+import sys
+sys.path.insert(0, '@pythonPath@')
+import zorba_api
+
+
+def test(zorba)
+  xquery = zorba.compileQuery("<a>text-a1<b at1='att1' at2='{1+2}'>text-b1</b>text-a2</a>") 
+   
+  saxHandler = zorba_api.SAX2ContentHandlerProxy()
+  saxHandler.setStartDocumentHandler(startDocumentHandler);
+  saxHandler.setEndDocumentHandler(endDocumentHandler);
+  saxHandler.setStartElementHandler(startElementHandler);
+  saxHandler.setEndElementHandler(endElementHandler);
+  saxHandler.setCharactersHandler(charactersHandler);
+  saxHandler.setProcessingInstructionHandler(processingInstructionHandler);
+  saxHandler.setIgnorableWhitespaceHandler(ignorableWhitespaceHandler);
+  saxHandler.setStartPrefixMappingHandler(startPrefixMappingHandler);
+  saxHandler.setEndPrefixMappingHandler(endPrefixMappingHandler);
+  saxHandler.setSkippedEntityHandler(skippedEntityHandler);
+  xquery.executeSAX(saxHandler)
+
+  return
+
+
+def startDocumentHandler():
+  print "Start Document"
+  return
+def endDocumentHandler():
+  print "End Document"
+  return
+def startElementHandler(URI, localName, QName, SAXAttributes):
+  print "Start Element - ", QName
+  return
+def endElementHandler(URI, localName, QName):
+  print "End Element - ", QName
+  return
+def charactersHandler(text):
+  print "Characters - ", text
+  return
+def processingInstructionHandler(target, data):
+  print "Processing Instruction"
+  return
+def ignorableWhitespaceHandler(text):
+  print "Ignorable Whitespace - ", text
+  return
+def startPrefixMappingHandler(prefix, URI):
+  print "Start Prefix Mapping - ", prefix
+  return
+def endPrefixMappingHandler(prefix):
+  print "End Prefix Mapping - ", prefix
+  return
+def skippedEntityHandler(name):
+  print "Skipped Entity - ", name
+  return
+
+
+store = zorba_api.InMemoryStore_getInstance()
+zorba = zorba_api.Zorba_getInstance(store)
+
+print "Running: XQuery execute - executeSAX"
+test(zorba)
+print "Success"
+
+
+zorba.shutdown()
+zorba_api.InMemoryStore_shutdown(store)
+

=== added file 'swig/ruby/tests/test10.rb'
--- swig/ruby/tests/test10.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test10.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,46 @@
+# Copyright 2006-2011 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.
+
+require '@rubyPath@/zorba_api'
+
+def test(zorba)
+  file = File.open("books.xml", "rb")
+  contents = file.read
+
+  dataManager = zorba.getXmlDataManager()
+  docIter = dataManager.parseXML(contents)
+  docIter.open();
+
+  doc = Zorba_api::Item.createEmptyItem()
+  docIter.next(doc)
+
+  docIter.close()
+  docIter.destroy()
+
+  xquery = zorba.compileQuery(".")
+  dynCtx = xquery.getDynamicContext()
+  dynCtx.setContextItem(doc)
+  print xquery.execute()
+  xquery.destroy()
+end  
+
+store = Zorba_api::InMemoryStore.getInstance()
+zorba = Zorba_api::Zorba.getInstance(store)
+
+print "Running: XQuery execute - Get Iterator and print info from its items"
+test(zorba)
+print "Success"
+
+zorba.shutdown()
+Zorba_api::InMemoryStore.shutdown(store)

=== added file 'swig/ruby/tests/test11.rb'
--- swig/ruby/tests/test11.rb	1970-01-01 00:00:00 +0000
+++ swig/ruby/tests/test11.rb	2012-03-26 20:16:18 +0000
@@ -0,0 +1,49 @@
+# Copyright 2006-2011 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");