Changeset 25231

Timestamp:

2012-03-16T21:38:01+13:00 (12 years ago)

Author:

ak19

Message:

Many changes to get corba working again ever since the addition of RSS support meant that the method get_rss_items needed to be mirrored in the corba code. The corba code was not compiling then and it turned out we needed a later version of Mico's corba implementation (2.3.13 up from 2.3.5). Therefore the current commit not only corrects some errors in the recently added getRssItems() method but includes further changes: 1. namespaced use of iostream functions were required in some mpp files. 2. New types and member variables added to the corbaiface.idl interface file, to mirror the presence of equivalent variables in comtools.h which hadn't been ported over yet. (Such as the complex corba data type equivalent of collectionmetamap used in comtools.h.) This required (de)serialisation methods to be declared and implemented in corbatext_t.h and corbatext_t.mpp. The additional member variables for the corbaColInfoResponse in corbaiface.idl are now also unpacked in corbaproto.mpp along with the rest of the data structure. 3. Having changed from mico version 2.3.5 to 2.3.13 required code to changed to use POA instead of BOA. This also meant that skeleton files were no longer to be generated when running idl over corbaiface.idl. corbaserver inherits from a POA related object now instead of from the skeleton. 4. Makefile.in was updated to reflect these changes (absence of skeleton), includes a target to run IDL over the corbaiface.idl file to generate the necessary helper files, and corrects earlier oversights in updating the corba makefile with the rest of the changes made over time to runtime-src.

Location:

main/trunk/greenstone2/runtime-src/src/corba

Files:

• Makefile.in (modified) (8 diffs)
• corbaServer.mpp (modified) (20 diffs)
• corbaclient.mpp (modified) (1 diff)
• corbaiface.h (modified) (23 diffs)
• corbaiface.idl (modified) (5 diffs)
• corbaiface.mpp (modified) (99 diffs)
• corbaproto.h (modified) (2 diffs)
• corbaproto.mpp (modified) (21 diffs)
• corbatext_t.h (modified) (2 diffs)
• corbatext_t.mpp (modified) (2 diffs)

main/trunk/greenstone2/runtime-src/src/corba/Makefile.in

@@ -39 +39 @@
 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 +49 @@
 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 +59 @@
 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 +91 @@
 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 +102 @@
 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 +126 @@
     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 +177 @@
 
 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 +192 @@
 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

main/trunk/greenstone2/runtime-src/src/corba/corbaServer.mpp

@@ +1 @@
+#define USE_POA
+
 // Standard headers
-#include <iostream.h>
-#include <fstream.h>
+#include <iostream>
+#include <fstream>
 
 // protocol headers
@@ -44 +46 @@
       here ++;
     }
-  cout << "Terminfo " << i << endl;
+  std::cout << "Terminfo " << i << std::endl;
 }
 
@@ -57 +59 @@
       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 +65 @@
 }
 
-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 +92 @@
     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 +132 @@
 
       // ****
-      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 +144 @@
       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 +150 @@
     {
       // 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 +174 @@
     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 +186 @@
       }
 
-    // cout << "  " << has << endl;
+    // std::cout << "  " << has << std::endl;
 
     delete cct;
@@ -245 +249 @@
     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 +266 @@
     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 +284 @@
     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 +296 @@
     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 +366 @@
 
     corbaconv_text_t::setCorbatext(collection,corbaCollect);
-    cout << collection.getcstr() << endl;
+    std::cout << collection.getcstr() << std::endl;
                 
     protocol->get_filterinfo(collection, response, error, logout);
@@ -399 +403 @@
   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 +420 @@
     protocol->get_rss_items(collection, gsdlhome, rss_items, error, logout);
     corbaconv_text_t::getCorbatext(rss_items,corbaRssItems);
-
+    
     // decode response
     corbaError = (corbaComError) error;
@@ -433 +437 @@
     ofstream logout;
 
-    cout << "Received collection list request" << endl;
+    std::cout << "Received collection list request" << std::endl;
 
     this->openLogfile("/etc/corbaout.txt", logout);
@@ -453 +457 @@
 
     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 +476 @@
   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;
 }
 
-

main/trunk/greenstone2/runtime-src/src/corba/corbaclient.mpp

@@ -75 +75 @@
   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;
   }

main/trunk/greenstone2/runtime-src/src/corba/corbaiface.h

