Index: main/trunk/greenstone2/runtime-src/src/corba/Makefile.in
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/Makefile.in	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/Makefile.in	(revision 25231)
@@ -39,5 +39,5 @@
 ENABLE_ACCENTFOLD = @ENABLE_ACCENTFOLD@
 ifeq ($(ENABLE_ACCENTFOLD), 1)
-ACCENTFOLD_LIBS = $(INDEXERS_DIR)/packages/unac/libunac.a 
+ACCENTFOLD_LIBS = $(INDEXERS_DIR)/packages/unac/libunac.a $(COMMON_PACKAGES_DIR)/iconv/lib/libiconv.a
 else
 ACCENTFOLD_LIBS = 
@@ -49,6 +49,8 @@
 MG_INDEXERS_LIBS = $(INDEXERS_DIR)/mg/src/text/libmgtext.a \
 	$(INDEXERS_DIR)/mg/lib/libmglib.a
+MG_INCLUDES = -I$(INDEXERS_DIR)/mg/lib
 else
 MG_INDEXERS_LIBS =
+MG_INCLUDES =
 endif
 
@@ -57,5 +59,5 @@
 MGPP_INDEXERS_LIBS = $(INDEXERS_DIR)/mgpp/text/libmgpptext.a \
 	$(INDEXERS_DIR)/mgpp/lib/libmgpplib.a
-MGPP_INCLUDES = -I$(INDEXERS_DIR)/mgpp/text 
+MGPP_INCLUDES = -I$(INDEXERS_DIR)/mgpp/text -I$(INDEXERS_DIR)/mgpp/lib
 else
 MGPP_INDEXERS_LIBS =
@@ -89,8 +91,8 @@
 MICO_VER = @MICO_VER@
 ifeq ($(MICO_DIR), default)
-MICO_INCLUDES = -I$(RUNTIME_PACKAGES_DIR)/mico/mico/include
+MICO_INCLUDES = -I. -I$(RUNTIME_PACKAGES_DIR)/mico/mico/include
 MICO_PATH = $(RUNTIME_PACKAGES_DIR)/mico/bin/
 else
-MICO_INCLUDES = -I$(MICO_DIR)
+MICO_INCLUDES = -I. -I$(MICO_DIR)
 MICO_PATH =
 endif
@@ -100,7 +102,8 @@
 AR = ar
 CC = @CC@
-CFLAGS = @CFLAGS@
+CFLAGS = -I. @CFLAGS@
+CXXFLAGS = -I. @CXXFLAGS@
 DEFS = @DEFS@ -DNZDL -DQUIET -DSHORT_SUFFIX -DPARADOCNUM -DGSDLSERVER $(GDBM_DEFINES) $(JDBM_DEFINES) $(SQLITE_DEFINES)
-INCLUDES = -I$(COMMON_DIR)/src/lib -I$(COLSERVR_DIR) -I$(PROTOCOL_DIR) -I$(RECPT_DIR) $(MGPP_INCLUDES) \
+INCLUDES = -I$(COMMON_DIR)/src/lib -I$(COLSERVR_DIR) -I$(PROTOCOL_DIR) -I$(RECPT_DIR) $(MG_INCLUDES) $(MGPP_INCLUDES) \
 	$(MICO_INCLUDES)
 INSTALL = @INSTALL@
@@ -123,14 +126,14 @@
 	corbaconv_text_t.mpp \
 	corbaiface.mpp \
-	corbaiface_skel.mpp \
 	corbaproto.mpp \
 	corbatext_t.mpp
+#	corbaiface_skel.mpp \
 
 OBJECTS = \
 	corbaconv_text_t.o \
 	corbaiface.o \
-	corbaiface_skel.o \
 	corbaproto.o \
 	corbatext_t.o
+#	corbaiface_skel.o \
 
 CORBASERVER_OBJECTS = \
@@ -174,4 +177,8 @@
 
 install:
+# We're in a linux makefile, so we know what the GSDLOS is if this
+# Makefile is run:
+	cp corbaserver ../../../cgi-bin/linux/.
+	if test -e corbarecptldd; then cp corbarecptldd ../../../cgi-bin/linux/.; fi
 
 clean:
@@ -185,4 +192,13 @@
 endif
 
+corbaiface.h corbaiface.mpp: corbaiface.idl
+
+# Because sequential commands are independent (each line seems to be run in its own shell),
+# need to set the path env vars and run the IDL command in the same cmd, so it remembers
+# the env vars when running the idl executable
+# (NOTE: In the past, before BOA changed to POA in corba code, skeleton files were
+# required. If needed again, generate them with the --c++-skel option to idl.)
+	export PATH=$(RUNTIME_PACKAGES_DIR)/mico/bin:${PATH};export LD_LIBRARY_PATH=$(RUNTIME_PACKAGES_DIR)/mico/lib:${LD_LIBRARY_PATH};idl --c++-suffix mpp corbaiface.idl;
+
 # Want to do distclean regardless of whether or not been compiled
 # distclean needs to get rid of anything produced by ./configure such
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaServer.mpp
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaServer.mpp	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaServer.mpp	(revision 25231)
@@ -1,5 +1,7 @@
+#define USE_POA
+
 // Standard headers
-#include <iostream.h>
-#include <fstream.h>
+#include <iostream>
+#include <fstream>
 
 // protocol headers
@@ -44,5 +46,5 @@
       here ++;
     }
-  cout << "Terminfo " << i << endl;
+  std::cout << "Terminfo " << i << std::endl;
 }
 
@@ -57,5 +59,5 @@
       corbaconv_text_t::setCorbatext(option.value,corba[i].value);
 
-      // cout << corbatext_string(corba[i].name) << "?" << option
+      // std::cout << corbatext_string(corba[i].name) << "?" << option
 
       array.push_back(option);
@@ -63,5 +65,7 @@
 }
 
-class corbaServer : virtual public corbaiface_skel
+// corbaServer no longer inherits from corbaiface_skel since the change from using 
+// BOA to POA in the Corba code upon updating Mico from version 2.3.5 to 2.3.13.
+class corbaServer : virtual public POA_gsdlInterface::corbaiface
 {
 private:
@@ -88,17 +92,17 @@
     char * cdirname;
 
-    cout << "CorbaServer: gsdlhome = " << home << endl;
+    std::cout << "CorbaServer: gsdlhome = " << home << std::endl;
 
     this->gsdlhome = home;
-    cout << gsdlhome.getcstr() << endl;
+    std::cout << gsdlhome.getcstr() << std::endl;
     dirname = filename_cat(gsdlhome, "/collect");
     cdirname = dirname.getcstr();
     if (!read_dir (cdirname, collections)) {
-      cout << "Unable to read the gsdl directory; terminating" << endl;
+      std::cout << "Unable to read the gsdl directory; terminating" << std::endl;
       exit (1);
     }
     delete cdirname;
 
-    cout << "Constructing set list server" << endl;
+    std::cout << "Constructing set list server" << std::endl;
     this->protocol = protocol;
 
@@ -128,10 +132,10 @@
 
       // ****
-      cout << "Recieved " << key << " = ";
+      std::cout << "Recieved " << key << " = ";
       for (int unsigned i=0; i<cfgline.size(); i++)
 	{
-	  cout << cfgline[i] << " ";
-	}
-      cout << endl;
+	  std::cout << cfgline[i] << " ";
+	}
+      std::cout << std::endl;
 
       // DB // ****
@@ -140,5 +144,5 @@
 	  text_tarray cfgline;
 	  cfgline.push_back (gsdlhome);
-	  cout << "Changing gsdlhome to " << gsdlhome << endl;
+	  std::cout << "Changing gsdlhome to " << gsdlhome << std::endl;
 	  protocol->configure(key, cfgline, error);
 	}
@@ -146,9 +150,9 @@
 	{
 	  // Only let gsdlhome through !!!! // ****
-	  cout << "Supressing httpdomain" << endl;
+	  std::cout << "Supressing httpdomain" << std::endl;
 	}
       else if (key=="httpprefix")
 	{
-	  cout << "Supressing httpprefix" << endl;
+	  std::cout << "Supressing httpprefix" << std::endl;
 	}
       else
@@ -170,5 +174,5 @@
     cct = new corbaconv_text_t(corbaCollect);
 
-    cout << "Collection: " << cct->getcstr() << endl;
+    std::cout << "Collection: " << cct->getcstr() << std::endl;
 
     protocol->has_collection(*cct, _has, err, logout); // 'cct' typecast to text_t
@@ -182,5 +186,5 @@
       }
 
-    // cout << "  " << has << endl;
+    // std::cout << "  " << has << std::endl;
 
     delete cct;
@@ -245,5 +249,5 @@
     logout.close();
     corbaError = (corbaComError) error;
-    cout << "Filter prepared" << corbaResponse.docInfo.length() << "," << corbaResponse.numDocs << endl;
+    std::cout << "Filter prepared" << corbaResponse.docInfo.length() << "," << corbaResponse.numDocs << std::endl;
   }
 
@@ -262,11 +266,11 @@
     protocol->get_collectinfo(collection, response, error, logout);
 
-    cout << "IsPublic  = " << ((response.isPublic)?"True":"False") << endl;
-    cout << "IsBeta    = " << ((response.isBeta)  ?"True":"False") << endl;
-    cout << "BuildDate = " << response.buildDate << endl;
-    cout << "NumDocs   = " << response.numDocs << endl;
-    cout << "NumBytes  = " << response.numBytes << endl;
-    cout << "NumWords  = " << response.numWords << endl;
-    cout << "UseBook   = " << ((response.useBook)  ?"True":"False") << endl;
+    std::cout << "IsPublic  = " << ((response.isPublic)?"True":"False") << std::endl;
+    std::cout << "IsBeta    = " << ((response.isBeta)  ?"True":"False") << std::endl;
+    std::cout << "BuildDate = " << response.buildDate << std::endl;
+    std::cout << "NumDocs   = " << response.numDocs << std::endl;
+    std::cout << "NumBytes  = " << response.numBytes << std::endl;
+    std::cout << "NumWords  = " << response.numWords << std::endl;
+    std::cout << "UseBook   = " << ((response.useBook)  ?"True":"False") << std::endl;
     
     corbaResponse.useBook   = response.useBook;
@@ -280,5 +284,5 @@
     corbaResponse.numWords  = response.numWords;
 
-    corbatext_mapToCorbaMap(response.collectionmeta, &corbaResponse.collectionMeta);
+    corbatext_colmetamapToCorbaColmetamap(response.collectionmeta, &corbaResponse.collectionMeta);
     corbatext_mapToCorbaMap(response.format, &corbaResponse.format);
     corbatext_mapToCorbaMap(response.building, &corbaResponse.building);
@@ -292,5 +296,5 @@
     while (f_here!=f_end)
     {
-      cout << "**** format: " << f_here->first << " = " << f_here->second << endl;
+      std::cout << "**** format: " << f_here->first << " = " << f_here->second << std::endl;
       f_here++;
     } 
@@ -362,5 +366,5 @@
 
     corbaconv_text_t::setCorbatext(collection,corbaCollect);
-    cout << collection.getcstr() << endl;
+    std::cout << collection.getcstr() << std::endl;
 			    
     protocol->get_filterinfo(collection, response, error, logout);
@@ -399,5 +403,5 @@
   void getRssItems (const struct corbatext_t &corbaCollect,
 		  const struct corbatext_t &corbaGsdlHome,
-		  const struct corbatext_t &corbaRssItems,
+		  struct corbatext_t &corbaRssItems,
 		  enum corbaComError &corbaError)
   {   
@@ -416,5 +420,5 @@
     protocol->get_rss_items(collection, gsdlhome, rss_items, error, logout);
     corbaconv_text_t::getCorbatext(rss_items,corbaRssItems);
-
+    
     // decode response
     corbaError = (corbaComError) error;
@@ -433,5 +437,5 @@
     ofstream logout;
 
-    cout << "Received collection list request" << endl;
+    std::cout << "Received collection list request" << std::endl;
 
     this->openLogfile("/etc/corbaout.txt", logout);
@@ -453,12 +457,12 @@
 
     corbatext_arrayToCorbaArray(collist, &corbalist);
-    cout << "Replying " << collist.size() << ": " << endl;
+    std::cout << "Replying " << collist.size() << ": " << std::endl;
 
     for (int unsigned i = 0; i < collist.size(); i ++)
       {
-	cout << collist[i];
-	if (i<collist.size()-1) cout << ", ";
+	std::cout << collist[i];
+	if (i<collist.size()-1) std::cout << ", ";
       }
-    cout << endl;
+    std::cout << std::endl;
 
     logout.close();
@@ -472,46 +476,77 @@
   collectset *cservers;
   text_t     gsdlhome;
-
-  cservers = new collectset(gsdlhome);
+  text_t     collecthome;
+
+  cservers = new collectset(gsdlhome, collecthome);
   protocol.set_collectset(cservers);
 
-  cout << "Started Corba ..." << endl;
+  std::cout << "Started Corba ..." << std::endl;
 
   // ORB initialization
+  // Initialize the ORB
   CORBA::ORB_var orb = CORBA::ORB_init( argc, argv, "mico-local-orb" );
+
+#if defined(USE_POA)
+  // Obtain a reference to the RootPOA and its Manager
+  CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA");
+  PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj);
+  PortableServer::POAManager_var mgr = poa->the_POAManager();
+#else
   CORBA::BOA_var boa = orb->BOA_init( argc, argv, "mico-local-boa" );
-
-  cout << "Initialised ORB and BOA" << endl;
-
+#endif
+
+  std::cout << "Initialised ORB and P/BOA" << std::endl;
+
+
+  // Create the Server object (the object that inherits from the POA_gsdlInterface::corbaiface
   corbaServer* server = new corbaServer(&protocol, gsdlhome);
 
-  cout << "Initialised server" << endl;
-
-  CORBA::String_var ref = orb->object_to_string( server );
-
-  cout << "Mapped Corba object to string" << endl;
-
+  // Activate the Servant (server)
+#if defined(USE_POA)
+  PortableServer::ObjectId_var oid = poa->activate_object (server);
+#endif
+
+  std::cout << "Initialised server" << std::endl;
+
+  CORBA::Object_var ref = poa->id_to_reference ( oid.in() );
+  CORBA::String_var str = orb->object_to_string( ref.in() );
+
+  std::cout << "Mapped Corba object to string" << std::endl;
+
+  // Write referene to file
   // write id to "naming service"
   ofstream out ("/tmp/localcorba.objid");
 	if (out.is_open()) {
-		out << ref << endl;
+	  	out << str.in() << std::endl;
 		if (out.fail() || out.bad()) {
-			cout << "Failed " << endl;
+			std::cout << "Failed " << std::endl;
 		}
 		out.close ();
 	}
 	else {
-		cout << "Unable to write string to file /tmp/localcorba.objid" << endl;
-		cout << "Please check the file permissions/ownership" << endl;
+	  	std::cout << "Unable to write string" << str.in() << " to file /tmp/localcorba.objid" << std::endl;
+		std::cout << "Please check the file permissions/ownership" << std::endl;
 		return 0;
 	}
-  cout << "Corba string is " << ref << endl;
-
+	std::cout << "Corba string is " << str.in() << std::endl;
+
+	// Activate the POA and start serving requests
   // indicate readiness and run
+#if defined(USE_POA)
+  mgr->activate ();
+  //poa->the_POAManager()->activate();
+#else
   boa->impl_is_ready( CORBA::ImplementationDef::_nil() );
+#endif
   orb->run ();
+
+#if defined(USE_POA)
+  // Shutdown (never reached)
+  poa->destroy (TRUE, TRUE);
+  delete server; // should I include this????
+#else
   CORBA::release( server );
+#endif
   return 0;
 }
 
-
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaclient.mpp
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaclient.mpp	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaclient.mpp	(revision 25231)
@@ -75,5 +75,5 @@
   if (argc == 1)
   { cout << "Content-type: text/html" << endl << endl;
-    cout << "Usage: " << argv[0] << "site1.objid [site2.objid ....]" << endl;
+    cout << "Usage: " << argv[0] << " site1.objid [site2.objid ....]" << endl;
     return 0;
   }
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaiface.h
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaiface.h	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaiface.h	(revision 25231)
@@ -1,41 +1,51 @@
 /*
- *  MICO --- a free CORBA implementation
- *  Copyright (C) 1997-98 Kay Roemer & Arno Puder
+ *  MICO --- an Open Source CORBA implementation
+ *  Copyright (c) 1997-2006 by The Mico Team
  *
  *  This file was automatically generated. DO NOT EDIT!
  */
 
-#if !defined(__CORBAIFACE_H__) || defined(MICO_NO_TOPLEVEL_MODULES)
-#define __CORBAIFACE_H__
-
-#ifndef MICO_NO_TOPLEVEL_MODULES
 #include <CORBA.h>
 #include <mico/throw.h>