@@ -1 +1 @@
 /*
- *  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 +65 @@
 };
 
-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 +92 @@
   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 +128 @@
 
 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 +149 @@
 
 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 +164 @@
   #endif //HAVE_EXPLICIT_STRUCT_OPS
 
-  corbaShortColInfo shoftInfo;
+  corbaShortColInfo shortInfo;
   CORBA::Boolean useBook;
   CORBA::Boolean isPublic;
@@ -143 +174 @@
   CORBA::ULong numWords;
   CORBA::ULong numBytes;
-  corbatext_tmap collectionMeta;
+  corbatext_tcollectionmeta_map collectionMeta;
   corbatext_tmap format;
   corbatext_tmap building;
@@ -149 +180 @@
   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 +218 @@
 
 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 +254 @@
 
 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 +276 @@
 };
 
-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 +301 @@
 
 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 +320 @@
 };
 
-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 +351 @@
 
 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 +371 @@
 };
 
-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 +398 @@
 };
 
-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 +422 @@
 };
 
-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 +454 @@
 };
 
-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 +467 @@
 
 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 +488 @@
 };
 
-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 +518 @@
 
     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 +544 @@
   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 +560 @@
 };
 
-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

main/trunk/greenstone2/runtime-src/src/corba/corbaiface.idl

@@ -23 +23 @@
   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 +64 @@
 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 +75 @@
   unsigned long     numWords;
   unsigned long     numBytes;
-  corbatext_tmap    collectionMeta;
+  corbatext_tcollectionmeta_map    collectionMeta; //corbatext_tmap    collectionMeta;
   corbatext_tmap    format;
   corbatext_tmap    building;
@@ -63 +81 @@
   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 +264 @@
                    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);
+
+};
+
+};

main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp

@@ -1 +1 @@
 /*
- *  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 +42 @@
 #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 +73 @@
 }
 
-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 +83 @@
 }
 
-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 +92 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
 
 
@@ -112 +120 @@
 #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 +151 @@
 }
 
-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 +160 @@
 }
 
-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 +168 @@
 }
 
-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 +277 @@
 }
 
-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 +286 @@
 }
 
-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 +319 @@
 #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 +350 @@
 }
 
-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 +360 @@
 }
 
-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 +369 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -280 +378 @@
 gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s )
 {
-  shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
+  shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
   useBook = ((corbaColInfoResponse&)_s).useBook;
   isPublic = ((corbaColInfoResponse&)_s).isPublic;
@@ -296 +394 @@
   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 +417 @@
 gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s )
 {
-  shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
+  shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
   useBook = ((corbaColInfoResponse&)_s).useBook;
   isPublic = ((corbaColInfoResponse&)_s).isPublic;
@@ -321 +433 @@
   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 +482 @@
 }
 
-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 +496 @@
     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 +502 @@
     _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 +532 @@
   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 +538 @@
   _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 +583 @@
 #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 +614 @@
 }
 
-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 +624 @@
 }
 
-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 +633 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -493 +657 @@
 #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 +688 @@
 }
 
-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 +696 @@
 }
 
-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 +703 @@
 }
 
-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 +737 @@
 }
 
-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 +746 @@
 }
 
-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 +785 @@
 }
 
-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 +794 @@
 }
 
-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 +831 @@
 #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 +862 @@
 }
 
-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 +874 @@
 }
 
-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 +885 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
 
 
@@ -728 +912 @@
 #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 +943 @@
 }
 
-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 +952 @@
 }
 
-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 +960 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -797 +986 @@
 #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 +1017 @@
 }
 
-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 +1026 @@
 }
 
-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 +1034 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
 
 
@@ -879 +1073 @@
 #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 +1104 @@
 }
 
-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 +1119 @@
 }
 
-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 +1133 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
 
 #ifdef HAVE_EXPLICIT_STRUCT_OPS
@@ -962 +1161 @@
 #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 +1192 @@
 }
 
-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 +1202 @@
 }
 
-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 +1211 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
 
 
@@ -1040 +1244 @@
 #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 +1275 @@
 }
 
-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 +1287 @@
 }
 
-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 +1298 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
 
 
@@ -1116 +1325 @@
 #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 +1356 @@
 }
 
-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 +1365 @@
 }
 
-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 +1373 @@
 }
 
-CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
+::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
 
 
@@ -1202 +1416 @@
 #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 +1447 @@
 }
 
-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 +1464 @@
 }
 
-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 +1480 @@
 }
 
-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 +1515 @@
 }
 
-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 +1524 @@
 }
 
-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 +1559 @@
 #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 +1590 @@
 }
 
-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 +1601 @@
 }
 
-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 +1611 @@
 }
 
-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 +1638 @@
     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 +1653 @@
 }
 
+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 +1774 @@
 
 
-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 +1827 @@
 
 
-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 +1876 @@
 
 
-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 +1927 @@
 
 
-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 +1978 @@
 
 
-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 +2031 @@
 
 
-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 +2082 @@
 
 
-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 +2133 @@
 
 
-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 +2186 @@
 
 
-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 +2239 @@
 
 
-#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 +2370 @@
 }
 
-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 +2480 @@
 }
 
-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 +2522 @@
 }
 
-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 +2535 @@
 }
 
-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 +2577 @@
 }
 
-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 +2590 @@
 }
 
-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 +2632 @@
 }
 
-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 +2645 @@
 }
 
-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 +2687 @@
 }
 
-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 +2700 @@
 }
 
-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 +2716 @@
     _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 +2736 @@
     _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 +2743 @@
     _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();
+}
+

main/trunk/greenstone2/runtime-src/src/corba/corbaproto.h

@@ -32 +32 @@
 #include "recptproto.h"
 #include "corbaiface.h"
+
+
 using namespace gsdlInterface;
 
@@ -40 +42 @@
   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;

main/trunk/greenstone2/runtime-src/src/corba/corbaproto.mpp

@@ -26 +26 @@
  *********************************************************************/
 