-#endif
-
-#ifndef MICO_NO_TOPLEVEL_MODULES
-MICO_NAMESPACE_DECL gsdlInterface {
-#endif
-
-#if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface)
-
-
-typedef SequenceTmpl<CORBA::UShort,MICO_TID_DEF> usString;
-#ifdef _WINDOWS
-static usString _dummy_usString;
-#endif
-typedef TSeqVar<SequenceTmpl<CORBA::UShort,MICO_TID_DEF> > usString_var;
-typedef TSeqOut<SequenceTmpl<CORBA::UShort,MICO_TID_DEF> > usString_out;
+
+#ifndef __CORBAIFACE_H__
+#define __CORBAIFACE_H__
+
+
+
+
+
+
+namespace gsdlInterface
+{
+
+class corbaiface;
+typedef corbaiface *corbaiface_ptr;
+typedef corbaiface_ptr corbaifaceRef;
+typedef ObjVar< corbaiface > corbaiface_var;
+typedef ObjOut< corbaiface > corbaiface_out;
+
+}
+
+
+
+
+
+
+namespace gsdlInterface
+{
+
+typedef SequenceTmpl< CORBA::UShort,MICO_TID_DEF> usString;
+typedef TSeqVar< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_var;
+typedef TSeqOut< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_out;
 
 typedef StringSequenceTmpl<CORBA::String_var> stringSeq;
-#ifdef _WINDOWS
-static stringSeq _dummy_stringSeq;
-#endif
-typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > stringSeq_var;
-typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > stringSeq_out;
+typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > stringSeq_var;
+typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > stringSeq_out;
 
 struct corbatext_t;
-typedef TVarVar<corbatext_t> corbatext_t_var;
-typedef TVarOut<corbatext_t> corbatext_t_out;
+typedef TVarVar< corbatext_t > corbatext_t_var;
+typedef TVarOut< corbatext_t > corbatext_t_out;
+
 
 struct corbatext_t {
@@ -55,21 +65,16 @@
 };
 
-typedef SequenceTmpl<corbatext_t,MICO_TID_DEF> corbatext_tarray;
-#ifdef _WINDOWS
-static corbatext_tarray _dummy_corbatext_tarray;
-#endif
-typedef TSeqVar<SequenceTmpl<corbatext_t,MICO_TID_DEF> > corbatext_tarray_var;
-typedef TSeqOut<SequenceTmpl<corbatext_t,MICO_TID_DEF> > corbatext_tarray_out;
+typedef SequenceTmpl< corbatext_t,MICO_TID_DEF> corbatext_tarray;
+typedef TSeqVar< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_var;
+typedef TSeqOut< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_out;
 
 typedef corbatext_tarray corbatext_tset;
-#ifdef _WINDOWS
-static corbatext_tset _dummy_corbatext_tset;
-#endif
-typedef TSeqVar<corbatext_tarray > corbatext_tset_var;
-typedef TSeqOut<corbatext_tarray > corbatext_tset_out;
+typedef TSeqVar< corbatext_tarray > corbatext_tset_var;
+typedef TSeqOut< corbatext_tarray > corbatext_tset_out;
 
 struct corbatext_tmap;
-typedef TVarVar<corbatext_tmap> corbatext_tmap_var;
-typedef TVarOut<corbatext_tmap> corbatext_tmap_out;
+typedef TVarVar< corbatext_tmap > corbatext_tmap_var;
+typedef TVarOut< corbatext_tmap > corbatext_tmap_out;
+
 
 struct corbatext_tmap {
@@ -87,4 +92,28 @@
   corbatext_tarray values;
 };
+
+struct corbatext_tcollectionmeta;
+typedef TVarVar< corbatext_tcollectionmeta > corbatext_tcollectionmeta_var;
+typedef TVarOut< corbatext_tcollectionmeta > corbatext_tcollectionmeta_out;
+
+
+struct corbatext_tcollectionmeta {
+  #ifdef HAVE_TYPEDEF_OVERLOAD
+  typedef corbatext_tcollectionmeta_var _var_type;
+  #endif
+  #ifdef HAVE_EXPLICIT_STRUCT_OPS
+  corbatext_tcollectionmeta();
+  ~corbatext_tcollectionmeta();
+  corbatext_tcollectionmeta( const corbatext_tcollectionmeta& s );
+  corbatext_tcollectionmeta& operator=( const corbatext_tcollectionmeta& s );
+  #endif //HAVE_EXPLICIT_STRUCT_OPS
+
+  corbatext_t name;
+  corbatext_tmap tuples;
+};
+
+typedef SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> corbatext_tcollectionmeta_map;
+typedef TSeqVar< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_var;
+typedef TSeqOut< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_out;
 
 enum corbaComError {
@@ -99,6 +128,7 @@
 
 struct corbaShortColInfo;
-typedef TVarVar<corbaShortColInfo> corbaShortColInfo_var;
-typedef TVarOut<corbaShortColInfo> corbaShortColInfo_out;
+typedef TVarVar< corbaShortColInfo > corbaShortColInfo_var;
+typedef TVarOut< corbaShortColInfo > corbaShortColInfo_out;
+
 
 struct corbaShortColInfo {
@@ -119,6 +149,7 @@
 
 struct corbaColInfoResponse;
-typedef TVarVar<corbaColInfoResponse> corbaColInfoResponse_var;
-typedef TVarOut<corbaColInfoResponse> corbaColInfoResponse_out;
+typedef TVarVar< corbaColInfoResponse > corbaColInfoResponse_var;
+typedef TVarOut< corbaColInfoResponse > corbaColInfoResponse_out;
+
 
 struct corbaColInfoResponse {
@@ -133,5 +164,5 @@
   #endif //HAVE_EXPLICIT_STRUCT_OPS
 
-  corbaShortColInfo shoftInfo;
+  corbaShortColInfo shortInfo;
   CORBA::Boolean useBook;
   CORBA::Boolean isPublic;
@@ -143,5 +174,5 @@
   CORBA::ULong numWords;
   CORBA::ULong numBytes;
-  corbatext_tmap collectionMeta;
+  corbatext_tcollectionmeta_map collectionMeta;
   corbatext_tmap format;
   corbatext_tmap building;
@@ -149,9 +180,24 @@
   corbatext_t httpprefix;
   corbatext_t receptionist;
+  CORBA::Boolean isSegmented;
+  CORBA::Boolean isCollectGroup;
+  CORBA::ULong ccsOptions;
+  CORBA::ULong stemIndexes;
+  CORBA::ULong numSections;
+  corbatext_tcollectionmeta_map collection_macros;
+  corbatext_t buildType;
+  corbatext_t infodbType;
+  corbatext_t authenticate;
+  corbatext_t auth_group;
+  corbatext_tmap public_documents;
+  corbatext_tmap private_documents;
+  corbatext_tmap dynamic_classifiers;
+  corbatext_t earliestDatestamp;
 };
 
 struct corbaDocRequest;
-typedef TVarVar<corbaDocRequest> corbaDocRequest_var;
-typedef TVarOut<corbaDocRequest> corbaDocRequest_out;
+typedef TVarVar< corbaDocRequest > corbaDocRequest_var;
+typedef TVarOut< corbaDocRequest > corbaDocRequest_out;
+
 
 struct corbaDocRequest {
@@ -172,6 +218,7 @@
 
 struct corbaDocResponse;
-typedef TVarVar<corbaDocResponse> corbaDocResponse_var;
-typedef TVarOut<corbaDocResponse> corbaDocResponse_out;
+typedef TVarVar< corbaDocResponse > corbaDocResponse_var;
+typedef TVarOut< corbaDocResponse > corbaDocResponse_out;
+
 
 struct corbaDocResponse {
@@ -207,6 +254,7 @@
 
 struct corbaFilterOption;
-typedef TVarVar<corbaFilterOption> corbaFilterOption_var;
-typedef TVarOut<corbaFilterOption> corbaFilterOption_out;
+typedef TVarVar< corbaFilterOption > corbaFilterOption_var;
+typedef TVarOut< corbaFilterOption > corbaFilterOption_out;
+
 
 struct corbaFilterOption {
@@ -228,14 +276,12 @@
 };
 
-typedef SequenceTmpl<corbaFilterOption,MICO_TID_DEF> corbaFilterOptionList;
-#ifdef _WINDOWS
-static corbaFilterOptionList _dummy_corbaFilterOptionList;
-#endif
-typedef TSeqVar<SequenceTmpl<corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var;
-typedef TSeqOut<SequenceTmpl<corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_out;
+typedef SequenceTmpl< corbaFilterOption,MICO_TID_DEF> corbaFilterOptionList;
+typedef TSeqVar< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var;
+typedef TSeqOut< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_out;
 
 struct corbaFilterOptionsResponse;
-typedef TVarVar<corbaFilterOptionsResponse> corbaFilterOptionsResponse_var;
-typedef TVarOut<corbaFilterOptionsResponse> corbaFilterOptionsResponse_out;
+typedef TVarVar< corbaFilterOptionsResponse > corbaFilterOptionsResponse_var;
+typedef TVarOut< corbaFilterOptionsResponse > corbaFilterOptionsResponse_out;
+
 
 struct corbaFilterOptionsResponse {
@@ -255,6 +301,7 @@
 
 struct corbaOptionValue;
-typedef TVarVar<corbaOptionValue> corbaOptionValue_var;
-typedef TVarOut<corbaOptionValue> corbaOptionValue_out;
+typedef TVarVar< corbaOptionValue > corbaOptionValue_var;
+typedef TVarOut< corbaOptionValue > corbaOptionValue_out;
+
 
 struct corbaOptionValue {
@@ -273,14 +320,12 @@
 };
 
-typedef SequenceTmpl<corbaOptionValue,MICO_TID_DEF> corbaOptionValue_array;
-#ifdef _WINDOWS
-static corbaOptionValue_array _dummy_corbaOptionValue_array;
-#endif
-typedef TSeqVar<SequenceTmpl<corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var;
-typedef TSeqOut<SequenceTmpl<corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_out;
+typedef SequenceTmpl< corbaOptionValue,MICO_TID_DEF> corbaOptionValue_array;
+typedef TSeqVar< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var;
+typedef TSeqOut< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_out;
 
 struct corbaFilterRequest;
-typedef TVarVar<corbaFilterRequest> corbaFilterRequest_var;
-typedef TVarOut<corbaFilterRequest> corbaFilterRequest_out;
+typedef TVarVar< corbaFilterRequest > corbaFilterRequest_var;
+typedef TVarOut< corbaFilterRequest > corbaFilterRequest_out;
+
 
 struct corbaFilterRequest {
@@ -306,6 +351,7 @@
 
 struct corbaTermInfo;
-typedef TVarVar<corbaTermInfo> corbaTermInfo_var;
-typedef TVarOut<corbaTermInfo> corbaTermInfo_out;
+typedef TVarVar< corbaTermInfo > corbaTermInfo_var;
+typedef TVarOut< corbaTermInfo > corbaTermInfo_out;
+
 
 struct corbaTermInfo {
@@ -325,14 +371,12 @@
 };
 
-typedef SequenceTmpl<corbaTermInfo,MICO_TID_DEF> corbaTermInfo_array;
-#ifdef _WINDOWS
-static corbaTermInfo_array _dummy_corbaTermInfo_array;
-#endif
-typedef TSeqVar<SequenceTmpl<corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var;
-typedef TSeqOut<SequenceTmpl<corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_out;
+typedef SequenceTmpl< corbaTermInfo,MICO_TID_DEF> corbaTermInfo_array;
+typedef TSeqVar< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var;
+typedef TSeqOut< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_out;
 
 struct corbaMetadataInfo;
-typedef TVarVar<corbaMetadataInfo> corbaMetadataInfo_var;
-typedef TVarOut<corbaMetadataInfo> corbaMetadataInfo_out;
+typedef TVarVar< corbaMetadataInfo > corbaMetadataInfo_var;
+typedef TVarOut< corbaMetadataInfo > corbaMetadataInfo_out;
+
 
 struct corbaMetadataInfo {
@@ -354,14 +398,12 @@
 };
 
-typedef SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> corbaMetadataInfo_array;
-#ifdef _WINDOWS
-static corbaMetadataInfo_array _dummy_corbaMetadataInfo_array;
-#endif
-typedef TSeqVar<SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var;
-typedef TSeqOut<SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_out;
+typedef SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> corbaMetadataInfo_array;
+typedef TSeqVar< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var;
+typedef TSeqOut< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_out;
 
 struct corbaMetadataInfo_map;
-typedef TVarVar<corbaMetadataInfo_map> corbaMetadataInfo_map_var;
-typedef TVarOut<corbaMetadataInfo_map> corbaMetadataInfo_map_out;
+typedef TVarVar< corbaMetadataInfo_map > corbaMetadataInfo_map_var;
+typedef TVarOut< corbaMetadataInfo_map > corbaMetadataInfo_map_out;
+
 
 struct corbaMetadataInfo_map {
@@ -380,14 +422,12 @@
 };
 
-typedef SequenceTmpl<CORBA::Long,MICO_TID_DEF> corbaDocFreq_array;
-#ifdef _WINDOWS
-static corbaDocFreq_array _dummy_corbaDocFreq_array;
-#endif
-typedef TSeqVar<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var;
-typedef TSeqOut<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_out;
+typedef SequenceTmpl< CORBA::Long,MICO_TID_DEF> corbaDocFreq_array;
+typedef TSeqVar< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var;
+typedef TSeqOut< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_out;
 
 struct corbaResultDocInfo;
-typedef TVarVar<corbaResultDocInfo> corbaResultDocInfo_var;
-typedef TVarOut<corbaResultDocInfo> corbaResultDocInfo_out;
+typedef TVarVar< corbaResultDocInfo > corbaResultDocInfo_var;
+typedef TVarOut< corbaResultDocInfo > corbaResultDocInfo_out;
+
 
 struct corbaResultDocInfo {
@@ -414,10 +454,7 @@
 };
 
-typedef SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> corbaResultDocInfo_array;
-#ifdef _WINDOWS
-static corbaResultDocInfo_array _dummy_corbaResultDocInfo_array;
-#endif
-typedef TSeqVar<SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var;
-typedef TSeqOut<SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_out;
+typedef SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> corbaResultDocInfo_array;
+typedef TSeqVar< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var;
+typedef TSeqOut< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_out;
 
 enum corbaIsApprox {
@@ -430,6 +467,7 @@
 
 struct corbaFilterResponse;
-typedef TVarVar<corbaFilterResponse> corbaFilterResponse_var;
-typedef TVarOut<corbaFilterResponse> corbaFilterResponse_out;
+typedef TVarVar< corbaFilterResponse > corbaFilterResponse_var;
+typedef TVarOut< corbaFilterResponse > corbaFilterResponse_out;
+
 
 struct corbaFilterResponse {
@@ -450,12 +488,9 @@
 };
 
-class corbaiface;
-typedef corbaiface *corbaiface_ptr;
-typedef corbaiface_ptr corbaifaceRef;
-typedef ObjVar<corbaiface> corbaiface_var;
-typedef ObjOut<corbaiface> corbaiface_out;
-
-
-// Common definitions for interface corbaiface
+
+/*
+ * Base class and common definitions for interface corbaiface
+ */
+
 class corbaiface : 
   virtual public CORBA::Object
@@ -483,17 +518,16 @@
 
     virtual void *_narrow_helper( const char *repoid );
-    static vector<CORBA::Narrow_proto> *_narrow_helpers;
-    static bool _narrow_helper2( CORBA::Object_ptr obj );
-
-    virtual CORBA::Boolean initialise( corbaComError& error ) = 0;
-    virtual void configure( const corbatext_t& key, const corbatext_tarray& cfgline, corbaComError& error ) = 0;
-    virtual void collectionList( corbatext_tarray& collist, corbaComError& error ) = 0;
-    virtual void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error ) = 0;
-    virtual void ping( const corbatext_t& collection, CORBA::Boolean& wasSuccess, corbaComError& error ) = 0;
-    virtual void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error ) = 0;
-    virtual void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error ) = 0;
-    virtual void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error ) = 0;
-    virtual void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error ) = 0;
-    virtual void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error ) = 0;
+
+    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0;
 
   protected:
@@ -510,14 +544,15 @@
   public:
     virtual ~corbaiface_stub();
-    CORBA::Boolean initialise( corbaComError& error );
-    void configure( const corbatext_t& key, const corbatext_tarray& cfgline, corbaComError& error );
-    void collectionList( corbatext_tarray& collist, corbaComError& error );
-    void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error );
-    void ping( const corbatext_t& collection, CORBA::Boolean& wasSuccess, corbaComError& error );
-    void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error );
-    void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error );
-    void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error );
-    void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error );
-    void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error );
+    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error );
+    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error );
+    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error );
+    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error );
+    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error );
+    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error );
+    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error );
+    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error );
+    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error );
+    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error );
+    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error );
 
   private:
@@ -525,90 +560,138 @@
 };
 
-class corbaiface_skel :
-  virtual public StaticMethodDispatcher,
-  virtual public corbaiface
+#ifndef MICO_CONF_NO_POA
+
+class corbaiface_stub_clp :
+  virtual public corbaiface_stub,
+  virtual public PortableServer::StubBase
 {
   public:
-    corbaiface_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
-    virtual ~corbaiface_skel();
-    corbaiface_skel( CORBA::Object_ptr obj );
-    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
-    corbaiface_ptr _this();
-
-};
-
-#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface)
-
-#ifndef MICO_NO_TOPLEVEL_MODULES
-
-} MICO_NAMESPACE_END_DECL
+    corbaiface_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
+    virtual ~corbaiface_stub_clp ();
+    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error );
+    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error );
+    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error );
+    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error );
+    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error );
+    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error );
+    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error );
+    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error );
+    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error );
+    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error );
+    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error );
+
+  protected:
+    corbaiface_stub_clp ();
+  private:
+    void operator=( const corbaiface_stub_clp & );
+};
+
+#endif // MICO_CONF_NO_POA
+
+}
+
+
+#ifndef MICO_CONF_NO_POA
+
+
+
+namespace POA_gsdlInterface
+{
+
+class corbaiface : virtual public PortableServer::StaticImplementation
+{
+  public:
+    virtual ~corbaiface ();
+    gsdlInterface::corbaiface_ptr _this ();
+    bool dispatch (CORBA::StaticServerRequest_ptr);
+    virtual void invoke (CORBA::StaticServerRequest_ptr);
+    virtual CORBA::Boolean _is_a (const char *);
+    virtual CORBA::InterfaceDef_ptr _get_interface ();
+    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
+
+    virtual void * _narrow_helper (const char *);
+    static corbaiface * _narrow (PortableServer::Servant);
+    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
+
+    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
+    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0;
+
+  protected:
+    corbaiface () {};
+
+  private:
+    corbaiface (const corbaiface &);
+    void operator= (const corbaiface &);
+};
+
+}
+
+
+#endif // MICO_CONF_NO_POA
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
+
+extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
+
+extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
+
 #endif
-
-
-
-#ifndef MICO_CONF_NO_POA
-
-#endif // MICO_CONF_NO_POA
-
-#if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
-
-extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
-
-extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
-
-#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)
-
-
-#if !defined(MICO_NO_TOPLEVEL_MODULES) && !defined(MICO_IN_GENERATED_CODE)
-#include <mico/template_impl.h>
-#endif
-
-#endif
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaiface.idl
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaiface.idl	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaiface.idl	(revision 25231)
@@ -23,4 +23,21 @@
   corbatext_tarray values;
 };
+
+// colserver/comtypes.h defines collectionmeta_map of collectionmeta 
+// as (sorted) tuples of: metadata name -> lang -> value
+// However, the C++ definition is: 
+// typedef map<text_t, text_tmap, lttext_t> collectionmeta_map;
+// Where lttext_t is defined to be a sorting function in text_t.h
+// Each collectionmeta name maps to one or more (lang,value) pairs. 
+// The struct below defines the entry for one collectionmeta name.
+struct corbatext_tcollectionmeta {
+  corbatext_t name;
+  corbatext_tmap tuples;
+  //corbatext_tarray languages;
+  //corbatext_tarray values;
+};
+
+typedef sequence<corbatext_tcollectionmeta> corbatext_tcollectionmeta_map;
+
 
 // standard error values
@@ -47,8 +64,9 @@
 struct corbaColInfoResponse
 {
-  boolean       useBook;
-  corbaShortColInfo shoftInfo;
+  corbaShortColInfo shortInfo;
+  boolean           useBook;
   boolean           isPublic;
   boolean           isBeta;
+
   unsigned long     buildDate;
   corbatext_tarray  ccsCols;        // Added 05/04/2000
@@ -57,5 +75,5 @@
   unsigned long     numWords;
   unsigned long     numBytes;
-  corbatext_tmap    collectionMeta;
+  corbatext_tcollectionmeta_map    collectionMeta; //corbatext_tmap    collectionMeta;
   corbatext_tmap    format;
   corbatext_tmap    building;
@@ -63,4 +81,23 @@
   corbatext_t       httpprefix;     // Added 27/07/2000
   corbatext_t       receptionist;
+
+  // The following member fields were added 14/03/2011 to 
+  // match up with ColInfoResponse_t definition in comtypes.h
+
+  boolean isSegmented;
+  boolean isCollectGroup; // used to group a set of collections as one item on the home page
+  unsigned long ccsOptions; // uses CCS #defines from above
+  unsigned long stemIndexes; // uses SI #defines from above
+  unsigned long numSections; // 0 if not known
+  corbatext_tcollectionmeta_map	 collection_macros; // for collectionmacro config directive (> gsdl 2.53)
+  corbatext_t         buildType;           // 'mg' or 'mgpp' or 'lucene'
+  corbatext_t         infodbType;          // 'gdbm', 'sqlite', etc.
+  corbatext_t         authenticate;        // 'document' or 'collection'
+  corbatext_t         auth_group;          // 'mygroup' 'yourgroup'
+  corbatext_tmap      public_documents;    // the acl to allow access to listed documents
+  corbatext_tmap      private_documents;   // the acl to disallow access to listed documents
+  corbatext_tmap      dynamic_classifiers;
+  corbatext_t         earliestDatestamp;   // For OAIserver validation. Time since linux Epoch, expressed as (long) integer value in string form
+
 };
 
@@ -227,10 +264,11 @@
                    inout corbaFilterResponse response,
                    inout corbaComError error);
-  void      get_rss_items (const text_t &collection, 
-			   const text_t &gsdlhome, 
-			   text_t &rss_items, 
-			   comerror_t &err, 
-			   ostream &logout);
-};
-
-};
+
+  void      getRssItems (in corbatext_t collection, 
+			 in corbatext_t gsdlhome, 
+			 inout corbatext_t rss_items, 
+			 inout corbaComError error);
+
+};
+
+};
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp	(revision 25231)
@@ -1,10 +1,13 @@
 /*
- *  MICO --- a free CORBA implementation
- *  Copyright (C) 1997-98 Kay Roemer & Arno Puder
+ *  MICO --- an Open Source CORBA implementation
+ *  Copyright (c) 1997-2006 by The Mico Team
  *
  *  This file was automatically generated. DO NOT EDIT!
  */
 
-#include "corbaiface.h"
+#include <corbaiface.h>
+
+
+using namespace std;
 
 //--------------------------------------------------------
@@ -39,16 +42,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbatext_t _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbatext_t();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const
+_Marshaller_gsdlInterface_corbatext_t::~_Marshaller_gsdlInterface_corbatext_t()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -65,5 +73,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -75,5 +83,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -84,5 +92,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
 
 
@@ -112,16 +120,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbatext_tmap : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbatext_tmap : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbatext_tmap _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbatext_tmap();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const
+_Marshaller_gsdlInterface_corbatext_tmap::~_Marshaller_gsdlInterface_corbatext_tmap()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -138,5 +151,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -147,5 +160,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbatext_tmap::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbatext_tmap::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -155,23 +168,103 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
-
-
-class _Marshaller_gsdlInterface_corbaComError : public CORBA::StaticTypeInfo {
-    typedef gsdlInterface::corbaComError _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
+
+#ifdef HAVE_EXPLICIT_STRUCT_OPS
+gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta()
+{
+}
+
+gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta( const corbatext_tcollectionmeta& _s )
+{
+  name = ((corbatext_tcollectionmeta&)_s).name;
+  tuples = ((corbatext_tcollectionmeta&)_s).tuples;
+}
+
+gsdlInterface::corbatext_tcollectionmeta::~corbatext_tcollectionmeta()
+{
+}
+
+gsdlInterface::corbatext_tcollectionmeta&
+gsdlInterface::corbatext_tcollectionmeta::operator=( const corbatext_tcollectionmeta& _s )
+{
+  name = ((corbatext_tcollectionmeta&)_s).name;
+  tuples = ((corbatext_tcollectionmeta&)_s).tuples;
+  return *this;
+}
+#endif
+
+class _Marshaller_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo {
+    typedef gsdlInterface::corbatext_tcollectionmeta _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbatext_tcollectionmeta();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const
+_Marshaller_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller_gsdlInterface_corbatext_tcollectionmeta()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tcollectionmeta::create() const
 {
   return (StaticValueType) new _MICO_T;
 }
 
+void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const
+{
+  *(_MICO_T*) d = *(_MICO_T*) s;
+}
+
+void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const
+{
+  delete (_MICO_T*) v;
+}
+
+::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  return
+    dc.struct_begin() &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
+    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->tuples ) &&
+    dc.struct_end();
+}
+
+void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ec.struct_begin();
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
+  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->tuples );
+  ec.struct_end();
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta;
+
+
+
+class _Marshaller_gsdlInterface_corbaComError : public ::CORBA::StaticTypeInfo {
+    typedef gsdlInterface::corbaComError _MICO_T;
+  public:
+    ~_Marshaller_gsdlInterface_corbaComError();
+    StaticValueType create () const;
+    void assign (StaticValueType dst, const StaticValueType src) const;
+    void free (StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
+};
+
+
+_Marshaller_gsdlInterface_corbaComError::~_Marshaller_gsdlInterface_corbaComError()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const
+{
+  return (StaticValueType) new _MICO_T;
+}
+
 void _Marshaller_gsdlInterface_corbaComError::assign( StaticValueType d, const StaticValueType s ) const
 {
@@ -184,7 +277,7 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong ul;
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong ul;
   if( !dc.enumeration( ul ) )
     return FALSE;
@@ -193,10 +286,10 @@
 }
 
-void _Marshaller_gsdlInterface_corbaComError::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
-}
-
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
+void _Marshaller_gsdlInterface_corbaComError::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -226,16 +319,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaShortColInfo : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaShortColInfo : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaShortColInfo _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaShortColInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const
+_Marshaller_gsdlInterface_corbaShortColInfo::~_Marshaller_gsdlInterface_corbaShortColInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -252,5 +350,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -262,5 +360,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -271,5 +369,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -280,5 +378,5 @@
 gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s )
 {
-  shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
+  shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
   useBook = ((corbaColInfoResponse&)_s).useBook;
   isPublic = ((corbaColInfoResponse&)_s).isPublic;
@@ -296,4 +394,18 @@
   httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
   receptionist = ((corbaColInfoResponse&)_s).receptionist;
+  isSegmented = ((corbaColInfoResponse&)_s).isSegmented;
+  isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup;
+  ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions;
+  stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes;
+  numSections = ((corbaColInfoResponse&)_s).numSections;
+  collection_macros = ((corbaColInfoResponse&)_s).collection_macros;
+  buildType = ((corbaColInfoResponse&)_s).buildType;
+  infodbType = ((corbaColInfoResponse&)_s).infodbType;
+  authenticate = ((corbaColInfoResponse&)_s).authenticate;
+  auth_group = ((corbaColInfoResponse&)_s).auth_group;
+  public_documents = ((corbaColInfoResponse&)_s).public_documents;
+  private_documents = ((corbaColInfoResponse&)_s).private_documents;
+  dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers;
+  earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp;
 }
 
@@ -305,5 +417,5 @@
 gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s )
 {
-  shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
+  shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
   useBook = ((corbaColInfoResponse&)_s).useBook;
   isPublic = ((corbaColInfoResponse&)_s).isPublic;
@@ -321,20 +433,39 @@
   httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
   receptionist = ((corbaColInfoResponse&)_s).receptionist;
+  isSegmented = ((corbaColInfoResponse&)_s).isSegmented;
+  isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup;
+  ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions;
+  stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes;
+  numSections = ((corbaColInfoResponse&)_s).numSections;
+  collection_macros = ((corbaColInfoResponse&)_s).collection_macros;
+  buildType = ((corbaColInfoResponse&)_s).buildType;
+  infodbType = ((corbaColInfoResponse&)_s).infodbType;
+  authenticate = ((corbaColInfoResponse&)_s).authenticate;
+  auth_group = ((corbaColInfoResponse&)_s).auth_group;
+  public_documents = ((corbaColInfoResponse&)_s).public_documents;
+  private_documents = ((corbaColInfoResponse&)_s).private_documents;
+  dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers;
+  earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp;
   return *this;
 }
 #endif
 