-#include <iostream.h>
-#include <fstream.h>
+#define USE_POA
+
+#include <iostream>
+#include <fstream>
 
 #include "fileutil.h"
@@ -63 +65 @@
       here ++;
     }
-  //  cout << "Options " << i << endl;
+  //  std::cout << "Options " << i << std::endl;
 }
 
@@ -190 +192 @@
         }
 
-      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 +310 @@
 
   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 +353 @@
   // 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 +392 @@
   // created
 
-  // cout << "Corbaproto::Configure" << endl;
+  // std::cout << "Corbaproto::Configure" << std::endl;
   corbatext_t      corbaKey;
   corbatext_tarray corbaCfgline;
@@ -403 +420 @@
 // 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 +443 @@
       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 +511 @@
                      ostream &/*logout*/) {
 
-  // cout << "Corbaproto::Collection list" << endl;
+  // std::cout << "Corbaproto::Collection list" << std::endl;
 
   corbatext_tarray corba_collist;
@@ -516 +533 @@
 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 +556 @@
 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 +575 @@
   wassuccess = (success != 0);
   err = (comerror_t) corbaError;  
-  cout << "Corbaproto::Ping" << err << endl;
+  std::cout << "Corbaproto::Ping" << err << std::endl;
 }
 
@@ -565 +582 @@
                  ColInfoResponse_t &collectinfo,
                  comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Collectinfo" << endl;
+  //  std::cout << "Corbaproto::Collectinfo" << std::endl;
 
   corbatext_t          corbaCollection;
@@ -591 +608 @@
   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 +615 @@
   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 +651 @@
                 InfoFiltersResponse_t &response,
                 comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filterinfo" << endl;
+  //  std::cout << "Corbaproto::Filterinfo" << std::endl;
 
   corbatext_t corbaCollection;
@@ -634 +677 @@
                    InfoFilterOptionsResponse_t &response, 
                    comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filteroptions" << endl;
+  //  std::cout << "Corbaproto::Filteroptions" << std::endl;
 
   corbatext_t corbaCollection;
@@ -688 +731 @@
   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 +749 @@
               FilterResponse_t &response,
               comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Filter" << endl;
+  //  std::cout << "Corbaproto::Filter" << std::endl;
 
   corbaFilterRequest corbaRequest;
@@ -742 +786 @@
 
   err = (comerror_t) corbaError;
-  //  cout << "Corbaproto::Filter" << endl;
+  //  std::cout << "Corbaproto::Filter" << std::endl;
 }
 
@@ -750 +794 @@
                    DocumentResponse_t &response,
                    comerror_t &err, ostream &logout) {
-  //  cout << "Corbaproto::Get Document" << endl;
+  //  std::cout << "Corbaproto::Get Document" << std::endl;
 
   corbatext_t      corbaCollect;

main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.h

@@ +1 @@
+#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 +14 @@
 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

main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.mpp

@@ -85 +85 @@
   ct->encoding = 0;
   cout << "C" << endl;
+
+  return 0;
 }
 
@@ -178 +180 @@
 }
 
+
+// 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));          
+    }
+}
+