-class _Marshaller_gsdlInterface_corbaColInfoResponse : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaColInfoResponse : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaColInfoResponse _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaColInfoResponse();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const
+_Marshaller_gsdlInterface_corbaColInfoResponse::~_Marshaller_gsdlInterface_corbaColInfoResponse()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -351,9 +482,9 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
     dc.struct_begin() &&
-    _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shoftInfo ) &&
+    _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shortInfo ) &&
     CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->useBook ) &&
     CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) &&
@@ -365,5 +496,5 @@
     CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) &&
     CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) &&
-    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) &&
+    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) &&
     _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) &&
     _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) &&
@@ -371,11 +502,25 @@
     _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) &&
     _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) &&
+    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isSegmented ) &&
+    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isCollectGroup ) &&
+    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->ccsOptions ) &&
+    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->stemIndexes ) &&
+    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numSections ) &&
+    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collection_macros ) &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->buildType ) &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->infodbType ) &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->authenticate ) &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->auth_group ) &&
+    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->public_documents ) &&
+    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->private_documents ) &&
+    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->dynamic_classifiers ) &&
+    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->earliestDatestamp ) &&
     dc.struct_end();
 }
 
-void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
-  _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shoftInfo );
+  _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shortInfo );
   CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->useBook );
   CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic );
@@ -387,5 +532,5 @@
   CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords );
   CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes );
-  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->collectionMeta );
+  _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collectionMeta );
   _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format );
   _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building );
@@ -393,8 +538,22 @@
   _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix );
   _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist );
+  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isSegmented );
+  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isCollectGroup );
+  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->ccsOptions );
+  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->stemIndexes );
+  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numSections );
+  _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collection_macros );
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->buildType );
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->infodbType );
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->authenticate );
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->auth_group );
+  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->public_documents );
+  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->private_documents );
+  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->dynamic_classifiers );
+  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->earliestDatestamp );
   ec.struct_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -424,16 +583,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaDocRequest : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaDocRequest : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaDocRequest _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaDocRequest();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const
+_Marshaller_gsdlInterface_corbaDocRequest::~_Marshaller_gsdlInterface_corbaDocRequest()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -450,5 +614,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -460,5 +624,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaDocRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaDocRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -469,5 +633,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -493,16 +657,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaDocResponse : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaDocResponse : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaDocResponse _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaDocResponse();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const
+_Marshaller_gsdlInterface_corbaDocResponse::~_Marshaller_gsdlInterface_corbaDocResponse()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -519,5 +688,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -527,5 +696,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaDocResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaDocResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -534,19 +703,24 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
-
-
-class _Marshaller_gsdlInterface_corbaFilterType : public CORBA::StaticTypeInfo {
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
+
+
+class _Marshaller_gsdlInterface_corbaFilterType : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterType _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterType();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const
+_Marshaller_gsdlInterface_corbaFilterType::~_Marshaller_gsdlInterface_corbaFilterType()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -563,7 +737,7 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong ul;
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong ul;
   if( !dc.enumeration( ul ) )
     return FALSE;
@@ -572,24 +746,29 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterType::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
-}
-
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
-
-
-class _Marshaller_gsdlInterface_corbaFilterRepeatable : public CORBA::StaticTypeInfo {
+void _Marshaller_gsdlInterface_corbaFilterType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
+
+
+class _Marshaller_gsdlInterface_corbaFilterRepeatable : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterRepeatable _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterRepeatable();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const
+_Marshaller_gsdlInterface_corbaFilterRepeatable::~_Marshaller_gsdlInterface_corbaFilterRepeatable()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -606,7 +785,7 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong ul;
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong ul;
   if( !dc.enumeration( ul ) )
     return FALSE;
@@ -615,10 +794,10 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
-}
-
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
+void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -652,16 +831,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterOption _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterOption();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const
+_Marshaller_gsdlInterface_corbaFilterOption::~_Marshaller_gsdlInterface_corbaFilterOption()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -678,5 +862,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -690,5 +874,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -701,5 +885,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
 
 
@@ -728,16 +912,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterOptionsResponse();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const
+_Marshaller_gsdlInterface_corbaFilterOptionsResponse::~_Marshaller_gsdlInterface_corbaFilterOptionsResponse()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -754,5 +943,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -763,5 +952,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -771,5 +960,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -797,16 +986,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaOptionValue _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaOptionValue();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const
+_Marshaller_gsdlInterface_corbaOptionValue::~_Marshaller_gsdlInterface_corbaOptionValue()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -823,5 +1017,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -832,5 +1026,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -840,5 +1034,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
 
 
@@ -879,16 +1073,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaFilterRequest : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaFilterRequest : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterRequest _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterRequest();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const
+_Marshaller_gsdlInterface_corbaFilterRequest::~_Marshaller_gsdlInterface_corbaFilterRequest()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -905,5 +1104,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -920,5 +1119,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -934,5 +1133,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -962,16 +1161,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaTermInfo _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaTermInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const
+_Marshaller_gsdlInterface_corbaTermInfo::~_Marshaller_gsdlInterface_corbaTermInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -988,5 +1192,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -998,5 +1202,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -1007,5 +1211,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
 
 
@@ -1040,16 +1244,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaMetadataInfo _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaMetadataInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const
+_Marshaller_gsdlInterface_corbaMetadataInfo::~_Marshaller_gsdlInterface_corbaMetadataInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1066,5 +1275,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -1078,5 +1287,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -1089,5 +1298,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
 
 
@@ -1116,16 +1325,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaMetadataInfo_map _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaMetadataInfo_map();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const
+_Marshaller_gsdlInterface_corbaMetadataInfo_map::~_Marshaller_gsdlInterface_corbaMetadataInfo_map()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1142,5 +1356,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -1151,5 +1365,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -1159,5 +1373,5 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
 
 
@@ -1202,16 +1416,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaResultDocInfo _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaResultDocInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const
+_Marshaller_gsdlInterface_corbaResultDocInfo::~_Marshaller_gsdlInterface_corbaResultDocInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1228,5 +1447,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -1245,5 +1464,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -1261,20 +1480,25 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
-
-
-
-class _Marshaller_gsdlInterface_corbaIsApprox : public CORBA::StaticTypeInfo {
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
+
+
+
+class _Marshaller_gsdlInterface_corbaIsApprox : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaIsApprox _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaIsApprox();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const
+_Marshaller_gsdlInterface_corbaIsApprox::~_Marshaller_gsdlInterface_corbaIsApprox()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1291,7 +1515,7 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong ul;
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong ul;
   if( !dc.enumeration( ul ) )
     return FALSE;
@@ -1300,10 +1524,10 @@
 }
 
-void _Marshaller_gsdlInterface_corbaIsApprox::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
-}
-
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
+void _Marshaller_gsdlInterface_corbaIsApprox::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -1335,16 +1559,21 @@
 #endif
 
-class _Marshaller_gsdlInterface_corbaFilterResponse : public CORBA::StaticTypeInfo {
+class _Marshaller_gsdlInterface_corbaFilterResponse : public ::CORBA::StaticTypeInfo {
     typedef gsdlInterface::corbaFilterResponse _MICO_T;
   public:
+    ~_Marshaller_gsdlInterface_corbaFilterResponse();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const
+_Marshaller_gsdlInterface_corbaFilterResponse::~_Marshaller_gsdlInterface_corbaFilterResponse()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1361,5 +1590,5 @@
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
 {
   return
@@ -1372,5 +1601,5 @@
 }
 
-void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
+void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
 {
   ec.struct_begin();
@@ -1382,34 +1611,25 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
-
-
-// Stub interface corbaiface
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
+
+
+/*
+ * Base interface for class corbaiface
+ */
+
 gsdlInterface::corbaiface::~corbaiface()
 {
 }
 
-void *gsdlInterface::corbaiface::_narrow_helper( const char *_rid )
-{
-  if( strcmp( _rid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 )
+void *
+gsdlInterface::corbaiface::_narrow_helper( const char *_repoid )
+{
+  if( strcmp( _repoid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 )
     return (void *)this;
   return NULL;
 }
 
-bool gsdlInterface::corbaiface::_narrow_helper2( CORBA::Object_ptr _obj )
-{
-  if( strcmp( _obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0" ) == 0) {
-    return true;
-  }
-  for( vector<CORBA::Narrow_proto>::size_type _i = 0;
-       _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
-    bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
-    if( _res )
-      return true;
-  }
-  return false;
-}
-
-gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj )
+gsdlInterface::corbaiface_ptr
+gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj )
 {
   gsdlInterface::corbaiface_ptr _o;
@@ -1418,8 +1638,7 @@
     if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" )))
       return _duplicate( (gsdlInterface::corbaiface_ptr) _p );
-    if( _narrow_helper2( _obj ) ||
-       ( _obj->_is_a_remote( "IDL:gsdlInterface/corbaiface:1.0" ) ) ) {
+    if (!strcmp (_obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0") || _obj->_is_a_remote ("IDL:gsdlInterface/corbaiface:1.0")) {
       _o = new gsdlInterface::corbaiface_stub;
-      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
+      _o->CORBA::Object::operator=( *_obj );
       return _o;
     }
@@ -1434,16 +1653,115 @@
 }
 
+class _Marshaller_gsdlInterface_corbaiface : public ::CORBA::StaticTypeInfo {
+    typedef gsdlInterface::corbaiface_ptr _MICO_T;
+  public:
+    ~_Marshaller_gsdlInterface_corbaiface();
+    StaticValueType create () const;
+    void assign (StaticValueType dst, const StaticValueType src) const;
+    void free (StaticValueType) const;
+    void release (StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
+};
+
+
+_Marshaller_gsdlInterface_corbaiface::~_Marshaller_gsdlInterface_corbaiface()
+{
+}
+
+::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
+{
+  return (StaticValueType) new _MICO_T( 0 );
+}
+
+void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
+{
+  *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s );
+}
+
+void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
+{
+  ::CORBA::release( *(_MICO_T *) v );
+  delete (_MICO_T*) v;
+}
+
+void _Marshaller_gsdlInterface_corbaiface::release( StaticValueType v ) const
+{
+  ::CORBA::release( *(_MICO_T *) v );
+}
+
+::CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::Object_ptr obj;
+  if (!::CORBA::_stc_Object->demarshal(dc, &obj))
+    return FALSE;
+  *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj );
+  ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
+  ::CORBA::release (obj);
+  return ret;
+}
+
+void _Marshaller_gsdlInterface_corbaiface::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::Object_ptr obj = *(_MICO_T *) v;
+  ::CORBA::_stc_Object->marshal( ec, &obj );
+}
+
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
+
+
+/*
+ * Stub interface for class corbaiface
+ */
+
 gsdlInterface::corbaiface_stub::~corbaiface_stub()
 {
 }
 
-CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void *
+POA_gsdlInterface::corbaiface::_narrow_helper (const char * repoid)
+{
+  if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
+    return (void *) this;
+  }
+  return NULL;
+}
+
+POA_gsdlInterface::corbaiface *
+POA_gsdlInterface::corbaiface::_narrow (PortableServer::Servant serv) 
+{
+  void * p;
+  if ((p = serv->_narrow_helper ("IDL:gsdlInterface/corbaiface:1.0")) != NULL) {
+    serv->_add_ref ();
+    return (POA_gsdlInterface::corbaiface *) p;
+  }
+  return NULL;
+}
+
+gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp ()
+{
+}
+
+gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
+  : CORBA::Object(*obj), PortableServer::StubBase(poa)
+{
+}
+
+gsdlInterface::corbaiface_stub_clp::~corbaiface_stub_clp ()
+{
+}
+
+#endif // MICO_CONF_NO_POA
+
+CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::Boolean _res;
   CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
 
   CORBA::StaticRequest __req( this, "initialise" );
-  __req.add_inout_arg( &_error );
+  __req.add_inout_arg( &_sa_error );
   __req.set_result( &__res );
 
@@ -1456,13 +1774,49 @@
 
 
-void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
-  CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+CORBA::Boolean
+gsdlInterface::corbaiface_stub_clp::initialise( gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      CORBA::Boolean __res;
+
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        __res = _myserv->initialise(_par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return __res;
+    }
+    _postinvoke ();
+  }
+
+  return gsdlInterface::corbaiface_stub::initialise(_par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key );
+  CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "configure" );
-  __req.add_in_arg( &_key );
-  __req.add_in_arg( &_cfgline );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_key );
+  __req.add_in_arg( &_sa_cfgline );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1473,11 +1827,45 @@
 
 
-void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->configure(_par_key, _par_cfgline, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::configure(_par_key, _par_cfgline, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "collectionList" );
-  __req.add_inout_arg( &_collist );
-  __req.add_inout_arg( &_error );
+  __req.add_inout_arg( &_sa_collist );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1488,13 +1876,47 @@
 
 
-void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
-  CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->collectionList(_par_collist, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::collectionList(_par_collist, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection );
+  CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "hasCollection" );
-  __req.add_in_arg( &_corbaCollection );
-  __req.add_inout_arg( &_has );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_corbaCollection );
+  __req.add_inout_arg( &_sa_has );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1505,13 +1927,47 @@
 
 
-void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _wasSuccess( CORBA::_stc_boolean, &wasSuccess );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->hasCollection(_par_corbaCollection, _par_has, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::hasCollection(_par_corbaCollection, _par_has, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "ping" );
-  __req.add_in_arg( &_collection );
-  __req.add_inout_arg( &_wasSuccess );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_inout_arg( &_sa_wasSuccess );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1522,15 +1978,49 @@
 
 
-void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
-  CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->ping(_par_collection, _par_wasSuccess, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::ping(_par_collection, _par_wasSuccess, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request );
+  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "getDocument" );
-  __req.add_in_arg( &_collection );
-  __req.add_inout_arg( &_request );
-  __req.add_inout_arg( &_response );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_inout_arg( &_sa_request );
+  __req.add_inout_arg( &_sa_response );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1541,13 +2031,47 @@
 
 
-void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->getDocument(_par_collection, _par_request, _par_response, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::getDocument(_par_collection, _par_request, _par_response, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "getCollectInfo" );
-  __req.add_in_arg( &_collection );
-  __req.add_inout_arg( &_response );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_inout_arg( &_sa_response );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1558,13 +2082,47 @@
 
 
-void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->getCollectInfo(_par_collection, _par_response, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::getCollectInfo(_par_collection, _par_response, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "getFilterInfo" );
-  __req.add_in_arg( &_collection );
-  __req.add_inout_arg( &_filterNames );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_inout_arg( &_sa_filterNames );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1575,15 +2133,49 @@
 
 
-void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
-  CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->getFilterInfo(_par_collection, _par_filterNames, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::getFilterInfo(_par_collection, _par_filterNames, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option );
+  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "getFilterOptions" );
-  __req.add_in_arg( &_collection );
-  __req.add_in_arg( &_option );
-  __req.add_inout_arg( &_response );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_in_arg( &_sa_option );
+  __req.add_inout_arg( &_sa_response );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1594,15 +2186,49 @@
 
 
-void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
-{
-  CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
-  CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
-  CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
-  CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->getFilterOptions(_par_collection, _par_option, _par_response, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::getFilterOptions(_par_collection, _par_option, _par_response, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request );
+  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
   CORBA::StaticRequest __req( this, "filter" );
-  __req.add_in_arg( &_collection );
-  __req.add_in_arg( &_request );
-  __req.add_inout_arg( &_response );
-  __req.add_inout_arg( &_error );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_in_arg( &_sa_request );
+  __req.add_inout_arg( &_sa_response );
+  __req.add_inout_arg( &_sa_error );
 
   __req.invoke();
@@ -1613,89 +2239,129 @@
 
 
-#ifdef HAVE_NAMESPACE
-namespace gsdlInterface { vector<CORBA::Narrow_proto> * corbaiface::_narrow_helpers; }
-#else
-vector<CORBA::Narrow_proto> * gsdlInterface::corbaiface::_narrow_helpers;
-#endif
-
-class _Marshaller_gsdlInterface_corbaiface : public CORBA::StaticTypeInfo {
-    typedef gsdlInterface::corbaiface_ptr _MICO_T;
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->filter(_par_collection, _par_request, _par_response, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::filter(_par_collection, _par_request, _par_response, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+void gsdlInterface::corbaiface_stub::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error )
+{
+  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+  CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome );
+  CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items );
+  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+  CORBA::StaticRequest __req( this, "getRssItems" );
+  __req.add_in_arg( &_sa_collection );
+  __req.add_in_arg( &_sa_gsdlhome );
+  __req.add_inout_arg( &_sa_rss_items );
+  __req.add_inout_arg( &_sa_error );
+
+  __req.invoke();
+
+  mico_sii_throw( &__req, 
+    0);
+}
+
+
+#ifndef MICO_CONF_NO_POA
+
+void
+gsdlInterface::corbaiface_stub_clp::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error )
+{
+  PortableServer::Servant _serv = _preinvoke ();
+  if (_serv) {
+    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
+    if (_myserv) {
+      #ifdef HAVE_EXCEPTIONS
+      try {
+      #endif
+        _myserv->getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error);
+      #ifdef HAVE_EXCEPTIONS
+      }
+      catch (...) {
+        _myserv->_remove_ref();
+        _postinvoke();
+        throw;
+      }
+      #endif
+
+      _myserv->_remove_ref();
+      _postinvoke ();
+      return;
+    }
+    _postinvoke ();
+  }
+
+  gsdlInterface::corbaiface_stub::getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error);
+}
+
+#endif // MICO_CONF_NO_POA
+
+class _Marshaller__seq_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbatext_t();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
-{
-  return (StaticValueType) new _MICO_T( 0 );
-}
-
-void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
-{
-  *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s );
-}
-
-void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
-{
-  CORBA::release( *(_MICO_T *) v );
+_Marshaller__seq_gsdlInterface_corbatext_t::~_Marshaller__seq_gsdlInterface_corbatext_t()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
+{
+  return (StaticValueType) new _MICO_T;
+}
+
+void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
+{
+  *(_MICO_T*) d = *(_MICO_T*) s;
+}
+
+void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
+{
   delete (_MICO_T*) v;
 }
 
-CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::Object_ptr obj;
-  if (!CORBA::_stc_Object->demarshal(dc, &obj))
-    return FALSE;
-  *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj );
-  CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v);
-  CORBA::release (obj);
-  return ret;
-}
-
-void _Marshaller_gsdlInterface_corbaiface::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::Object_ptr obj = *(_MICO_T *) v;
-  CORBA::_stc_Object->marshal( ec, &obj );
-}
-
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
-
-class _Marshaller__seq_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
-  public:
-    StaticValueType create () const;
-    void assign (StaticValueType dst, const StaticValueType src) const;
-    void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
-};
-
-
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
-{
-  return (StaticValueType) new _MICO_T;
-}
-
-void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
-{
-  *(_MICO_T*) d = *(_MICO_T*) s;
-}
-
-void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
-{
-  delete (_MICO_T*) v;
-}
-
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1704,48 +2370,108 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
-
-class _Marshaller__seq_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
+
+class _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbatext_tcollectionmeta,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
+_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::create() const
 {
   return (StaticValueType) new _MICO_T;
 }
 
-void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
+void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const
 {
   *(_MICO_T*) d = *(_MICO_T*) s;
 }
 
-void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
+void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const
 {
   delete (_MICO_T*) v;
 }
 
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
+    if( !_marshaller_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
+      return FALSE;
+  }
+  return dc.seq_end();
+}
+
+void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
+  ec.seq_begin( len );
+  for( ::CORBA::ULong i = 0; i < len; i++ )
+    _marshaller_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &(*(_MICO_T*)v)[i] );
+  ec.seq_end();
+}
+
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;
+
+class _Marshaller__seq_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
+  public:
+    ~_Marshaller__seq_gsdlInterface_corbaFilterOption();
+    StaticValueType create () const;
+    void assign (StaticValueType dst, const StaticValueType src) const;
+    void free (StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
+};
+
+
+_Marshaller__seq_gsdlInterface_corbaFilterOption::~_Marshaller__seq_gsdlInterface_corbaFilterOption()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
+{
+  return (StaticValueType) new _MICO_T;
+}
+
+void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
+{
+  *(_MICO_T*) d = *(_MICO_T*) s;
+}
+
+void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
+{
+  delete (_MICO_T*) v;
+}
+
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
+  if( !dc.seq_begin( len ) )
+    return FALSE;
+  ((_MICO_T *) v)->length( len );
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1754,27 +2480,32 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
-
-class _Marshaller__seq_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
+
+class _Marshaller__seq_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbaOptionValue();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
+_Marshaller__seq_gsdlInterface_corbaOptionValue::~_Marshaller__seq_gsdlInterface_corbaOptionValue()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1791,11 +2522,11 @@
 }
 
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1804,27 +2535,32 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
-
-class _Marshaller__seq_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
+
+class _Marshaller__seq_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbaTermInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
+_Marshaller__seq_gsdlInterface_corbaTermInfo::~_Marshaller__seq_gsdlInterface_corbaTermInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1841,11 +2577,11 @@
 }
 
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1854,27 +2590,32 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
-
-class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
+
+class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbaMetadataInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
+_Marshaller__seq_gsdlInterface_corbaMetadataInfo::~_Marshaller__seq_gsdlInterface_corbaMetadataInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1891,11 +2632,11 @@
 }
 
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1904,27 +2645,32 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
-
-class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
-    typedef SequenceTmpl<gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
+
+class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo {
+    typedef SequenceTmpl< gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
   public:
+    ~_Marshaller__seq_gsdlInterface_corbaResultDocInfo();
     StaticValueType create () const;
     void assign (StaticValueType dst, const StaticValueType src) const;
     void free (StaticValueType) const;
-    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
-    void marshal (CORBA::DataEncoder &, StaticValueType) const;
+    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
+    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
 };
 
 
-CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
+_Marshaller__seq_gsdlInterface_corbaResultDocInfo::~_Marshaller__seq_gsdlInterface_corbaResultDocInfo()
+{
+}
+
+::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
 {
   return (StaticValueType) new _MICO_T;
@@ -1941,11 +2687,11 @@
 }
 
-CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
-{
-  CORBA::ULong len;
+::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
+{
+  ::CORBA::ULong len;
   if( !dc.seq_begin( len ) )
     return FALSE;
   ((_MICO_T *) v)->length( len );
-  for( CORBA::ULong i = 0; i < len; i++ ) {
+  for( ::CORBA::ULong i = 0; i < len; i++ ) {
     if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
       return FALSE;
@@ -1954,14 +2700,14 @@
 }
 
-void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
-{
-  CORBA::ULong len = ((_MICO_T *) v)->length();
+void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
+{
+  ::CORBA::ULong len = ((_MICO_T *) v)->length();
   ec.seq_begin( len );
-  for( CORBA::ULong i = 0; i < len; i++ )
+  for( ::CORBA::ULong i = 0; i < len; i++ )
     _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
   ec.seq_end();
 }
 
-CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
+::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
 
 struct __tc_init_CORBAIFACE {
@@ -1970,4 +2716,5 @@
     _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t;
     _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap;
+    _marshaller_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller_gsdlInterface_corbatext_tcollectionmeta;
     _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError;
     _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo;
@@ -1989,4 +2736,5 @@
     _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface;
     _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t;
+    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;
     _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption;
     _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue;
@@ -1995,6 +2743,357 @@
     _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo;
   }
+
+  ~__tc_init_CORBAIFACE()
+  {
+    delete static_cast<_Marshaller_gsdlInterface_corbatext_t*>(_marshaller_gsdlInterface_corbatext_t);
+    delete static_cast<_Marshaller_gsdlInterface_corbatext_tmap*>(_marshaller_gsdlInterface_corbatext_tmap);
+    delete static_cast<_Marshaller_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller_gsdlInterface_corbatext_tcollectionmeta);
+    delete static_cast<_Marshaller_gsdlInterface_corbaComError*>(_marshaller_gsdlInterface_corbaComError);
+    delete static_cast<_Marshaller_gsdlInterface_corbaShortColInfo*>(_marshaller_gsdlInterface_corbaShortColInfo);
+    delete static_cast<_Marshaller_gsdlInterface_corbaColInfoResponse*>(_marshaller_gsdlInterface_corbaColInfoResponse);
+    delete static_cast<_Marshaller_gsdlInterface_corbaDocRequest*>(_marshaller_gsdlInterface_corbaDocRequest);
+    delete static_cast<_Marshaller_gsdlInterface_corbaDocResponse*>(_marshaller_gsdlInterface_corbaDocResponse);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterType*>(_marshaller_gsdlInterface_corbaFilterType);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterRepeatable*>(_marshaller_gsdlInterface_corbaFilterRepeatable);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterOption*>(_marshaller_gsdlInterface_corbaFilterOption);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterOptionsResponse*>(_marshaller_gsdlInterface_corbaFilterOptionsResponse);
+    delete static_cast<_Marshaller_gsdlInterface_corbaOptionValue*>(_marshaller_gsdlInterface_corbaOptionValue);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterRequest*>(_marshaller_gsdlInterface_corbaFilterRequest);
+    delete static_cast<_Marshaller_gsdlInterface_corbaTermInfo*>(_marshaller_gsdlInterface_corbaTermInfo);
+    delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo*>(_marshaller_gsdlInterface_corbaMetadataInfo);
+    delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo_map*>(_marshaller_gsdlInterface_corbaMetadataInfo_map);
+    delete static_cast<_Marshaller_gsdlInterface_corbaResultDocInfo*>(_marshaller_gsdlInterface_corbaResultDocInfo);
+    delete static_cast<_Marshaller_gsdlInterface_corbaIsApprox*>(_marshaller_gsdlInterface_corbaIsApprox);
+    delete static_cast<_Marshaller_gsdlInterface_corbaFilterResponse*>(_marshaller_gsdlInterface_corbaFilterResponse);
+    delete static_cast<_Marshaller_gsdlInterface_corbaiface*>(_marshaller_gsdlInterface_corbaiface);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_t*>(_marshaller__seq_gsdlInterface_corbatext_t);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbaFilterOption*>(_marshaller__seq_gsdlInterface_corbaFilterOption);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbaOptionValue*>(_marshaller__seq_gsdlInterface_corbaOptionValue);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbaTermInfo*>(_marshaller__seq_gsdlInterface_corbaTermInfo);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbaMetadataInfo*>(_marshaller__seq_gsdlInterface_corbaMetadataInfo);
+    delete static_cast<_Marshaller__seq_gsdlInterface_corbaResultDocInfo*>(_marshaller__seq_gsdlInterface_corbaResultDocInfo);
+  }
 };
 
 static __tc_init_CORBAIFACE __init_CORBAIFACE;
 
+//--------------------------------------------------------
+//  Implementation of skeletons
+//--------------------------------------------------------
+
+// PortableServer Skeleton Class for interface gsdlInterface::corbaiface
+POA_gsdlInterface::corbaiface::~corbaiface()
+{
+}
+
+::gsdlInterface::corbaiface_ptr
+POA_gsdlInterface::corbaiface::_this ()
+{
+  CORBA::Object_var obj = PortableServer::ServantBase::_this();
+  return ::gsdlInterface::corbaiface::_narrow (obj);
+}
+
+CORBA::Boolean
+POA_gsdlInterface::corbaiface::_is_a (const char * repoid)
+{
+  if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
+    return TRUE;
+  }
+  return FALSE;
+}
+
+CORBA::InterfaceDef_ptr
+POA_gsdlInterface::corbaiface::_get_interface ()
+{
+  CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:gsdlInterface/corbaiface:1.0");
+
+  if (CORBA::is_nil (ifd)) {
+    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
+  }
+
+  return ifd;
+}
+
+CORBA::RepositoryId
+POA_gsdlInterface::corbaiface::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
+{
+  return CORBA::string_dup ("IDL:gsdlInterface/corbaiface:1.0");
+}
+
+CORBA::Object_ptr
+POA_gsdlInterface::corbaiface::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
+{
+  return new ::gsdlInterface::corbaiface_stub_clp (poa, obj);
+}
+
+bool
+POA_gsdlInterface::corbaiface::dispatch (CORBA::StaticServerRequest_ptr __req)
+{
+  #ifdef HAVE_EXCEPTIONS
+  try {
+  #endif
+    switch (mico_string_hash (__req->op_name(), 17)) {
+    case 0:
+      if( strcmp( __req->op_name(), "collectionList" ) == 0 ) {
+        ::gsdlInterface::corbatext_tarray _par_collist;
+        CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_inout_arg( &_sa_collist );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        collectionList( _par_collist, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 3:
+      if( strcmp( __req->op_name(), "ping" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        CORBA::Boolean _par_wasSuccess;
+        CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_inout_arg( &_sa_wasSuccess );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        ping( _par_collection, _par_wasSuccess, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 7:
+      if( strcmp( __req->op_name(), "filter" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbaFilterRequest _par_request;
+        CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request );
+        ::gsdlInterface::corbaFilterResponse _par_response;
+        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_in_arg( &_sa_request );
+        __req->add_inout_arg( &_sa_response );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        filter( _par_collection, _par_request, _par_response, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 8:
+      if( strcmp( __req->op_name(), "getRssItems" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbatext_t _par_gsdlhome;
+        CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome );
+        ::gsdlInterface::corbatext_t _par_rss_items;
+        CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_in_arg( &_sa_gsdlhome );
+        __req->add_inout_arg( &_sa_rss_items );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        getRssItems( _par_collection, _par_gsdlhome, _par_rss_items, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 9:
+      if( strcmp( __req->op_name(), "getFilterOptions" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbatext_t _par_option;
+        CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option );
+        ::gsdlInterface::corbaFilterOptionsResponse _par_response;
+        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_in_arg( &_sa_option );
+        __req->add_inout_arg( &_sa_response );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        getFilterOptions( _par_collection, _par_option, _par_response, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 10:
+      if( strcmp( __req->op_name(), "getCollectInfo" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbaColInfoResponse _par_response;
+        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_inout_arg( &_sa_response );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        getCollectInfo( _par_collection, _par_response, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 11:
+      if( strcmp( __req->op_name(), "initialise" ) == 0 ) {
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        CORBA::Boolean _res;
+        CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
+        __req->add_inout_arg( &_sa_error );
+        __req->set_result( &__res );
+
+        if( !__req->read_args() )
+          return true;
+
+        _res = initialise( _par_error );
+        __req->write_results();
+        return true;
+      }
+      if( strcmp( __req->op_name(), "getFilterInfo" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbatext_tarray _par_filterNames;
+        CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_inout_arg( &_sa_filterNames );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        getFilterInfo( _par_collection, _par_filterNames, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 12:
+      if( strcmp( __req->op_name(), "hasCollection" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_corbaCollection;
+        CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection );
+        CORBA::Boolean _par_has;
+        CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_corbaCollection );
+        __req->add_inout_arg( &_sa_has );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        hasCollection( _par_corbaCollection, _par_has, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    case 13:
+      if( strcmp( __req->op_name(), "configure" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_key;
+        CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key );
+        ::gsdlInterface::corbatext_tarray _par_cfgline;
+        CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_key );
+        __req->add_in_arg( &_sa_cfgline );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        configure( _par_key, _par_cfgline, _par_error );
+        __req->write_results();
+        return true;
+      }
+      if( strcmp( __req->op_name(), "getDocument" ) == 0 ) {
+        ::gsdlInterface::corbatext_t _par_collection;
+        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
+        ::gsdlInterface::corbaDocRequest _par_request;
+        CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request );
+        ::gsdlInterface::corbaDocResponse _par_response;
+        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response );
+        ::gsdlInterface::corbaComError _par_error;
+        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
+
+        __req->add_in_arg( &_sa_collection );
+        __req->add_inout_arg( &_sa_request );
+        __req->add_inout_arg( &_sa_response );
+        __req->add_inout_arg( &_sa_error );
+
+        if( !__req->read_args() )
+          return true;
+
+        getDocument( _par_collection, _par_request, _par_response, _par_error );
+        __req->write_results();
+        return true;
+      }
+      break;
+    }
+  #ifdef HAVE_EXCEPTIONS
+  } catch( CORBA::SystemException_catch &_ex ) {
+    __req->set_exception( _ex->_clone() );
+    __req->write_results();
+    return true;
+  } catch( ... ) {
+    CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
+    __req->set_exception (_ex->_clone());
+    __req->write_results ();
+    return true;
+  }
+  #endif
+
+  return false;
+}
+
+void
+POA_gsdlInterface::corbaiface::invoke (CORBA::StaticServerRequest_ptr __req)
+{
+  if (dispatch (__req)) {
+      return;
+  }
+
+  CORBA::Exception * ex = 
+    new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
+  __req->set_exception (ex);
+  __req->write_results();
+}
+
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaproto.h
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaproto.h	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaproto.h	(revision 25231)
@@ -32,4 +32,6 @@
 #include "recptproto.h"
 #include "corbaiface.h"
+
+
 using namespace gsdlInterface;
 
@@ -40,6 +42,6 @@
   collectservermapclass cservers;
   corbaiface_var        client;
-  CORBA::ORB_var        orb;
-  CORBA::BOA_var        boa;
+  //CORBA::ORB_var        orb;
+  //CORBA::BOA_var        boa;
   CORBA::Object_var     obj;
   text_t gsdlhome;
Index: main/trunk/greenstone2/runtime-src/src/corba/corbaproto.mpp
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbaproto.mpp	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbaproto.mpp	(revision 25231)
@@ -26,6 +26,8 @@
  *********************************************************************/
 
-#include <iostream.h>
-#include <fstream.h>
+#define USE_POA
+
+#include <iostream>
+#include <fstream>
 
 #include "fileutil.h"
@@ -63,5 +65,5 @@
       here ++;
     }
-  //  cout << "Options " << i << endl;
+  //  std::cout << "Options " << i << std::endl;
 }
 
@@ -190,5 +192,5 @@
 	    }
 
-	  cout << "Parent " << mi << " " << (int) &mhere->second << " " << (int) mhere->second.parent << endl;
+	  std::cout << "Parent " << mi << " " << (off_t) &mhere->second << " " << (off_t) mhere->second.parent << std::endl;
 
 	  mhere ++;
@@ -308,5 +310,12 @@
 
   CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
-  CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );
+
+#if defined(USE_POA)
+    CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA");
+    PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj);
+    poa->the_POAManager()->activate();
+#else
+    CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );
+#endif
 
   char objid_filename[256];
@@ -344,5 +353,13 @@
   // DB // Try this out!! // ****
   CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
-  CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );
+
+#if defined(USE_POA)
+    CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA");
+    PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj);
+
+    poa->the_POAManager()->activate();
+#else
+    CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );
+#endif
 
   /*  char* site_name_chars = site_name.getcstr();
@@ -375,5 +392,5 @@
   // created
 
-  // cout << "Corbaproto::Configure" << endl;
+  // std::cout << "Corbaproto::Configure" << std::endl;
   corbatext_t      corbaKey;
   corbatext_tarray corbaCfgline;
@@ -403,5 +420,5 @@
 // this init will configure and init each of the collection servers
 bool corbaproto::init (comerror_t &err, ostream &logout) {
-//  cout << "Corbaproto::Init" << endl;
+//  std::cout << "Corbaproto::Init" << std::endl;
   gsdlInterface::corbaComError error = corbaNoError;
 
@@ -426,5 +443,5 @@
       text_t format_line = format_here->second;
 
-      // cout << "*** format line = " << format_line << endl; // ****
+      // std::cout << "*** format line = " << format_line << std::endl; // ****
 
       text_t::iterator fl_begin = format_line.begin();
@@ -494,5 +511,5 @@
 				     ostream &/*logout*/) {
 
-  // cout << "Corbaproto::Collection list" << endl;
+  // std::cout << "Corbaproto::Collection list" << std::endl;
 
   corbatext_tarray corba_collist;
@@ -516,5 +533,5 @@
 void corbaproto::has_collection (const text_t &collection, bool &hascollection, 
 				comerror_t &err, ostream &/*logout*/) {
-  // cout << "Corbaproto::Has collection" << endl;
+  // std::cout << "Corbaproto::Has collection" << std::endl;
 
   corbatext_t     corbaCollection;
@@ -539,5 +556,5 @@
 void corbaproto::ping (const text_t &collection, bool &wassuccess, 
 		      comerror_t &err, ostream &/*logout*/) {
-  // cout << "Corbaproto::Ping" << endl;
+  // std::cout << "Corbaproto::Ping" << std::endl;
 
   corbatext_t corbaCollect;
@@ -558,5 +575,5 @@
   wassuccess = (success != 0);
   err = (comerror_t) corbaError;  
-  cout << "Corbaproto::Ping" << err << endl;
+  std::cout << "Corbaproto::Ping" << err << std::endl;
 }
 
@@ -565,5 +582,5 @@
 				 ColInfoResponse_t &collectinfo,
 				 comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Collectinfo" << endl;
+  //  std::cout << "Corbaproto::Collectinfo" << std::endl;
 
   corbatext_t          corbaCollection;
@@ -591,5 +608,5 @@
   collectinfo.numWords  = corbaCollectInfo.numWords;
   collectinfo.numBytes  = corbaCollectInfo.numBytes;
-  corbatext_corbaMapToMap(corbaCollectInfo.collectionMeta, collectinfo.collectionmeta);
+  corbatext_corbaColmetamapToColmetamap(corbaCollectInfo.collectionMeta, collectinfo.collectionmeta);
   corbatext_corbaMapToMap(corbaCollectInfo.format, collectinfo.format);
   corbatext_corbaMapToMap(corbaCollectInfo.building, collectinfo.building);
@@ -598,4 +615,30 @@
   corbaconv_text_t::setCorbatext(collectinfo.receptionist,corbaCollectInfo.receptionist);
 
+  // Member variables in comtools mirrored in corbaiface (and corbaproto) on 14/03/2012.
+  // shortInfo (previously mistyped as "shoftInfo" in corbaiface.idl) has 3 simple fields
+  corbaconv_text_t::setCorbatext(collectinfo.shortInfo.name, corbaCollectInfo.shortInfo.name);
+  corbaconv_text_t::setCorbatext(collectinfo.shortInfo.host, corbaCollectInfo.shortInfo.host);
+  collectinfo.shortInfo.port = corbaCollectInfo.shortInfo.response;
+  
+  collectinfo.isSegmented = corbaCollectInfo.isSegmented;
+  collectinfo.isCollectGroup = corbaCollectInfo.isCollectGroup;
+
+  collectinfo.numSections = corbaCollectInfo.numSections;
+  collectinfo.ccsOptions = corbaCollectInfo.ccsOptions;
+  collectinfo.stemIndexes = corbaCollectInfo.stemIndexes;
+
+  corbatext_corbaColmetamapToColmetamap(corbaCollectInfo.collection_macros, collectinfo.collection_macros);
+
+  corbaconv_text_t::setCorbatext(collectinfo.buildType,corbaCollectInfo.buildType);
+  corbaconv_text_t::setCorbatext(collectinfo.infodbType,corbaCollectInfo.infodbType);
+  corbaconv_text_t::setCorbatext(collectinfo.authenticate,corbaCollectInfo.authenticate);
+  corbaconv_text_t::setCorbatext(collectinfo.auth_group,corbaCollectInfo.auth_group);
+  corbaconv_text_t::setCorbatext(collectinfo.earliestDatestamp,corbaCollectInfo.earliestDatestamp);
+
+  corbatext_corbaMapToMap(corbaCollectInfo.public_documents, collectinfo.public_documents);
+  corbatext_corbaMapToMap(corbaCollectInfo.private_documents, collectinfo.private_documents);
+  corbatext_corbaMapToMap(corbaCollectInfo.dynamic_classifiers, collectinfo.dynamic_classifiers);
+
+
   cache_missing_icons(collectinfo.format,collectinfo.httpdomain,
 		      collectinfo.httpprefix);
@@ -608,5 +651,5 @@
 				InfoFiltersResponse_t &response,
 				comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filterinfo" << endl;
+  //  std::cout << "Corbaproto::Filterinfo" << std::endl;
 
   corbatext_t corbaCollection;
@@ -634,5 +677,5 @@
 				   InfoFilterOptionsResponse_t &response, 
 				   comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filteroptions" << endl;
+  //  std::cout << "Corbaproto::Filteroptions" << std::endl;
 
   corbatext_t corbaCollection;
@@ -688,15 +731,16 @@
   corbaconv_text_t::getCorbatext(collection,corbaCollection);
   corbaconv_text_t::getCorbatext(gsdlhome,corbaGsdlHome);
-  corbaconv_text_t::getCorbatext(rss_items,corbaRssItems);
-
-  // get the corba client reference
-  // corbaiface_var lclient = this->getCorbaClient(); // ****
-  corbaiface_var lclient = client;
-
-  // execute the corba transaction
-  lclient->get_rss_items (corbaCollection, corbaGsdlHome, corbaRssItems, corbaError);
+
+  // get the corba client reference
+  // corbaiface_var lclient = this->getCorbaClient(); // ****
+  corbaiface_var lclient = client;
+
+  // execute the corba transaction
+  lclient->getRssItems (corbaCollection, corbaGsdlHome, corbaRssItems, corbaError);
+
+  err =  (comerror_t) corbaError;
 
   // convert the response back to normal form
-  rss_items = corbaRssItems;
+  corbaconv_text_t::setCorbatext(rss_items,corbaRssItems);
 }
 
@@ -705,5 +749,5 @@
 			  FilterResponse_t &response,
 			  comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filter" << endl;
+  //  std::cout << "Corbaproto::Filter" << std::endl;
 
   corbaFilterRequest corbaRequest;
@@ -742,5 +786,5 @@
 
   err = (comerror_t) corbaError;
-  //  cout << "Corbaproto::Filter" << endl;
+  //  std::cout << "Corbaproto::Filter" << std::endl;
 }
 
@@ -750,5 +794,5 @@
 			       DocumentResponse_t &response,
 			       comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Get Document" << endl;
+  //  std::cout << "Corbaproto::Get Document" << std::endl;
 
   corbatext_t      corbaCollect;
Index: main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.h
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.h	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.h	(revision 25231)
@@ -1,4 +1,6 @@
+#include "comtypes.h"
+
 void corbatext_fillChar(corbatext_t *t, char *text);
-void corbatext_usvector(corbatext_t t, vector<unsigned short>& us);
+void corbatext_usvector(corbatext_t t, std::vector<unsigned short>& us);
 char *corbatext_string(corbatext_t t);
 #ifdef TEXT_T_H
@@ -12,2 +14,6 @@
 int corbatext_corbatext(text_t t, corbatext_t_var ct);
 #endif
+#ifdef COMTYPES_H
+void corbatext_colmetamapToCorbaColmetamap(collectionmeta_map cm, corbatext_tcollectionmeta_map *ccm);
+void corbatext_corbaColmetamapToColmetamap(corbatext_tcollectionmeta_map ccm, collectionmeta_map &cm);
+#endif
Index: main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.mpp
===================================================================
--- main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.mpp	(revision 25230)
+++ main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.mpp	(revision 25231)
@@ -85,4 +85,6 @@
   ct->encoding = 0;
   cout << "C" << endl;
+
+  return 0;
 }
 
@@ -178,2 +180,52 @@
 }
 
+
+// map of metanames to array(lang, value). So each metaname[i] maps to array (lang, value).
+// Note that corbacollectionmeta_map is an array of pairs
+// each pair consists of (string, map)
+void corbatext_colmetamapToCorbaColmetamap(collectionmeta_map cm, corbatext_tcollectionmeta_map *ccm)
+{
+  collectionmeta_map::iterator here = cm.begin();
+  collectionmeta_map::iterator end  = cm.end();
+  unsigned int i = 0;
+
+  while (here != end)
+    {
+      ccm->length(i+1); // increase size of array of (name, tuples) pairs by 1 each time
+
+      // fill in the metaname field
+      // metaname is of type text_t, get the corbatext value for the text_t key
+      (*ccm)[i].name = *corbatext_corbatext((*here).first); // metaname is of type text_t
+
+      // fill in the tuples field
+      corbatext_mapToCorbaMap((*here).second, &((*ccm)[i].tuples));
+
+      here ++;
+      i ++;
+    }
+
+}
+
+void corbatext_corbaColmetamapToColmetamap(corbatext_tcollectionmeta_map ccm, collectionmeta_map &cm)
+{
+  unsigned int i;
+
+  for (i = 0; i < ccm.length(); i ++) 
+    {
+    // ccm is an array
+    // where each element is a pair of (name, tuples)
+
+    // 1. get the (corba_text_t) name and convert it to text_t
+    text_t* meta_name = new corbaconv_text_t(ccm[i].name);
+
+    corbatext_tmap corbameta_tuples = ccm[i].tuples;
+
+    text_tmap *tuples_map = new text_tmap();
+    corbatext_corbaMapToMap(ccm[i].tuples, *tuples_map);
+
+
+    cm.insert(make_pair(*meta_name,
+    			*tuples_map));			
+    }
+}
+
