Show
Ignore:
Timestamp:
16.03.2012 21:38:01 (8 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:
10 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone2/runtime-src/src/corba/Makefile.in

    r22058 r25231  
    3939ENABLE_ACCENTFOLD = @ENABLE_ACCENTFOLD@ 
    4040ifeq ($(ENABLE_ACCENTFOLD), 1) 
    41 ACCENTFOLD_LIBS = $(INDEXERS_DIR)/packages/unac/libunac.a  
     41ACCENTFOLD_LIBS = $(INDEXERS_DIR)/packages/unac/libunac.a $(COMMON_PACKAGES_DIR)/iconv/lib/libiconv.a 
    4242else 
    4343ACCENTFOLD_LIBS =  
     
    4949MG_INDEXERS_LIBS = $(INDEXERS_DIR)/mg/src/text/libmgtext.a \ 
    5050    $(INDEXERS_DIR)/mg/lib/libmglib.a 
     51MG_INCLUDES = -I$(INDEXERS_DIR)/mg/lib 
    5152else 
    5253MG_INDEXERS_LIBS = 
     54MG_INCLUDES = 
    5355endif 
    5456 
     
    5759MGPP_INDEXERS_LIBS = $(INDEXERS_DIR)/mgpp/text/libmgpptext.a \ 
    5860    $(INDEXERS_DIR)/mgpp/lib/libmgpplib.a 
    59 MGPP_INCLUDES = -I$(INDEXERS_DIR)/mgpp/text  
     61MGPP_INCLUDES = -I$(INDEXERS_DIR)/mgpp/text -I$(INDEXERS_DIR)/mgpp/lib 
    6062else 
    6163MGPP_INDEXERS_LIBS = 
     
    8991MICO_VER = @MICO_VER@ 
    9092ifeq ($(MICO_DIR), default) 
    91 MICO_INCLUDES = -I$(RUNTIME_PACKAGES_DIR)/mico/mico/include 
     93MICO_INCLUDES = -I. -I$(RUNTIME_PACKAGES_DIR)/mico/mico/include 
    9294MICO_PATH = $(RUNTIME_PACKAGES_DIR)/mico/bin/ 
    9395else 
    94 MICO_INCLUDES = -I$(MICO_DIR) 
     96MICO_INCLUDES = -I. -I$(MICO_DIR) 
    9597MICO_PATH = 
    9698endif 
     
    100102AR = ar 
    101103CC = @CC@ 
    102 CFLAGS = @CFLAGS@ 
     104CFLAGS = -I. @CFLAGS@ 
     105CXXFLAGS = -I. @CXXFLAGS@ 
    103106DEFS = @DEFS@ -DNZDL -DQUIET -DSHORT_SUFFIX -DPARADOCNUM -DGSDLSERVER $(GDBM_DEFINES) $(JDBM_DEFINES) $(SQLITE_DEFINES) 
    104 INCLUDES = -I$(COMMON_DIR)/src/lib -I$(COLSERVR_DIR) -I$(PROTOCOL_DIR) -I$(RECPT_DIR) $(MGPP_INCLUDES) \ 
     107INCLUDES = -I$(COMMON_DIR)/src/lib -I$(COLSERVR_DIR) -I$(PROTOCOL_DIR) -I$(RECPT_DIR) $(MG_INCLUDES) $(MGPP_INCLUDES) \ 
    105108    $(MICO_INCLUDES) 
    106109INSTALL = @INSTALL@ 
     
    123126    corbaconv_text_t.mpp \ 
    124127    corbaiface.mpp \ 
    125     corbaiface_skel.mpp \ 
    126128    corbaproto.mpp \ 
    127129    corbatext_t.mpp 
     130#   corbaiface_skel.mpp \ 
    128131 
    129132OBJECTS = \ 
    130133    corbaconv_text_t.o \ 
    131134    corbaiface.o \ 
    132     corbaiface_skel.o \ 
    133135    corbaproto.o \ 
    134136    corbatext_t.o 
     137#   corbaiface_skel.o \ 
    135138 
    136139CORBASERVER_OBJECTS = \ 
     
    174177 
    175178install: 
     179# We're in a linux makefile, so we know what the GSDLOS is if this 
     180# Makefile is run: 
     181    cp corbaserver ../../../cgi-bin/linux/. 
     182    if test -e corbarecptldd; then cp corbarecptldd ../../../cgi-bin/linux/.; fi 
    176183 
    177184clean: 
     
    185192endif 
    186193 
     194corbaiface.h corbaiface.mpp: corbaiface.idl 
     195 
     196# Because sequential commands are independent (each line seems to be run in its own shell), 
     197# need to set the path env vars and run the IDL command in the same cmd, so it remembers 
     198# the env vars when running the idl executable 
     199# (NOTE: In the past, before BOA changed to POA in corba code, skeleton files were 
     200# required. If needed again, generate them with the --c++-skel option to idl.) 
     201    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; 
     202 
    187203# Want to do distclean regardless of whether or not been compiled 
    188204# distclean needs to get rid of anything produced by ./configure such 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaServer.mpp

    r24959 r25231  
     1#define USE_POA 
     2 
    13// Standard headers 
    2 #include <iostream.h> 
    3 #include <fstream.h> 
     4#include <iostream> 
     5#include <fstream> 
    46 
    57// protocol headers 
     
    4446      here ++; 
    4547    } 
    46   cout << "Terminfo " << i << endl; 
     48  std::cout << "Terminfo " << i << std::endl; 
    4749} 
    4850 
     
    5759      corbaconv_text_t::setCorbatext(option.value,corba[i].value); 
    5860 
    59       // cout << corbatext_string(corba[i].name) << "?" << option 
     61      // std::cout << corbatext_string(corba[i].name) << "?" << option 
    6062 
    6163      array.push_back(option); 
     
    6365} 
    6466 
    65 class corbaServer : virtual public corbaiface_skel 
     67// corbaServer no longer inherits from corbaiface_skel since the change from using  
     68// BOA to POA in the Corba code upon updating Mico from version 2.3.5 to 2.3.13. 
     69class corbaServer : virtual public POA_gsdlInterface::corbaiface 
    6670{ 
    6771private: 
     
    8892    char * cdirname; 
    8993 
    90     cout << "CorbaServer: gsdlhome = " << home << endl; 
     94    std::cout << "CorbaServer: gsdlhome = " << home << std::endl; 
    9195 
    9296    this->gsdlhome = home; 
    93     cout << gsdlhome.getcstr() << endl; 
     97    std::cout << gsdlhome.getcstr() << std::endl; 
    9498    dirname = filename_cat(gsdlhome, "/collect"); 
    9599    cdirname = dirname.getcstr(); 
    96100    if (!read_dir (cdirname, collections)) { 
    97       cout << "Unable to read the gsdl directory; terminating" << endl; 
     101      std::cout << "Unable to read the gsdl directory; terminating" << std::endl; 
    98102      exit (1); 
    99103    } 
    100104    delete cdirname; 
    101105 
    102     cout << "Constructing set list server" << endl; 
     106    std::cout << "Constructing set list server" << std::endl; 
    103107    this->protocol = protocol; 
    104108 
     
    128132 
    129133      // **** 
    130       cout << "Recieved " << key << " = "; 
     134      std::cout << "Recieved " << key << " = "; 
    131135      for (int unsigned i=0; i<cfgline.size(); i++) 
    132136    { 
    133       cout << cfgline[i] << " "; 
    134     } 
    135       cout << endl; 
     137      std::cout << cfgline[i] << " "; 
     138    } 
     139      std::cout << std::endl; 
    136140 
    137141      // DB // **** 
     
    140144      text_tarray cfgline; 
    141145      cfgline.push_back (gsdlhome); 
    142       cout << "Changing gsdlhome to " << gsdlhome << endl; 
     146      std::cout << "Changing gsdlhome to " << gsdlhome << std::endl; 
    143147      protocol->configure(key, cfgline, error); 
    144148    } 
     
    146150    { 
    147151      // Only let gsdlhome through !!!! // **** 
    148       cout << "Supressing httpdomain" << endl; 
     152      std::cout << "Supressing httpdomain" << std::endl; 
    149153    } 
    150154      else if (key=="httpprefix") 
    151155    { 
    152       cout << "Supressing httpprefix" << endl; 
     156      std::cout << "Supressing httpprefix" << std::endl; 
    153157    } 
    154158      else 
     
    170174    cct = new corbaconv_text_t(corbaCollect); 
    171175 
    172     cout << "Collection: " << cct->getcstr() << endl; 
     176    std::cout << "Collection: " << cct->getcstr() << std::endl; 
    173177 
    174178    protocol->has_collection(*cct, _has, err, logout); // 'cct' typecast to text_t 
     
    182186      } 
    183187 
    184     // cout << "  " << has << endl; 
     188    // std::cout << "  " << has << std::endl; 
    185189 
    186190    delete cct; 
     
    245249    logout.close(); 
    246250    corbaError = (corbaComError) error; 
    247     cout << "Filter prepared" << corbaResponse.docInfo.length() << "," << corbaResponse.numDocs << endl; 
     251    std::cout << "Filter prepared" << corbaResponse.docInfo.length() << "," << corbaResponse.numDocs << std::endl; 
    248252  } 
    249253 
     
    262266    protocol->get_collectinfo(collection, response, error, logout); 
    263267 
    264     cout << "IsPublic  = " << ((response.isPublic)?"True":"False") << endl; 
    265     cout << "IsBeta    = " << ((response.isBeta)  ?"True":"False") << endl; 
    266     cout << "BuildDate = " << response.buildDate << endl; 
    267     cout << "NumDocs   = " << response.numDocs << endl; 
    268     cout << "NumBytes  = " << response.numBytes << endl; 
    269     cout << "NumWords  = " << response.numWords << endl; 
    270     cout << "UseBook   = " << ((response.useBook)  ?"True":"False") << endl; 
     268    std::cout << "IsPublic  = " << ((response.isPublic)?"True":"False") << std::endl; 
     269    std::cout << "IsBeta    = " << ((response.isBeta)  ?"True":"False") << std::endl; 
     270    std::cout << "BuildDate = " << response.buildDate << std::endl; 
     271    std::cout << "NumDocs   = " << response.numDocs << std::endl; 
     272    std::cout << "NumBytes  = " << response.numBytes << std::endl; 
     273    std::cout << "NumWords  = " << response.numWords << std::endl; 
     274    std::cout << "UseBook   = " << ((response.useBook)  ?"True":"False") << std::endl; 
    271275     
    272276    corbaResponse.useBook   = response.useBook; 
     
    280284    corbaResponse.numWords  = response.numWords; 
    281285 
    282     corbatext_mapToCorbaMap(response.collectionmeta, &corbaResponse.collectionMeta); 
     286    corbatext_colmetamapToCorbaColmetamap(response.collectionmeta, &corbaResponse.collectionMeta); 
    283287    corbatext_mapToCorbaMap(response.format, &corbaResponse.format); 
    284288    corbatext_mapToCorbaMap(response.building, &corbaResponse.building); 
     
    292296    while (f_here!=f_end) 
    293297    { 
    294       cout << "**** format: " << f_here->first << " = " << f_here->second << endl; 
     298      std::cout << "**** format: " << f_here->first << " = " << f_here->second << std::endl; 
    295299      f_here++; 
    296300    }  
     
    362366 
    363367    corbaconv_text_t::setCorbatext(collection,corbaCollect); 
    364     cout << collection.getcstr() << endl; 
     368    std::cout << collection.getcstr() << std::endl; 
    365369                 
    366370    protocol->get_filterinfo(collection, response, error, logout); 
     
    399403  void getRssItems (const struct corbatext_t &corbaCollect, 
    400404          const struct corbatext_t &corbaGsdlHome, 
    401           const struct corbatext_t &corbaRssItems, 
     405          struct corbatext_t &corbaRssItems, 
    402406          enum corbaComError &corbaError) 
    403407  {    
     
    416420    protocol->get_rss_items(collection, gsdlhome, rss_items, error, logout); 
    417421    corbaconv_text_t::getCorbatext(rss_items,corbaRssItems); 
    418  
     422     
    419423    // decode response 
    420424    corbaError = (corbaComError) error; 
     
    433437    ofstream logout; 
    434438 
    435     cout << "Received collection list request" << endl; 
     439    std::cout << "Received collection list request" << std::endl; 
    436440 
    437441    this->openLogfile("/etc/corbaout.txt", logout); 
     
    453457 
    454458    corbatext_arrayToCorbaArray(collist, &corbalist); 
    455     cout << "Replying " << collist.size() << ": " << endl; 
     459    std::cout << "Replying " << collist.size() << ": " << std::endl; 
    456460 
    457461    for (int unsigned i = 0; i < collist.size(); i ++) 
    458462      { 
    459     cout << collist[i]; 
    460     if (i<collist.size()-1) cout << ", "; 
     463    std::cout << collist[i]; 
     464    if (i<collist.size()-1) std::cout << ", "; 
    461465      } 
    462     cout << endl; 
     466    std::cout << std::endl; 
    463467 
    464468    logout.close(); 
     
    472476  collectset *cservers; 
    473477  text_t     gsdlhome; 
    474  
    475   cservers = new collectset(gsdlhome); 
     478  text_t     collecthome; 
     479 
     480  cservers = new collectset(gsdlhome, collecthome); 
    476481  protocol.set_collectset(cservers); 
    477482 
    478   cout << "Started Corba ..." << endl; 
     483  std::cout << "Started Corba ..." << std::endl; 
    479484 
    480485  // ORB initialization 
     486  // Initialize the ORB 
    481487  CORBA::ORB_var orb = CORBA::ORB_init( argc, argv, "mico-local-orb" ); 
     488 
     489#if defined(USE_POA) 
     490  // Obtain a reference to the RootPOA and its Manager 
     491  CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA"); 
     492  PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj); 
     493  PortableServer::POAManager_var mgr = poa->the_POAManager(); 
     494#else 
    482495  CORBA::BOA_var boa = orb->BOA_init( argc, argv, "mico-local-boa" ); 
    483  
    484   cout << "Initialised ORB and BOA" << endl; 
    485  
     496#endif 
     497 
     498  std::cout << "Initialised ORB and P/BOA" << std::endl; 
     499 
     500 
     501  // Create the Server object (the object that inherits from the POA_gsdlInterface::corbaiface 
    486502  corbaServer* server = new corbaServer(&protocol, gsdlhome); 
    487503 
    488   cout << "Initialised server" << endl; 
    489  
    490   CORBA::String_var ref = orb->object_to_string( server ); 
    491  
    492   cout << "Mapped Corba object to string" << endl; 
    493  
     504  // Activate the Servant (server) 
     505#if defined(USE_POA) 
     506  PortableServer::ObjectId_var oid = poa->activate_object (server); 
     507#endif 
     508 
     509  std::cout << "Initialised server" << std::endl; 
     510 
     511  CORBA::Object_var ref = poa->id_to_reference ( oid.in() ); 
     512  CORBA::String_var str = orb->object_to_string( ref.in() ); 
     513 
     514  std::cout << "Mapped Corba object to string" << std::endl; 
     515 
     516  // Write referene to file 
    494517  // write id to "naming service" 
    495518  ofstream out ("/tmp/localcorba.objid"); 
    496519    if (out.is_open()) { 
    497         out << ref << endl; 
     520        out << str.in() << std::endl; 
    498521        if (out.fail() || out.bad()) { 
    499             cout << "Failed " << endl; 
     522            std::cout << "Failed " << std::endl; 
    500523        } 
    501524        out.close (); 
    502525    } 
    503526    else { 
    504         cout << "Unable to write string to file /tmp/localcorba.objid" << endl; 
    505         cout << "Please check the file permissions/ownership" << endl; 
     527        std::cout << "Unable to write string" << str.in() << " to file /tmp/localcorba.objid" << std::endl; 
     528        std::cout << "Please check the file permissions/ownership" << std::endl; 
    506529        return 0; 
    507530    } 
    508   cout << "Corba string is " << ref << endl; 
    509  
     531    std::cout << "Corba string is " << str.in() << std::endl; 
     532 
     533    // Activate the POA and start serving requests 
    510534  // indicate readiness and run 
     535#if defined(USE_POA) 
     536  mgr->activate (); 
     537  //poa->the_POAManager()->activate(); 
     538#else 
    511539  boa->impl_is_ready( CORBA::ImplementationDef::_nil() ); 
     540#endif 
    512541  orb->run (); 
     542 
     543#if defined(USE_POA) 
     544  // Shutdown (never reached) 
     545  poa->destroy (TRUE, TRUE); 
     546  delete server; // should I include this???? 
     547#else 
    513548  CORBA::release( server ); 
     549#endif 
    514550  return 0; 
    515551} 
    516552 
    517  
  • main/trunk/greenstone2/runtime-src/src/corba/corbaclient.mpp

    r21324 r25231  
    7575  if (argc == 1) 
    7676  { cout << "Content-type: text/html" << endl << endl; 
    77     cout << "Usage: " << argv[0] << "site1.objid [site2.objid ....]" << endl; 
     77    cout << "Usage: " << argv[0] << " site1.objid [site2.objid ....]" << endl; 
    7878    return 0; 
    7979  } 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaiface.h

    r15463 r25231  
    11/* 
    2  *  MICO --- a free CORBA implementation 
    3  *  Copyright (C) 1997-98 Kay Roemer & Arno Puder 
     2 *  MICO --- an Open Source CORBA implementation 
     3 *  Copyright (c) 1997-2006 by The Mico Team 
    44 * 
    55 *  This file was automatically generated. DO NOT EDIT! 
    66 */ 
    77 
    8 #if !defined(__CORBAIFACE_H__) || defined(MICO_NO_TOPLEVEL_MODULES) 
    9 #define __CORBAIFACE_H__ 
    10  
    11 #ifndef MICO_NO_TOPLEVEL_MODULES 
    128#include <CORBA.h> 
    139#include <mico/throw.h> 
    14 #endif 
    15  
    16 #ifndef MICO_NO_TOPLEVEL_MODULES 
    17 MICO_NAMESPACE_DECL gsdlInterface { 
    18 #endif 
    19  
    20 #if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface) 
    21  
    22  
    23 typedef SequenceTmpl<CORBA::UShort,MICO_TID_DEF> usString; 
    24 #ifdef _WINDOWS 
    25 static usString _dummy_usString; 
    26 #endif 
    27 typedef TSeqVar<SequenceTmpl<CORBA::UShort,MICO_TID_DEF> > usString_var; 
    28 typedef TSeqOut<SequenceTmpl<CORBA::UShort,MICO_TID_DEF> > usString_out; 
     10 
     11#ifndef __CORBAIFACE_H__ 
     12#define __CORBAIFACE_H__ 
     13 
     14 
     15 
     16 
     17 
     18 
     19namespace gsdlInterface 
     20{ 
     21 
     22class corbaiface; 
     23typedef corbaiface *corbaiface_ptr; 
     24typedef corbaiface_ptr corbaifaceRef; 
     25typedef ObjVar< corbaiface > corbaiface_var; 
     26typedef ObjOut< corbaiface > corbaiface_out; 
     27 
     28} 
     29 
     30 
     31 
     32 
     33 
     34 
     35namespace gsdlInterface 
     36{ 
     37 
     38typedef SequenceTmpl< CORBA::UShort,MICO_TID_DEF> usString; 
     39typedef TSeqVar< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_var; 
     40typedef TSeqOut< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_out; 
    2941 
    3042typedef StringSequenceTmpl<CORBA::String_var> stringSeq; 
    31 #ifdef _WINDOWS 
    32 static stringSeq _dummy_stringSeq; 
    33 #endif 
    34 typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > stringSeq_var; 
    35 typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > stringSeq_out; 
     43typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > stringSeq_var; 
     44typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > stringSeq_out; 
    3645 
    3746struct corbatext_t; 
    38 typedef TVarVar<corbatext_t> corbatext_t_var; 
    39 typedef TVarOut<corbatext_t> corbatext_t_out; 
     47typedef TVarVar< corbatext_t > corbatext_t_var; 
     48typedef TVarOut< corbatext_t > corbatext_t_out; 
     49 
    4050 
    4151struct corbatext_t { 
     
    5565}; 
    5666 
    57 typedef SequenceTmpl<corbatext_t,MICO_TID_DEF> corbatext_tarray; 
    58 #ifdef _WINDOWS 
    59 static corbatext_tarray _dummy_corbatext_tarray; 
    60 #endif 
    61 typedef TSeqVar<SequenceTmpl<corbatext_t,MICO_TID_DEF> > corbatext_tarray_var; 
    62 typedef TSeqOut<SequenceTmpl<corbatext_t,MICO_TID_DEF> > corbatext_tarray_out; 
     67typedef SequenceTmpl< corbatext_t,MICO_TID_DEF> corbatext_tarray; 
     68typedef TSeqVar< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_var; 
     69typedef TSeqOut< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_out; 
    6370 
    6471typedef corbatext_tarray corbatext_tset; 
    65 #ifdef _WINDOWS 
    66 static corbatext_tset _dummy_corbatext_tset; 
    67 #endif 
    68 typedef TSeqVar<corbatext_tarray > corbatext_tset_var; 
    69 typedef TSeqOut<corbatext_tarray > corbatext_tset_out; 
     72typedef TSeqVar< corbatext_tarray > corbatext_tset_var; 
     73typedef TSeqOut< corbatext_tarray > corbatext_tset_out; 
    7074 
    7175struct corbatext_tmap; 
    72 typedef TVarVar<corbatext_tmap> corbatext_tmap_var; 
    73 typedef TVarOut<corbatext_tmap> corbatext_tmap_out; 
     76typedef TVarVar< corbatext_tmap > corbatext_tmap_var; 
     77typedef TVarOut< corbatext_tmap > corbatext_tmap_out; 
     78 
    7479 
    7580struct corbatext_tmap { 
     
    8792  corbatext_tarray values; 
    8893}; 
     94 
     95struct corbatext_tcollectionmeta; 
     96typedef TVarVar< corbatext_tcollectionmeta > corbatext_tcollectionmeta_var; 
     97typedef TVarOut< corbatext_tcollectionmeta > corbatext_tcollectionmeta_out; 
     98 
     99 
     100struct corbatext_tcollectionmeta { 
     101  #ifdef HAVE_TYPEDEF_OVERLOAD 
     102  typedef corbatext_tcollectionmeta_var _var_type; 
     103  #endif 
     104  #ifdef HAVE_EXPLICIT_STRUCT_OPS 
     105  corbatext_tcollectionmeta(); 
     106  ~corbatext_tcollectionmeta(); 
     107  corbatext_tcollectionmeta( const corbatext_tcollectionmeta& s ); 
     108  corbatext_tcollectionmeta& operator=( const corbatext_tcollectionmeta& s ); 
     109  #endif //HAVE_EXPLICIT_STRUCT_OPS 
     110 
     111  corbatext_t name; 
     112  corbatext_tmap tuples; 
     113}; 
     114 
     115typedef SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> corbatext_tcollectionmeta_map; 
     116typedef TSeqVar< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_var; 
     117typedef TSeqOut< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_out; 
    89118 
    90119enum corbaComError { 
     
    99128 
    100129struct corbaShortColInfo; 
    101 typedef TVarVar<corbaShortColInfo> corbaShortColInfo_var; 
    102 typedef TVarOut<corbaShortColInfo> corbaShortColInfo_out; 
     130typedef TVarVar< corbaShortColInfo > corbaShortColInfo_var; 
     131typedef TVarOut< corbaShortColInfo > corbaShortColInfo_out; 
     132 
    103133 
    104134struct corbaShortColInfo { 
     
    119149 
    120150struct corbaColInfoResponse; 
    121 typedef TVarVar<corbaColInfoResponse> corbaColInfoResponse_var; 
    122 typedef TVarOut<corbaColInfoResponse> corbaColInfoResponse_out; 
     151typedef TVarVar< corbaColInfoResponse > corbaColInfoResponse_var; 
     152typedef TVarOut< corbaColInfoResponse > corbaColInfoResponse_out; 
     153 
    123154 
    124155struct corbaColInfoResponse { 
     
    133164  #endif //HAVE_EXPLICIT_STRUCT_OPS 
    134165 
    135   corbaShortColInfo shoftInfo; 
     166  corbaShortColInfo shortInfo; 
    136167  CORBA::Boolean useBook; 
    137168  CORBA::Boolean isPublic; 
     
    143174  CORBA::ULong numWords; 
    144175  CORBA::ULong numBytes; 
    145   corbatext_tmap collectionMeta; 
     176  corbatext_tcollectionmeta_map collectionMeta; 
    146177  corbatext_tmap format; 
    147178  corbatext_tmap building; 
     
    149180  corbatext_t httpprefix; 
    150181  corbatext_t receptionist; 
     182  CORBA::Boolean isSegmented; 
     183  CORBA::Boolean isCollectGroup; 
     184  CORBA::ULong ccsOptions; 
     185  CORBA::ULong stemIndexes; 
     186  CORBA::ULong numSections; 
     187  corbatext_tcollectionmeta_map collection_macros; 
     188  corbatext_t buildType; 
     189  corbatext_t infodbType; 
     190  corbatext_t authenticate; 
     191  corbatext_t auth_group; 
     192  corbatext_tmap public_documents; 
     193  corbatext_tmap private_documents; 
     194  corbatext_tmap dynamic_classifiers; 
     195  corbatext_t earliestDatestamp; 
    151196}; 
    152197 
    153198struct corbaDocRequest; 
    154 typedef TVarVar<corbaDocRequest> corbaDocRequest_var; 
    155 typedef TVarOut<corbaDocRequest> corbaDocRequest_out; 
     199typedef TVarVar< corbaDocRequest > corbaDocRequest_var; 
     200typedef TVarOut< corbaDocRequest > corbaDocRequest_out; 
     201 
    156202 
    157203struct corbaDocRequest { 
     
    172218 
    173219struct corbaDocResponse; 
    174 typedef TVarVar<corbaDocResponse> corbaDocResponse_var; 
    175 typedef TVarOut<corbaDocResponse> corbaDocResponse_out; 
     220typedef TVarVar< corbaDocResponse > corbaDocResponse_var; 
     221typedef TVarOut< corbaDocResponse > corbaDocResponse_out; 
     222 
    176223 
    177224struct corbaDocResponse { 
     
    207254 
    208255struct corbaFilterOption; 
    209 typedef TVarVar<corbaFilterOption> corbaFilterOption_var; 
    210 typedef TVarOut<corbaFilterOption> corbaFilterOption_out; 
     256typedef TVarVar< corbaFilterOption > corbaFilterOption_var; 
     257typedef TVarOut< corbaFilterOption > corbaFilterOption_out; 
     258 
    211259 
    212260struct corbaFilterOption { 
     
    228276}; 
    229277 
    230 typedef SequenceTmpl<corbaFilterOption,MICO_TID_DEF> corbaFilterOptionList; 
    231 #ifdef _WINDOWS 
    232 static corbaFilterOptionList _dummy_corbaFilterOptionList; 
    233 #endif 
    234 typedef TSeqVar<SequenceTmpl<corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var; 
    235 typedef TSeqOut<SequenceTmpl<corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_out; 
     278typedef SequenceTmpl< corbaFilterOption,MICO_TID_DEF> corbaFilterOptionList; 
     279typedef TSeqVar< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var; 
     280typedef TSeqOut< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_out; 
    236281 
    237282struct corbaFilterOptionsResponse; 
    238 typedef TVarVar<corbaFilterOptionsResponse> corbaFilterOptionsResponse_var; 
    239 typedef TVarOut<corbaFilterOptionsResponse> corbaFilterOptionsResponse_out; 
     283typedef TVarVar< corbaFilterOptionsResponse > corbaFilterOptionsResponse_var; 
     284typedef TVarOut< corbaFilterOptionsResponse > corbaFilterOptionsResponse_out; 
     285 
    240286 
    241287struct corbaFilterOptionsResponse { 
     
    255301 
    256302struct corbaOptionValue; 
    257 typedef TVarVar<corbaOptionValue> corbaOptionValue_var; 
    258 typedef TVarOut<corbaOptionValue> corbaOptionValue_out; 
     303typedef TVarVar< corbaOptionValue > corbaOptionValue_var; 
     304typedef TVarOut< corbaOptionValue > corbaOptionValue_out; 
     305 
    259306 
    260307struct corbaOptionValue { 
     
    273320}; 
    274321 
    275 typedef SequenceTmpl<corbaOptionValue,MICO_TID_DEF> corbaOptionValue_array; 
    276 #ifdef _WINDOWS 
    277 static corbaOptionValue_array _dummy_corbaOptionValue_array; 
    278 #endif 
    279 typedef TSeqVar<SequenceTmpl<corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var; 
    280 typedef TSeqOut<SequenceTmpl<corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_out; 
     322typedef SequenceTmpl< corbaOptionValue,MICO_TID_DEF> corbaOptionValue_array; 
     323typedef TSeqVar< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var; 
     324typedef TSeqOut< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_out; 
    281325 
    282326struct corbaFilterRequest; 
    283 typedef TVarVar<corbaFilterRequest> corbaFilterRequest_var; 
    284 typedef TVarOut<corbaFilterRequest> corbaFilterRequest_out; 
     327typedef TVarVar< corbaFilterRequest > corbaFilterRequest_var; 
     328typedef TVarOut< corbaFilterRequest > corbaFilterRequest_out; 
     329 
    285330 
    286331struct corbaFilterRequest { 
     
    306351 
    307352struct corbaTermInfo; 
    308 typedef TVarVar<corbaTermInfo> corbaTermInfo_var; 
    309 typedef TVarOut<corbaTermInfo> corbaTermInfo_out; 
     353typedef TVarVar< corbaTermInfo > corbaTermInfo_var; 
     354typedef TVarOut< corbaTermInfo > corbaTermInfo_out; 
     355 
    310356 
    311357struct corbaTermInfo { 
     
    325371}; 
    326372 
    327 typedef SequenceTmpl<corbaTermInfo,MICO_TID_DEF> corbaTermInfo_array; 
    328 #ifdef _WINDOWS 
    329 static corbaTermInfo_array _dummy_corbaTermInfo_array; 
    330 #endif 
    331 typedef TSeqVar<SequenceTmpl<corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var; 
    332 typedef TSeqOut<SequenceTmpl<corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_out; 
     373typedef SequenceTmpl< corbaTermInfo,MICO_TID_DEF> corbaTermInfo_array; 
     374typedef TSeqVar< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var; 
     375typedef TSeqOut< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_out; 
    333376 
    334377struct corbaMetadataInfo; 
    335 typedef TVarVar<corbaMetadataInfo> corbaMetadataInfo_var; 
    336 typedef TVarOut<corbaMetadataInfo> corbaMetadataInfo_out; 
     378typedef TVarVar< corbaMetadataInfo > corbaMetadataInfo_var; 
     379typedef TVarOut< corbaMetadataInfo > corbaMetadataInfo_out; 
     380 
    337381 
    338382struct corbaMetadataInfo { 
     
    354398}; 
    355399 
    356 typedef SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> corbaMetadataInfo_array; 
    357 #ifdef _WINDOWS 
    358 static corbaMetadataInfo_array _dummy_corbaMetadataInfo_array; 
    359 #endif 
    360 typedef TSeqVar<SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var; 
    361 typedef TSeqOut<SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_out; 
     400typedef SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> corbaMetadataInfo_array; 
     401typedef TSeqVar< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var; 
     402typedef TSeqOut< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_out; 
    362403 
    363404struct corbaMetadataInfo_map; 
    364 typedef TVarVar<corbaMetadataInfo_map> corbaMetadataInfo_map_var; 
    365 typedef TVarOut<corbaMetadataInfo_map> corbaMetadataInfo_map_out; 
     405typedef TVarVar< corbaMetadataInfo_map > corbaMetadataInfo_map_var; 
     406typedef TVarOut< corbaMetadataInfo_map > corbaMetadataInfo_map_out; 
     407 
    366408 
    367409struct corbaMetadataInfo_map { 
     
    380422}; 
    381423 
    382 typedef SequenceTmpl<CORBA::Long,MICO_TID_DEF> corbaDocFreq_array; 
    383 #ifdef _WINDOWS 
    384 static corbaDocFreq_array _dummy_corbaDocFreq_array; 
    385 #endif 
    386 typedef TSeqVar<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var; 
    387 typedef TSeqOut<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_out; 
     424typedef SequenceTmpl< CORBA::Long,MICO_TID_DEF> corbaDocFreq_array; 
     425typedef TSeqVar< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var; 
     426typedef TSeqOut< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_out; 
    388427 
    389428struct corbaResultDocInfo; 
    390 typedef TVarVar<corbaResultDocInfo> corbaResultDocInfo_var; 
    391 typedef TVarOut<corbaResultDocInfo> corbaResultDocInfo_out; 
     429typedef TVarVar< corbaResultDocInfo > corbaResultDocInfo_var; 
     430typedef TVarOut< corbaResultDocInfo > corbaResultDocInfo_out; 
     431 
    392432 
    393433struct corbaResultDocInfo { 
     
    414454}; 
    415455 
    416 typedef SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> corbaResultDocInfo_array; 
    417 #ifdef _WINDOWS 
    418 static corbaResultDocInfo_array _dummy_corbaResultDocInfo_array; 
    419 #endif 
    420 typedef TSeqVar<SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var; 
    421 typedef TSeqOut<SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_out; 
     456typedef SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> corbaResultDocInfo_array; 
     457typedef TSeqVar< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var; 
     458typedef TSeqOut< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_out; 
    422459 
    423460enum corbaIsApprox { 
     
    430467 
    431468struct corbaFilterResponse; 
    432 typedef TVarVar<corbaFilterResponse> corbaFilterResponse_var; 
    433 typedef TVarOut<corbaFilterResponse> corbaFilterResponse_out; 
     469typedef TVarVar< corbaFilterResponse > corbaFilterResponse_var; 
     470typedef TVarOut< corbaFilterResponse > corbaFilterResponse_out; 
     471 
    434472 
    435473struct corbaFilterResponse { 
     
    450488}; 
    451489 
    452 class corbaiface; 
    453 typedef corbaiface *corbaiface_ptr; 
    454 typedef corbaiface_ptr corbaifaceRef; 
    455 typedef ObjVar<corbaiface> corbaiface_var; 
    456 typedef ObjOut<corbaiface> corbaiface_out; 
    457  
    458  
    459 // Common definitions for interface corbaiface 
     490 
     491/* 
     492 * Base class and common definitions for interface corbaiface 
     493 */ 
     494 
    460495class corbaiface :  
    461496  virtual public CORBA::Object 
     
    483518 
    484519    virtual void *_narrow_helper( const char *repoid ); 
    485     static vector<CORBA::Narrow_proto> *_narrow_helpers; 
    486     static bool _narrow_helper2( CORBA::Object_ptr obj ); 
    487  
    488     virtual CORBA::Boolean initialise( corbaComError& error ) = 0; 
    489     virtual void configure( const corbatext_t& key, const corbatext_tarray& cfgline, corbaComError& error ) = 0; 
    490     virtual void collectionList( corbatext_tarray& collist, corbaComError& error ) = 0; 
    491     virtual void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error ) = 0; 
    492     virtual void ping( const corbatext_t& collection, CORBA::Boolean& wasSuccess, corbaComError& error ) = 0; 
    493     virtual void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error ) = 0; 
    494     virtual void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error ) = 0; 
    495     virtual void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error ) = 0; 
    496     virtual void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error ) = 0; 
    497     virtual void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error ) = 0; 
     520 
     521    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0; 
     522    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0; 
     523    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0; 
     524    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0; 
     525    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0; 
     526    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     527    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     528    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0; 
     529    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     530    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     531    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0; 
    498532 
    499533  protected: 
     
    510544  public: 
    511545    virtual ~corbaiface_stub(); 
    512     CORBA::Boolean initialise( corbaComError& error ); 
    513     void configure( const corbatext_t& key, const corbatext_tarray& cfgline, corbaComError& error ); 
    514     void collectionList( corbatext_tarray& collist, corbaComError& error ); 
    515     void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error ); 
    516     void ping( const corbatext_t& collection, CORBA::Boolean& wasSuccess, corbaComError& error ); 
    517     void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error ); 
    518     void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error ); 
    519     void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error ); 
    520     void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error ); 
    521     void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error ); 
     546    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ); 
     547    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ); 
     548    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ); 
     549    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ); 
     550    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ); 
     551    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ); 
     552    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ); 
     553    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ); 
     554    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ); 
     555    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ); 
     556    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ); 
    522557 
    523558  private: 
     
    525560}; 
    526561 
    527 class corbaiface_skel : 
    528   virtual public StaticMethodDispatcher, 
    529   virtual public corbaiface 
     562#ifndef MICO_CONF_NO_POA 
     563 
     564class corbaiface_stub_clp : 
     565  virtual public corbaiface_stub, 
     566  virtual public PortableServer::StubBase 
    530567{ 
    531568  public: 
    532     corbaiface_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() ); 
    533     virtual ~corbaiface_skel(); 
    534     corbaiface_skel( CORBA::Object_ptr obj ); 
    535     virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env ); 
    536     corbaiface_ptr _this(); 
    537  
    538 }; 
    539  
    540 #endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface) 
    541  
    542 #ifndef MICO_NO_TOPLEVEL_MODULES 
    543  
    544 } MICO_NAMESPACE_END_DECL 
     569    corbaiface_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); 
     570    virtual ~corbaiface_stub_clp (); 
     571    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ); 
     572    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ); 
     573    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ); 
     574    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ); 
     575    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ); 
     576    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ); 
     577    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ); 
     578    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ); 
     579    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ); 
     580    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ); 
     581    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ); 
     582 
     583  protected: 
     584    corbaiface_stub_clp (); 
     585  private: 
     586    void operator=( const corbaiface_stub_clp & ); 
     587}; 
     588 
     589#endif // MICO_CONF_NO_POA 
     590 
     591} 
     592 
     593 
     594#ifndef MICO_CONF_NO_POA 
     595 
     596 
     597 
     598namespace POA_gsdlInterface 
     599{ 
     600 
     601class corbaiface : virtual public PortableServer::StaticImplementation 
     602{ 
     603  public: 
     604    virtual ~corbaiface (); 
     605    gsdlInterface::corbaiface_ptr _this (); 
     606    bool dispatch (CORBA::StaticServerRequest_ptr); 
     607    virtual void invoke (CORBA::StaticServerRequest_ptr); 
     608    virtual CORBA::Boolean _is_a (const char *); 
     609    virtual CORBA::InterfaceDef_ptr _get_interface (); 
     610    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr); 
     611 
     612    virtual void * _narrow_helper (const char *); 
     613    static corbaiface * _narrow (PortableServer::Servant); 
     614    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); 
     615 
     616    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0; 
     617    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0; 
     618    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0; 
     619    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0; 
     620    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0; 
     621    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     622    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     623    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0; 
     624    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     625    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0; 
     626    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0; 
     627 
     628  protected: 
     629    corbaiface () {}; 
     630 
     631  private: 
     632    corbaiface (const corbaiface &); 
     633    void operator= (const corbaiface &); 
     634}; 
     635 
     636} 
     637 
     638 
     639#endif // MICO_CONF_NO_POA 
     640 
     641extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t; 
     642 
     643extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap; 
     644 
     645extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta; 
     646 
     647extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError; 
     648 
     649extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo; 
     650 
     651extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse; 
     652 
     653extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest; 
     654 
     655extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse; 
     656 
     657extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType; 
     658 
     659extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable; 
     660 
     661extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption; 
     662 
     663extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse; 
     664 
     665extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue; 
     666 
     667extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest; 
     668 
     669extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo; 
     670 
     671extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo; 
     672 
     673extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map; 
     674 
     675extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo; 
     676 
     677extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox; 
     678 
     679extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse; 
     680 
     681extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface; 
     682 
     683extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t; 
     684 
     685extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta; 
     686 
     687extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption; 
     688 
     689extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue; 
     690 
     691extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo; 
     692 
     693extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo; 
     694 
     695extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo; 
     696 
    545697#endif 
    546  
    547  
    548  
    549 #ifndef MICO_CONF_NO_POA 
    550  
    551 #endif // MICO_CONF_NO_POA 
    552  
    553 #if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL) 
    554  
    555 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t; 
    556  
    557 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap; 
    558  
    559 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError; 
    560  
    561 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo; 
    562  
    563 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse; 
    564  
    565 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest; 
    566  
    567 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse; 
    568  
    569 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType; 
    570  
    571 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable; 
    572  
    573 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption; 
    574  
    575 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse; 
    576  
    577 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue; 
    578  
    579 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest; 
    580  
    581 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo; 
    582  
    583 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo; 
    584  
    585 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map; 
    586  
    587 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo; 
    588  
    589 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox; 
    590  
    591 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse; 
    592  
    593 extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface; 
    594  
    595 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t; 
    596  
    597 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption; 
    598  
    599 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue; 
    600  
    601 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo; 
    602  
    603 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo; 
    604  
    605 extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo; 
    606  
    607 #endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL) 
    608  
    609  
    610 #if !defined(MICO_NO_TOPLEVEL_MODULES) && !defined(MICO_IN_GENERATED_CODE) 
    611 #include <mico/template_impl.h> 
    612 #endif 
    613  
    614 #endif 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaiface.idl

    r24970 r25231  
    2323  corbatext_tarray values; 
    2424}; 
     25 
     26// colserver/comtypes.h defines collectionmeta_map of collectionmeta  
     27// as (sorted) tuples of: metadata name -> lang -> value 
     28// However, the C++ definition is:  
     29// typedef map<text_t, text_tmap, lttext_t> collectionmeta_map; 
     30// Where lttext_t is defined to be a sorting function in text_t.h 
     31// Each collectionmeta name maps to one or more (lang,value) pairs.  
     32// The struct below defines the entry for one collectionmeta name. 
     33struct corbatext_tcollectionmeta { 
     34  corbatext_t name; 
     35  corbatext_tmap tuples; 
     36  //corbatext_tarray languages; 
     37  //corbatext_tarray values; 
     38}; 
     39 
     40typedef sequence<corbatext_tcollectionmeta> corbatext_tcollectionmeta_map; 
     41 
    2542 
    2643// standard error values 
     
    4764struct corbaColInfoResponse 
    4865{ 
    49   boolean       useBook; 
    50   corbaShortColInfo shoftInfo; 
     66  corbaShortColInfo shortInfo; 
     67  boolean           useBook; 
    5168  boolean           isPublic; 
    5269  boolean           isBeta; 
     70 
    5371  unsigned long     buildDate; 
    5472  corbatext_tarray  ccsCols;        // Added 05/04/2000 
     
    5775  unsigned long     numWords; 
    5876  unsigned long     numBytes; 
    59   corbatext_tmap    collectionMeta; 
     77  corbatext_tcollectionmeta_map    collectionMeta; //corbatext_tmap    collectionMeta; 
    6078  corbatext_tmap    format; 
    6179  corbatext_tmap    building; 
     
    6381  corbatext_t       httpprefix;     // Added 27/07/2000 
    6482  corbatext_t       receptionist; 
     83 
     84  // The following member fields were added 14/03/2011 to  
     85  // match up with ColInfoResponse_t definition in comtypes.h 
     86 
     87  boolean isSegmented; 
     88  boolean isCollectGroup; // used to group a set of collections as one item on the home page 
     89  unsigned long ccsOptions; // uses CCS #defines from above 
     90  unsigned long stemIndexes; // uses SI #defines from above 
     91  unsigned long numSections; // 0 if not known 
     92  corbatext_tcollectionmeta_map  collection_macros; // for collectionmacro config directive (> gsdl 2.53) 
     93  corbatext_t         buildType;           // 'mg' or 'mgpp' or 'lucene' 
     94  corbatext_t         infodbType;          // 'gdbm', 'sqlite', etc. 
     95  corbatext_t         authenticate;        // 'document' or 'collection' 
     96  corbatext_t         auth_group;          // 'mygroup' 'yourgroup' 
     97  corbatext_tmap      public_documents;    // the acl to allow access to listed documents 
     98  corbatext_tmap      private_documents;   // the acl to disallow access to listed documents 
     99  corbatext_tmap      dynamic_classifiers; 
     100  corbatext_t         earliestDatestamp;   // For OAIserver validation. Time since linux Epoch, expressed as (long) integer value in string form 
     101 
    65102}; 
    66103 
     
    227264                   inout corbaFilterResponse response, 
    228265                   inout corbaComError error); 
    229   void      get_rss_items (const text_t &collection,  
    230                const text_t &gsdlhome,  
    231                text_t &rss_items,  
    232                comerror_t &err,  
    233                ostream &logout); 
    234 }; 
    235  
    236 }; 
     266 
     267  void      getRssItems (in corbatext_t collection,  
     268             in corbatext_t gsdlhome,  
     269             inout corbatext_t rss_items,  
     270             inout corbaComError error); 
     271 
     272}; 
     273 
     274}; 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp

    r15463 r25231  
    11/* 
    2  *  MICO --- a free CORBA implementation 
    3  *  Copyright (C) 1997-98 Kay Roemer & Arno Puder 
     2 *  MICO --- an Open Source CORBA implementation 
     3 *  Copyright (c) 1997-2006 by The Mico Team 
    44 * 
    55 *  This file was automatically generated. DO NOT EDIT! 
    66 */ 
    77 
    8 #include "corbaiface.h" 
     8#include <corbaiface.h> 
     9 
     10 
     11using namespace std; 
    912 
    1013//-------------------------------------------------------- 
     
    3942#endif 
    4043 
    41 class _Marshaller_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo { 
     44class _Marshaller_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo { 
    4245    typedef gsdlInterface::corbatext_t _MICO_T; 
    4346  public: 
     47    ~_Marshaller_gsdlInterface_corbatext_t(); 
    4448    StaticValueType create () const; 
    4549    void assign (StaticValueType dst, const StaticValueType src) const; 
    4650    void free (StaticValueType) const; 
    47     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    48     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     51    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     52    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    4953}; 
    5054 
    5155 
    52 CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const 
     56_Marshaller_gsdlInterface_corbatext_t::~_Marshaller_gsdlInterface_corbatext_t() 
     57{ 
     58} 
     59 
     60::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const 
    5361{ 
    5462  return (StaticValueType) new _MICO_T; 
     
    6573} 
    6674 
    67 CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     75::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    6876{ 
    6977  return 
     
    7583} 
    7684 
    77 void _Marshaller_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     85void _Marshaller_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    7886{ 
    7987  ec.struct_begin(); 
     
    8492} 
    8593 
    86 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t; 
     94::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t; 
    8795 
    8896 
     
    112120#endif 
    113121 
    114 class _Marshaller_gsdlInterface_corbatext_tmap : public CORBA::StaticTypeInfo { 
     122class _Marshaller_gsdlInterface_corbatext_tmap : public ::CORBA::StaticTypeInfo { 
    115123    typedef gsdlInterface::corbatext_tmap _MICO_T; 
    116124  public: 
     125    ~_Marshaller_gsdlInterface_corbatext_tmap(); 
    117126    StaticValueType create () const; 
    118127    void assign (StaticValueType dst, const StaticValueType src) const; 
    119128    void free (StaticValueType) const; 
    120     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    121     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     129    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     130    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    122131}; 
    123132 
    124133 
    125 CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const 
     134_Marshaller_gsdlInterface_corbatext_tmap::~_Marshaller_gsdlInterface_corbatext_tmap() 
     135{ 
     136} 
     137 
     138::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const 
    126139{ 
    127140  return (StaticValueType) new _MICO_T; 
     
    138151} 
    139152 
    140 CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     153::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    141154{ 
    142155  return 
     
    147160} 
    148161 
    149 void _Marshaller_gsdlInterface_corbatext_tmap::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     162void _Marshaller_gsdlInterface_corbatext_tmap::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    150163{ 
    151164  ec.struct_begin(); 
     
    155168} 
    156169 
    157 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap; 
    158  
    159  
    160 class _Marshaller_gsdlInterface_corbaComError : public CORBA::StaticTypeInfo { 
    161     typedef gsdlInterface::corbaComError _MICO_T; 
     170::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap; 
     171 
     172#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     173gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta() 
     174{ 
     175} 
     176 
     177gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta( const corbatext_tcollectionmeta& _s ) 
     178{ 
     179  name = ((corbatext_tcollectionmeta&)_s).name; 
     180  tuples = ((corbatext_tcollectionmeta&)_s).tuples; 
     181} 
     182 
     183gsdlInterface::corbatext_tcollectionmeta::~corbatext_tcollectionmeta() 
     184{ 
     185} 
     186 
     187gsdlInterface::corbatext_tcollectionmeta& 
     188gsdlInterface::corbatext_tcollectionmeta::operator=( const corbatext_tcollectionmeta& _s ) 
     189{ 
     190  name = ((corbatext_tcollectionmeta&)_s).name; 
     191  tuples = ((corbatext_tcollectionmeta&)_s).tuples; 
     192  return *this; 
     193} 
     194#endif 
     195 
     196class _Marshaller_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo { 
     197    typedef gsdlInterface::corbatext_tcollectionmeta _MICO_T; 
    162198  public: 
     199    ~_Marshaller_gsdlInterface_corbatext_tcollectionmeta(); 
    163200    StaticValueType create () const; 
    164201    void assign (StaticValueType dst, const StaticValueType src) const; 
    165202    void free (StaticValueType) const; 
    166     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    167     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     203    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     204    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    168205}; 
    169206 
    170207 
    171 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const 
     208_Marshaller_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller_gsdlInterface_corbatext_tcollectionmeta() 
     209{ 
     210} 
     211 
     212::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tcollectionmeta::create() const 
    172213{ 
    173214  return (StaticValueType) new _MICO_T; 
    174215} 
    175216 
     217void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const 
     218{ 
     219  *(_MICO_T*) d = *(_MICO_T*) s; 
     220} 
     221 
     222void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const 
     223{ 
     224  delete (_MICO_T*) v; 
     225} 
     226 
     227::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     228{ 
     229  return 
     230    dc.struct_begin() && 
     231    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) && 
     232    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->tuples ) && 
     233    dc.struct_end(); 
     234} 
     235 
     236void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     237{ 
     238  ec.struct_begin(); 
     239  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name ); 
     240  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->tuples ); 
     241  ec.struct_end(); 
     242} 
     243 
     244::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta; 
     245 
     246 
     247 
     248class _Marshaller_gsdlInterface_corbaComError : public ::CORBA::StaticTypeInfo { 
     249    typedef gsdlInterface::corbaComError _MICO_T; 
     250  public: 
     251    ~_Marshaller_gsdlInterface_corbaComError(); 
     252    StaticValueType create () const; 
     253    void assign (StaticValueType dst, const StaticValueType src) const; 
     254    void free (StaticValueType) const; 
     255    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     256    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
     257}; 
     258 
     259 
     260_Marshaller_gsdlInterface_corbaComError::~_Marshaller_gsdlInterface_corbaComError() 
     261{ 
     262} 
     263 
     264::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const 
     265{ 
     266  return (StaticValueType) new _MICO_T; 
     267} 
     268 
    176269void _Marshaller_gsdlInterface_corbaComError::assign( StaticValueType d, const StaticValueType s ) const 
    177270{ 
     
    184277} 
    185278 
    186 CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    187 { 
    188   CORBA::ULong ul; 
     279::CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     280{ 
     281  ::CORBA::ULong ul; 
    189282  if( !dc.enumeration( ul ) ) 
    190283    return FALSE; 
     
    193286} 
    194287 
    195 void _Marshaller_gsdlInterface_corbaComError::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    196 { 
    197   ec.enumeration( (CORBA::ULong) *(_MICO_T *) v ); 
    198 } 
    199  
    200 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError; 
     288void _Marshaller_gsdlInterface_corbaComError::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     289{ 
     290  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); 
     291} 
     292 
     293::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError; 
    201294 
    202295#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    226319#endif 
    227320 
    228 class _Marshaller_gsdlInterface_corbaShortColInfo : public CORBA::StaticTypeInfo { 
     321class _Marshaller_gsdlInterface_corbaShortColInfo : public ::CORBA::StaticTypeInfo { 
    229322    typedef gsdlInterface::corbaShortColInfo _MICO_T; 
    230323  public: 
     324    ~_Marshaller_gsdlInterface_corbaShortColInfo(); 
    231325    StaticValueType create () const; 
    232326    void assign (StaticValueType dst, const StaticValueType src) const; 
    233327    void free (StaticValueType) const; 
    234     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    235     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     328    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     329    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    236330}; 
    237331 
    238332 
    239 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const 
     333_Marshaller_gsdlInterface_corbaShortColInfo::~_Marshaller_gsdlInterface_corbaShortColInfo() 
     334{ 
     335} 
     336 
     337::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const 
    240338{ 
    241339  return (StaticValueType) new _MICO_T; 
     
    252350} 
    253351 
    254 CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     352::CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    255353{ 
    256354  return 
     
    262360} 
    263361 
    264 void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     362void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    265363{ 
    266364  ec.struct_begin(); 
     
    271369} 
    272370 
    273 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo; 
     371::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo; 
    274372 
    275373#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    280378gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s ) 
    281379{ 
    282   shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo; 
     380  shortInfo = ((corbaColInfoResponse&)_s).shortInfo; 
    283381  useBook = ((corbaColInfoResponse&)_s).useBook; 
    284382  isPublic = ((corbaColInfoResponse&)_s).isPublic; 
     
    296394  httpprefix = ((corbaColInfoResponse&)_s).httpprefix; 
    297395  receptionist = ((corbaColInfoResponse&)_s).receptionist; 
     396  isSegmented = ((corbaColInfoResponse&)_s).isSegmented; 
     397  isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup; 
     398  ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions; 
     399  stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes; 
     400  numSections = ((corbaColInfoResponse&)_s).numSections; 
     401  collection_macros = ((corbaColInfoResponse&)_s).collection_macros; 
     402  buildType = ((corbaColInfoResponse&)_s).buildType; 
     403  infodbType = ((corbaColInfoResponse&)_s).infodbType; 
     404  authenticate = ((corbaColInfoResponse&)_s).authenticate; 
     405  auth_group = ((corbaColInfoResponse&)_s).auth_group; 
     406  public_documents = ((corbaColInfoResponse&)_s).public_documents; 
     407  private_documents = ((corbaColInfoResponse&)_s).private_documents; 
     408  dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers; 
     409  earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp; 
    298410} 
    299411 
     
    305417gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s ) 
    306418{ 
    307   shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo; 
     419  shortInfo = ((corbaColInfoResponse&)_s).shortInfo; 
    308420  useBook = ((corbaColInfoResponse&)_s).useBook; 
    309421  isPublic = ((corbaColInfoResponse&)_s).isPublic; 
     
    321433  httpprefix = ((corbaColInfoResponse&)_s).httpprefix; 
    322434  receptionist = ((corbaColInfoResponse&)_s).receptionist; 
     435  isSegmented = ((corbaColInfoResponse&)_s).isSegmented; 
     436  isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup; 
     437  ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions; 
     438  stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes; 
     439  numSections = ((corbaColInfoResponse&)_s).numSections; 
     440  collection_macros = ((corbaColInfoResponse&)_s).collection_macros; 
     441  buildType = ((corbaColInfoResponse&)_s).buildType; 
     442  infodbType = ((corbaColInfoResponse&)_s).infodbType; 
     443  authenticate = ((corbaColInfoResponse&)_s).authenticate; 
     444  auth_group = ((corbaColInfoResponse&)_s).auth_group; 
     445  public_documents = ((corbaColInfoResponse&)_s).public_documents; 
     446  private_documents = ((corbaColInfoResponse&)_s).private_documents; 
     447  dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers; 
     448  earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp; 
    323449  return *this; 
    324450} 
    325451#endif 
    326452 
    327 class _Marshaller_gsdlInterface_corbaColInfoResponse : public CORBA::StaticTypeInfo { 
     453class _Marshaller_gsdlInterface_corbaColInfoResponse : public ::CORBA::StaticTypeInfo { 
    328454    typedef gsdlInterface::corbaColInfoResponse _MICO_T; 
    329455  public: 
     456    ~_Marshaller_gsdlInterface_corbaColInfoResponse(); 
    330457    StaticValueType create () const; 
    331458    void assign (StaticValueType dst, const StaticValueType src) const; 
    332459    void free (StaticValueType) const; 
    333     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    334     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     460    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     461    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    335462}; 
    336463 
    337464 
    338 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const 
     465_Marshaller_gsdlInterface_corbaColInfoResponse::~_Marshaller_gsdlInterface_corbaColInfoResponse() 
     466{ 
     467} 
     468 
     469::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const 
    339470{ 
    340471  return (StaticValueType) new _MICO_T; 
     
    351482} 
    352483 
    353 CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     484::CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    354485{ 
    355486  return 
    356487    dc.struct_begin() && 
    357     _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shoftInfo ) && 
     488    _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shortInfo ) && 
    358489    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->useBook ) && 
    359490    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) && 
     
    365496    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) && 
    366497    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) && 
    367     _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) && 
     498    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) && 
    368499    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) && 
    369500    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) && 
     
    371502    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) && 
    372503    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) && 
     504    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isSegmented ) && 
     505    CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isCollectGroup ) && 
     506    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->ccsOptions ) && 
     507    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->stemIndexes ) && 
     508    CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numSections ) && 
     509    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collection_macros ) && 
     510    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->buildType ) && 
     511    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->infodbType ) && 
     512    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->authenticate ) && 
     513    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->auth_group ) && 
     514    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->public_documents ) && 
     515    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->private_documents ) && 
     516    _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->dynamic_classifiers ) && 
     517    _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->earliestDatestamp ) && 
    373518    dc.struct_end(); 
    374519} 
    375520 
    376 void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     521void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    377522{ 
    378523  ec.struct_begin(); 
    379   _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shoftInfo ); 
     524  _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shortInfo ); 
    380525  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->useBook ); 
    381526  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic ); 
     
    387532  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords ); 
    388533  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes ); 
    389   _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->collectionMeta ); 
     534  _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collectionMeta ); 
    390535  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format ); 
    391536  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building ); 
     
    393538  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix ); 
    394539  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist ); 
     540  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isSegmented ); 
     541  CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isCollectGroup ); 
     542  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->ccsOptions ); 
     543  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->stemIndexes ); 
     544  CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numSections ); 
     545  _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collection_macros ); 
     546  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->buildType ); 
     547  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->infodbType ); 
     548  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->authenticate ); 
     549  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->auth_group ); 
     550  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->public_documents ); 
     551  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->private_documents ); 
     552  _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->dynamic_classifiers ); 
     553  _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->earliestDatestamp ); 
    395554  ec.struct_end(); 
    396555} 
    397556 
    398 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse; 
     557::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse; 
    399558 
    400559#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    424583#endif 
    425584 
    426 class _Marshaller_gsdlInterface_corbaDocRequest : public CORBA::StaticTypeInfo { 
     585class _Marshaller_gsdlInterface_corbaDocRequest : public ::CORBA::StaticTypeInfo { 
    427586    typedef gsdlInterface::corbaDocRequest _MICO_T; 
    428587  public: 
     588    ~_Marshaller_gsdlInterface_corbaDocRequest(); 
    429589    StaticValueType create () const; 
    430590    void assign (StaticValueType dst, const StaticValueType src) const; 
    431591    void free (StaticValueType) const; 
    432     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    433     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     592    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     593    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    434594}; 
    435595 
    436596 
    437 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const 
     597_Marshaller_gsdlInterface_corbaDocRequest::~_Marshaller_gsdlInterface_corbaDocRequest() 
     598{ 
     599} 
     600 
     601::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const 
    438602{ 
    439603  return (StaticValueType) new _MICO_T; 
     
    450614} 
    451615 
    452 CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     616::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    453617{ 
    454618  return 
     
    460624} 
    461625 
    462 void _Marshaller_gsdlInterface_corbaDocRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     626void _Marshaller_gsdlInterface_corbaDocRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    463627{ 
    464628  ec.struct_begin(); 
     
    469633} 
    470634 
    471 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest; 
     635::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest; 
    472636 
    473637#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    493657#endif 
    494658 
    495 class _Marshaller_gsdlInterface_corbaDocResponse : public CORBA::StaticTypeInfo { 
     659class _Marshaller_gsdlInterface_corbaDocResponse : public ::CORBA::StaticTypeInfo { 
    496660    typedef gsdlInterface::corbaDocResponse _MICO_T; 
    497661  public: 
     662    ~_Marshaller_gsdlInterface_corbaDocResponse(); 
    498663    StaticValueType create () const; 
    499664    void assign (StaticValueType dst, const StaticValueType src) const; 
    500665    void free (StaticValueType) const; 
    501     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    502     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     666    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     667    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    503668}; 
    504669 
    505670 
    506 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const 
     671_Marshaller_gsdlInterface_corbaDocResponse::~_Marshaller_gsdlInterface_corbaDocResponse() 
     672{ 
     673} 
     674 
     675::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const 
    507676{ 
    508677  return (StaticValueType) new _MICO_T; 
     
    519688} 
    520689 
    521 CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     690::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    522691{ 
    523692  return 
     
    527696} 
    528697 
    529 void _Marshaller_gsdlInterface_corbaDocResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     698void _Marshaller_gsdlInterface_corbaDocResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    530699{ 
    531700  ec.struct_begin(); 
     
    534703} 
    535704 
    536 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse; 
    537  
    538  
    539 class _Marshaller_gsdlInterface_corbaFilterType : public CORBA::StaticTypeInfo { 
     705::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse; 
     706 
     707 
     708class _Marshaller_gsdlInterface_corbaFilterType : public ::CORBA::StaticTypeInfo { 
    540709    typedef gsdlInterface::corbaFilterType _MICO_T; 
    541710  public: 
     711    ~_Marshaller_gsdlInterface_corbaFilterType(); 
    542712    StaticValueType create () const; 
    543713    void assign (StaticValueType dst, const StaticValueType src) const; 
    544714    void free (StaticValueType) const; 
    545     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    546     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     715    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     716    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    547717}; 
    548718 
    549719 
    550 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const 
     720_Marshaller_gsdlInterface_corbaFilterType::~_Marshaller_gsdlInterface_corbaFilterType() 
     721{ 
     722} 
     723 
     724::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const 
    551725{ 
    552726  return (StaticValueType) new _MICO_T; 
     
    563737} 
    564738 
    565 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    566 { 
    567   CORBA::ULong ul; 
     739::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     740{ 
     741  ::CORBA::ULong ul; 
    568742  if( !dc.enumeration( ul ) ) 
    569743    return FALSE; 
     
    572746} 
    573747 
    574 void _Marshaller_gsdlInterface_corbaFilterType::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    575 { 
    576   ec.enumeration( (CORBA::ULong) *(_MICO_T *) v ); 
    577 } 
    578  
    579 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType; 
    580  
    581  
    582 class _Marshaller_gsdlInterface_corbaFilterRepeatable : public CORBA::StaticTypeInfo { 
     748void _Marshaller_gsdlInterface_corbaFilterType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     749{ 
     750  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); 
     751} 
     752 
     753::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType; 
     754 
     755 
     756class _Marshaller_gsdlInterface_corbaFilterRepeatable : public ::CORBA::StaticTypeInfo { 
    583757    typedef gsdlInterface::corbaFilterRepeatable _MICO_T; 
    584758  public: 
     759    ~_Marshaller_gsdlInterface_corbaFilterRepeatable(); 
    585760    StaticValueType create () const; 
    586761    void assign (StaticValueType dst, const StaticValueType src) const; 
    587762    void free (StaticValueType) const; 
    588     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    589     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     763    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     764    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    590765}; 
    591766 
    592767 
    593 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const 
     768_Marshaller_gsdlInterface_corbaFilterRepeatable::~_Marshaller_gsdlInterface_corbaFilterRepeatable() 
     769{ 
     770} 
     771 
     772::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const 
    594773{ 
    595774  return (StaticValueType) new _MICO_T; 
     
    606785} 
    607786 
    608 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    609 { 
    610   CORBA::ULong ul; 
     787::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     788{ 
     789  ::CORBA::ULong ul; 
    611790  if( !dc.enumeration( ul ) ) 
    612791    return FALSE; 
     
    615794} 
    616795 
    617 void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    618 { 
    619   ec.enumeration( (CORBA::ULong) *(_MICO_T *) v ); 
    620 } 
    621  
    622 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable; 
     796void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     797{ 
     798  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); 
     799} 
     800 
     801::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable; 
    623802 
    624803#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    652831#endif 
    653832 
    654 class _Marshaller_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo { 
     833class _Marshaller_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo { 
    655834    typedef gsdlInterface::corbaFilterOption _MICO_T; 
    656835  public: 
     836    ~_Marshaller_gsdlInterface_corbaFilterOption(); 
    657837    StaticValueType create () const; 
    658838    void assign (StaticValueType dst, const StaticValueType src) const; 
    659839    void free (StaticValueType) const; 
    660     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    661     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     840    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     841    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    662842}; 
    663843 
    664844 
    665 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const 
     845_Marshaller_gsdlInterface_corbaFilterOption::~_Marshaller_gsdlInterface_corbaFilterOption() 
     846{ 
     847} 
     848 
     849::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const 
    666850{ 
    667851  return (StaticValueType) new _MICO_T; 
     
    678862} 
    679863 
    680 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     864::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    681865{ 
    682866  return 
     
    690874} 
    691875 
    692 void _Marshaller_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     876void _Marshaller_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    693877{ 
    694878  ec.struct_begin(); 
     
    701885} 
    702886 
    703 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption; 
     887::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption; 
    704888 
    705889 
     
    728912#endif 
    729913 
    730 class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public CORBA::StaticTypeInfo { 
     914class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public ::CORBA::StaticTypeInfo { 
    731915    typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T; 
    732916  public: 
     917    ~_Marshaller_gsdlInterface_corbaFilterOptionsResponse(); 
    733918    StaticValueType create () const; 
    734919    void assign (StaticValueType dst, const StaticValueType src) const; 
    735920    void free (StaticValueType) const; 
    736     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    737     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     921    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     922    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    738923}; 
    739924 
    740925 
    741 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const 
     926_Marshaller_gsdlInterface_corbaFilterOptionsResponse::~_Marshaller_gsdlInterface_corbaFilterOptionsResponse() 
     927{ 
     928} 
     929 
     930::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const 
    742931{ 
    743932  return (StaticValueType) new _MICO_T; 
     
    754943} 
    755944 
    756 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     945::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    757946{ 
    758947  return 
     
    763952} 
    764953 
    765 void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     954void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    766955{ 
    767956  ec.struct_begin(); 
     
    771960} 
    772961 
    773 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse; 
     962::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse; 
    774963 
    775964#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    797986#endif 
    798987 
    799 class _Marshaller_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo { 
     988class _Marshaller_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo { 
    800989    typedef gsdlInterface::corbaOptionValue _MICO_T; 
    801990  public: 
     991    ~_Marshaller_gsdlInterface_corbaOptionValue(); 
    802992    StaticValueType create () const; 
    803993    void assign (StaticValueType dst, const StaticValueType src) const; 
    804994    void free (StaticValueType) const; 
    805     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    806     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     995    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     996    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    807997}; 
    808998 
    809999 
    810 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const 
     1000_Marshaller_gsdlInterface_corbaOptionValue::~_Marshaller_gsdlInterface_corbaOptionValue() 
     1001{ 
     1002} 
     1003 
     1004::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const 
    8111005{ 
    8121006  return (StaticValueType) new _MICO_T; 
     
    8231017} 
    8241018 
    825 CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1019::CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    8261020{ 
    8271021  return 
     
    8321026} 
    8331027 
    834 void _Marshaller_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1028void _Marshaller_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    8351029{ 
    8361030  ec.struct_begin(); 
     
    8401034} 
    8411035 
    842 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue; 
     1036::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue; 
    8431037 
    8441038 
     
    8791073#endif 
    8801074 
    881 class _Marshaller_gsdlInterface_corbaFilterRequest : public CORBA::StaticTypeInfo { 
     1075class _Marshaller_gsdlInterface_corbaFilterRequest : public ::CORBA::StaticTypeInfo { 
    8821076    typedef gsdlInterface::corbaFilterRequest _MICO_T; 
    8831077  public: 
     1078    ~_Marshaller_gsdlInterface_corbaFilterRequest(); 
    8841079    StaticValueType create () const; 
    8851080    void assign (StaticValueType dst, const StaticValueType src) const; 
    8861081    void free (StaticValueType) const; 
    887     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    888     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1082    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1083    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    8891084}; 
    8901085 
    8911086 
    892 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const 
     1087_Marshaller_gsdlInterface_corbaFilterRequest::~_Marshaller_gsdlInterface_corbaFilterRequest() 
     1088{ 
     1089} 
     1090 
     1091::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const 
    8931092{ 
    8941093  return (StaticValueType) new _MICO_T; 
     
    9051104} 
    9061105 
    907 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1106::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    9081107{ 
    9091108  return 
     
    9201119} 
    9211120 
    922 void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1121void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    9231122{ 
    9241123  ec.struct_begin(); 
     
    9341133} 
    9351134 
    936 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest; 
     1135::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest; 
    9371136 
    9381137#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    9621161#endif 
    9631162 
    964 class _Marshaller_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo { 
     1163class _Marshaller_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo { 
    9651164    typedef gsdlInterface::corbaTermInfo _MICO_T; 
    9661165  public: 
     1166    ~_Marshaller_gsdlInterface_corbaTermInfo(); 
    9671167    StaticValueType create () const; 
    9681168    void assign (StaticValueType dst, const StaticValueType src) const; 
    9691169    void free (StaticValueType) const; 
    970     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    971     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1170    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1171    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    9721172}; 
    9731173 
    9741174 
    975 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const 
     1175_Marshaller_gsdlInterface_corbaTermInfo::~_Marshaller_gsdlInterface_corbaTermInfo() 
     1176{ 
     1177} 
     1178 
     1179::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const 
    9761180{ 
    9771181  return (StaticValueType) new _MICO_T; 
     
    9881192} 
    9891193 
    990 CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1194::CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    9911195{ 
    9921196  return 
     
    9981202} 
    9991203 
    1000 void _Marshaller_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1204void _Marshaller_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    10011205{ 
    10021206  ec.struct_begin(); 
     
    10071211} 
    10081212 
    1009 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo; 
     1213::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo; 
    10101214 
    10111215 
     
    10401244#endif 
    10411245 
    1042 class _Marshaller_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo { 
     1246class _Marshaller_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo { 
    10431247    typedef gsdlInterface::corbaMetadataInfo _MICO_T; 
    10441248  public: 
     1249    ~_Marshaller_gsdlInterface_corbaMetadataInfo(); 
    10451250    StaticValueType create () const; 
    10461251    void assign (StaticValueType dst, const StaticValueType src) const; 
    10471252    void free (StaticValueType) const; 
    1048     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1049     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1253    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1254    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    10501255}; 
    10511256 
    10521257 
    1053 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const 
     1258_Marshaller_gsdlInterface_corbaMetadataInfo::~_Marshaller_gsdlInterface_corbaMetadataInfo() 
     1259{ 
     1260} 
     1261 
     1262::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const 
    10541263{ 
    10551264  return (StaticValueType) new _MICO_T; 
     
    10661275} 
    10671276 
    1068 CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1277::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    10691278{ 
    10701279  return 
     
    10781287} 
    10791288 
    1080 void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1289void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    10811290{ 
    10821291  ec.struct_begin(); 
     
    10891298} 
    10901299 
    1091 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo; 
     1300::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo; 
    10921301 
    10931302 
     
    11161325#endif 
    11171326 
    1118 class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public CORBA::StaticTypeInfo { 
     1327class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public ::CORBA::StaticTypeInfo { 
    11191328    typedef gsdlInterface::corbaMetadataInfo_map _MICO_T; 
    11201329  public: 
     1330    ~_Marshaller_gsdlInterface_corbaMetadataInfo_map(); 
    11211331    StaticValueType create () const; 
    11221332    void assign (StaticValueType dst, const StaticValueType src) const; 
    11231333    void free (StaticValueType) const; 
    1124     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1125     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1334    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1335    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    11261336}; 
    11271337 
    11281338 
    1129 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const 
     1339_Marshaller_gsdlInterface_corbaMetadataInfo_map::~_Marshaller_gsdlInterface_corbaMetadataInfo_map() 
     1340{ 
     1341} 
     1342 
     1343::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const 
    11301344{ 
    11311345  return (StaticValueType) new _MICO_T; 
     
    11421356} 
    11431357 
    1144 CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1358::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    11451359{ 
    11461360  return 
     
    11511365} 
    11521366 
    1153 void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1367void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    11541368{ 
    11551369  ec.struct_begin(); 
     
    11591373} 
    11601374 
    1161 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map; 
     1375::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map; 
    11621376 
    11631377 
     
    12021416#endif 
    12031417 
    1204 class _Marshaller_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo { 
     1418class _Marshaller_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo { 
    12051419    typedef gsdlInterface::corbaResultDocInfo _MICO_T; 
    12061420  public: 
     1421    ~_Marshaller_gsdlInterface_corbaResultDocInfo(); 
    12071422    StaticValueType create () const; 
    12081423    void assign (StaticValueType dst, const StaticValueType src) const; 
    12091424    void free (StaticValueType) const; 
    1210     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1211     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1425    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1426    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    12121427}; 
    12131428 
    12141429 
    1215 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const 
     1430_Marshaller_gsdlInterface_corbaResultDocInfo::~_Marshaller_gsdlInterface_corbaResultDocInfo() 
     1431{ 
     1432} 
     1433 
     1434::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const 
    12161435{ 
    12171436  return (StaticValueType) new _MICO_T; 
     
    12281447} 
    12291448 
    1230 CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1449::CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    12311450{ 
    12321451  return 
     
    12451464} 
    12461465 
    1247 void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1466void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    12481467{ 
    12491468  ec.struct_begin(); 
     
    12611480} 
    12621481 
    1263 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo; 
    1264  
    1265  
    1266  
    1267 class _Marshaller_gsdlInterface_corbaIsApprox : public CORBA::StaticTypeInfo { 
     1482::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo; 
     1483 
     1484 
     1485 
     1486class _Marshaller_gsdlInterface_corbaIsApprox : public ::CORBA::StaticTypeInfo { 
    12681487    typedef gsdlInterface::corbaIsApprox _MICO_T; 
    12691488  public: 
     1489    ~_Marshaller_gsdlInterface_corbaIsApprox(); 
    12701490    StaticValueType create () const; 
    12711491    void assign (StaticValueType dst, const StaticValueType src) const; 
    12721492    void free (StaticValueType) const; 
    1273     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1274     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1493    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1494    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    12751495}; 
    12761496 
    12771497 
    1278 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const 
     1498_Marshaller_gsdlInterface_corbaIsApprox::~_Marshaller_gsdlInterface_corbaIsApprox() 
     1499{ 
     1500} 
     1501 
     1502::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const 
    12791503{ 
    12801504  return (StaticValueType) new _MICO_T; 
     
    12911515} 
    12921516 
    1293 CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1294 { 
    1295   CORBA::ULong ul; 
     1517::CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     1518{ 
     1519  ::CORBA::ULong ul; 
    12961520  if( !dc.enumeration( ul ) ) 
    12971521    return FALSE; 
     
    13001524} 
    13011525 
    1302 void _Marshaller_gsdlInterface_corbaIsApprox::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1303 { 
    1304   ec.enumeration( (CORBA::ULong) *(_MICO_T *) v ); 
    1305 } 
    1306  
    1307 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox; 
     1526void _Marshaller_gsdlInterface_corbaIsApprox::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     1527{ 
     1528  ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); 
     1529} 
     1530 
     1531::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox; 
    13081532 
    13091533#ifdef HAVE_EXPLICIT_STRUCT_OPS 
     
    13351559#endif 
    13361560 
    1337 class _Marshaller_gsdlInterface_corbaFilterResponse : public CORBA::StaticTypeInfo { 
     1561class _Marshaller_gsdlInterface_corbaFilterResponse : public ::CORBA::StaticTypeInfo { 
    13381562    typedef gsdlInterface::corbaFilterResponse _MICO_T; 
    13391563  public: 
     1564    ~_Marshaller_gsdlInterface_corbaFilterResponse(); 
    13401565    StaticValueType create () const; 
    13411566    void assign (StaticValueType dst, const StaticValueType src) const; 
    13421567    void free (StaticValueType) const; 
    1343     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1344     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     1568    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1569    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    13451570}; 
    13461571 
    13471572 
    1348 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const 
     1573_Marshaller_gsdlInterface_corbaFilterResponse::~_Marshaller_gsdlInterface_corbaFilterResponse() 
     1574{ 
     1575} 
     1576 
     1577::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const 
    13491578{ 
    13501579  return (StaticValueType) new _MICO_T; 
     
    13611590} 
    13621591 
    1363 CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
     1592::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
    13641593{ 
    13651594  return 
     
    13721601} 
    13731602 
    1374 void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
     1603void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
    13751604{ 
    13761605  ec.struct_begin(); 
     
    13821611} 
    13831612 
    1384 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse; 
    1385  
    1386  
    1387 // Stub interface corbaiface 
     1613::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse; 
     1614 
     1615 
     1616/* 
     1617 * Base interface for class corbaiface 
     1618 */ 
     1619 
    13881620gsdlInterface::corbaiface::~corbaiface() 
    13891621{ 
    13901622} 
    13911623 
    1392 void *gsdlInterface::corbaiface::_narrow_helper( const char *_rid ) 
    1393 { 
    1394   if( strcmp( _rid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 ) 
     1624void * 
     1625gsdlInterface::corbaiface::_narrow_helper( const char *_repoid ) 
     1626{ 
     1627  if( strcmp( _repoid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 ) 
    13951628    return (void *)this; 
    13961629  return NULL; 
    13971630} 
    13981631 
    1399 bool gsdlInterface::corbaiface::_narrow_helper2( CORBA::Object_ptr _obj ) 
    1400 { 
    1401   if( strcmp( _obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0" ) == 0) { 
    1402     return true; 
    1403   } 
    1404   for( vector<CORBA::Narrow_proto>::size_type _i = 0; 
    1405        _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) { 
    1406     bool _res = (*(*_narrow_helpers)[ _i ])( _obj ); 
    1407     if( _res ) 
    1408       return true; 
    1409   } 
    1410   return false; 
    1411 } 
    1412  
    1413 gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj ) 
     1632gsdlInterface::corbaiface_ptr 
     1633gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj ) 
    14141634{ 
    14151635  gsdlInterface::corbaiface_ptr _o; 
     
    14181638    if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" ))) 
    14191639      return _duplicate( (gsdlInterface::corbaiface_ptr) _p ); 
    1420     if( _narrow_helper2( _obj ) || 
    1421        ( _obj->_is_a_remote( "IDL:gsdlInterface/corbaiface:1.0" ) ) ) { 
     1640    if (!strcmp (_obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0") || _obj->_is_a_remote ("IDL:gsdlInterface/corbaiface:1.0")) { 
    14221641      _o = new gsdlInterface::corbaiface_stub; 
    1423       _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj ); 
     1642      _o->CORBA::Object::operator=( *_obj ); 
    14241643      return _o; 
    14251644    } 
     
    14341653} 
    14351654 
     1655class _Marshaller_gsdlInterface_corbaiface : public ::CORBA::StaticTypeInfo { 
     1656    typedef gsdlInterface::corbaiface_ptr _MICO_T; 
     1657  public: 
     1658    ~_Marshaller_gsdlInterface_corbaiface(); 
     1659    StaticValueType create () const; 
     1660    void assign (StaticValueType dst, const StaticValueType src) const; 
     1661    void free (StaticValueType) const; 
     1662    void release (StaticValueType) const; 
     1663    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     1664    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
     1665}; 
     1666 
     1667 
     1668_Marshaller_gsdlInterface_corbaiface::~_Marshaller_gsdlInterface_corbaiface() 
     1669{ 
     1670} 
     1671 
     1672::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const 
     1673{ 
     1674  return (StaticValueType) new _MICO_T( 0 ); 
     1675} 
     1676 
     1677void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const 
     1678{ 
     1679  *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s ); 
     1680} 
     1681 
     1682void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const 
     1683{ 
     1684  ::CORBA::release( *(_MICO_T *) v ); 
     1685  delete (_MICO_T*) v; 
     1686} 
     1687 
     1688void _Marshaller_gsdlInterface_corbaiface::release( StaticValueType v ) const 
     1689{ 
     1690  ::CORBA::release( *(_MICO_T *) v ); 
     1691} 
     1692 
     1693::CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     1694{ 
     1695  ::CORBA::Object_ptr obj; 
     1696  if (!::CORBA::_stc_Object->demarshal(dc, &obj)) 
     1697    return FALSE; 
     1698  *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj ); 
     1699  ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v); 
     1700  ::CORBA::release (obj); 
     1701  return ret; 
     1702} 
     1703 
     1704void _Marshaller_gsdlInterface_corbaiface::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     1705{ 
     1706  ::CORBA::Object_ptr obj = *(_MICO_T *) v; 
     1707  ::CORBA::_stc_Object->marshal( ec, &obj ); 
     1708} 
     1709 
     1710::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface; 
     1711 
     1712 
     1713/* 
     1714 * Stub interface for class corbaiface 
     1715 */ 
     1716 
    14361717gsdlInterface::corbaiface_stub::~corbaiface_stub() 
    14371718{ 
    14381719} 
    14391720 
    1440 CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& error ) 
    1441 { 
    1442   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1721#ifndef MICO_CONF_NO_POA 
     1722 
     1723void * 
     1724POA_gsdlInterface::corbaiface::_narrow_helper (const char * repoid) 
     1725{ 
     1726  if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) { 
     1727    return (void *) this; 
     1728  } 
     1729  return NULL; 
     1730} 
     1731 
     1732POA_gsdlInterface::corbaiface * 
     1733POA_gsdlInterface::corbaiface::_narrow (PortableServer::Servant serv)  
     1734{ 
     1735  void * p; 
     1736  if ((p = serv->_narrow_helper ("IDL:gsdlInterface/corbaiface:1.0")) != NULL) { 
     1737    serv->_add_ref (); 
     1738    return (POA_gsdlInterface::corbaiface *) p; 
     1739  } 
     1740  return NULL; 
     1741} 
     1742 
     1743gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp () 
     1744{ 
     1745} 
     1746 
     1747gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj) 
     1748  : CORBA::Object(*obj), PortableServer::StubBase(poa) 
     1749{ 
     1750} 
     1751 
     1752gsdlInterface::corbaiface_stub_clp::~corbaiface_stub_clp () 
     1753{ 
     1754} 
     1755 
     1756#endif // MICO_CONF_NO_POA 
     1757 
     1758CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& _par_error ) 
     1759{ 
     1760  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    14431761  CORBA::Boolean _res; 
    14441762  CORBA::StaticAny __res( CORBA::_stc_boolean, &_res ); 
    14451763 
    14461764  CORBA::StaticRequest __req( this, "initialise" ); 
    1447   __req.add_inout_arg( &_error ); 
     1765  __req.add_inout_arg( &_sa_error ); 
    14481766  __req.set_result( &__res ); 
    14491767 
     
    14561774 
    14571775 
    1458 void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error ) 
    1459 { 
    1460   CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key ); 
    1461   CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline ); 
    1462   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1776#ifndef MICO_CONF_NO_POA 
     1777 
     1778CORBA::Boolean 
     1779gsdlInterface::corbaiface_stub_clp::initialise( gsdlInterface::corbaComError& _par_error ) 
     1780{ 
     1781  PortableServer::Servant _serv = _preinvoke (); 
     1782  if (_serv) { 
     1783    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     1784    if (_myserv) { 
     1785      CORBA::Boolean __res; 
     1786 
     1787      #ifdef HAVE_EXCEPTIONS 
     1788      try { 
     1789      #endif 
     1790        __res = _myserv->initialise(_par_error); 
     1791      #ifdef HAVE_EXCEPTIONS 
     1792      } 
     1793      catch (...) { 
     1794        _myserv->_remove_ref(); 
     1795        _postinvoke(); 
     1796        throw; 
     1797      } 
     1798      #endif 
     1799 
     1800      _myserv->_remove_ref(); 
     1801      _postinvoke (); 
     1802      return __res; 
     1803    } 
     1804    _postinvoke (); 
     1805  } 
     1806 
     1807  return gsdlInterface::corbaiface_stub::initialise(_par_error); 
     1808} 
     1809 
     1810#endif // MICO_CONF_NO_POA 
     1811 
     1812void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error ) 
     1813{ 
     1814  CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key ); 
     1815  CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline ); 
     1816  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    14631817  CORBA::StaticRequest __req( this, "configure" ); 
    1464   __req.add_in_arg( &_key ); 
    1465   __req.add_in_arg( &_cfgline ); 
    1466   __req.add_inout_arg( &_error ); 
     1818  __req.add_in_arg( &_sa_key ); 
     1819  __req.add_in_arg( &_sa_cfgline ); 
     1820  __req.add_inout_arg( &_sa_error ); 
    14671821 
    14681822  __req.invoke(); 
     
    14731827 
    14741828 
    1475 void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error ) 
    1476 { 
    1477   CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist ); 
    1478   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1829#ifndef MICO_CONF_NO_POA 
     1830 
     1831void 
     1832gsdlInterface::corbaiface_stub_clp::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error ) 
     1833{ 
     1834  PortableServer::Servant _serv = _preinvoke (); 
     1835  if (_serv) { 
     1836    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     1837    if (_myserv) { 
     1838      #ifdef HAVE_EXCEPTIONS 
     1839      try { 
     1840      #endif 
     1841        _myserv->configure(_par_key, _par_cfgline, _par_error); 
     1842      #ifdef HAVE_EXCEPTIONS 
     1843      } 
     1844      catch (...) { 
     1845        _myserv->_remove_ref(); 
     1846        _postinvoke(); 
     1847        throw; 
     1848      } 
     1849      #endif 
     1850 
     1851      _myserv->_remove_ref(); 
     1852      _postinvoke (); 
     1853      return; 
     1854    } 
     1855    _postinvoke (); 
     1856  } 
     1857 
     1858  gsdlInterface::corbaiface_stub::configure(_par_key, _par_cfgline, _par_error); 
     1859} 
     1860 
     1861#endif // MICO_CONF_NO_POA 
     1862 
     1863void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error ) 
     1864{ 
     1865  CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist ); 
     1866  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    14791867  CORBA::StaticRequest __req( this, "collectionList" ); 
    1480   __req.add_inout_arg( &_collist ); 
    1481   __req.add_inout_arg( &_error ); 
     1868  __req.add_inout_arg( &_sa_collist ); 
     1869  __req.add_inout_arg( &_sa_error ); 
    14821870 
    14831871  __req.invoke(); 
     
    14881876 
    14891877 
    1490 void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error ) 
    1491 { 
    1492   CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection ); 
    1493   CORBA::StaticAny _has( CORBA::_stc_boolean, &has ); 
    1494   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1878#ifndef MICO_CONF_NO_POA 
     1879 
     1880void 
     1881gsdlInterface::corbaiface_stub_clp::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error ) 
     1882{ 
     1883  PortableServer::Servant _serv = _preinvoke (); 
     1884  if (_serv) { 
     1885    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     1886    if (_myserv) { 
     1887      #ifdef HAVE_EXCEPTIONS 
     1888      try { 
     1889      #endif 
     1890        _myserv->collectionList(_par_collist, _par_error); 
     1891      #ifdef HAVE_EXCEPTIONS 
     1892      } 
     1893      catch (...) { 
     1894        _myserv->_remove_ref(); 
     1895        _postinvoke(); 
     1896        throw; 
     1897      } 
     1898      #endif 
     1899 
     1900      _myserv->_remove_ref(); 
     1901      _postinvoke (); 
     1902      return; 
     1903    } 
     1904    _postinvoke (); 
     1905  } 
     1906 
     1907  gsdlInterface::corbaiface_stub::collectionList(_par_collist, _par_error); 
     1908} 
     1909 
     1910#endif // MICO_CONF_NO_POA 
     1911 
     1912void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error ) 
     1913{ 
     1914  CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection ); 
     1915  CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has ); 
     1916  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    14951917  CORBA::StaticRequest __req( this, "hasCollection" ); 
    1496   __req.add_in_arg( &_corbaCollection ); 
    1497   __req.add_inout_arg( &_has ); 
    1498   __req.add_inout_arg( &_error ); 
     1918  __req.add_in_arg( &_sa_corbaCollection ); 
     1919  __req.add_inout_arg( &_sa_has ); 
     1920  __req.add_inout_arg( &_sa_error ); 
    14991921 
    15001922  __req.invoke(); 
     
    15051927 
    15061928 
    1507 void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, gsdlInterface::corbaComError& error ) 
    1508 { 
    1509   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1510   CORBA::StaticAny _wasSuccess( CORBA::_stc_boolean, &wasSuccess ); 
    1511   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1929#ifndef MICO_CONF_NO_POA 
     1930 
     1931void 
     1932gsdlInterface::corbaiface_stub_clp::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error ) 
     1933{ 
     1934  PortableServer::Servant _serv = _preinvoke (); 
     1935  if (_serv) { 
     1936    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     1937    if (_myserv) { 
     1938      #ifdef HAVE_EXCEPTIONS 
     1939      try { 
     1940      #endif 
     1941        _myserv->hasCollection(_par_corbaCollection, _par_has, _par_error); 
     1942      #ifdef HAVE_EXCEPTIONS 
     1943      } 
     1944      catch (...) { 
     1945        _myserv->_remove_ref(); 
     1946        _postinvoke(); 
     1947        throw; 
     1948      } 
     1949      #endif 
     1950 
     1951      _myserv->_remove_ref(); 
     1952      _postinvoke (); 
     1953      return; 
     1954    } 
     1955    _postinvoke (); 
     1956  } 
     1957 
     1958  gsdlInterface::corbaiface_stub::hasCollection(_par_corbaCollection, _par_has, _par_error); 
     1959} 
     1960 
     1961#endif // MICO_CONF_NO_POA 
     1962 
     1963void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error ) 
     1964{ 
     1965  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     1966  CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess ); 
     1967  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    15121968  CORBA::StaticRequest __req( this, "ping" ); 
    1513   __req.add_in_arg( &_collection ); 
    1514   __req.add_inout_arg( &_wasSuccess ); 
    1515   __req.add_inout_arg( &_error ); 
     1969  __req.add_in_arg( &_sa_collection ); 
     1970  __req.add_inout_arg( &_sa_wasSuccess ); 
     1971  __req.add_inout_arg( &_sa_error ); 
    15161972 
    15171973  __req.invoke(); 
     
    15221978 
    15231979 
    1524 void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error ) 
    1525 { 
    1526   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1527   CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request ); 
    1528   CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response ); 
    1529   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     1980#ifndef MICO_CONF_NO_POA 
     1981 
     1982void 
     1983gsdlInterface::corbaiface_stub_clp::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error ) 
     1984{ 
     1985  PortableServer::Servant _serv = _preinvoke (); 
     1986  if (_serv) { 
     1987    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     1988    if (_myserv) { 
     1989      #ifdef HAVE_EXCEPTIONS 
     1990      try { 
     1991      #endif 
     1992        _myserv->ping(_par_collection, _par_wasSuccess, _par_error); 
     1993      #ifdef HAVE_EXCEPTIONS 
     1994      } 
     1995      catch (...) { 
     1996        _myserv->_remove_ref(); 
     1997        _postinvoke(); 
     1998        throw; 
     1999      } 
     2000      #endif 
     2001 
     2002      _myserv->_remove_ref(); 
     2003      _postinvoke (); 
     2004      return; 
     2005    } 
     2006    _postinvoke (); 
     2007  } 
     2008 
     2009  gsdlInterface::corbaiface_stub::ping(_par_collection, _par_wasSuccess, _par_error); 
     2010} 
     2011 
     2012#endif // MICO_CONF_NO_POA 
     2013 
     2014void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2015{ 
     2016  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2017  CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request ); 
     2018  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response ); 
     2019  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    15302020  CORBA::StaticRequest __req( this, "getDocument" ); 
    1531   __req.add_in_arg( &_collection ); 
    1532   __req.add_inout_arg( &_request ); 
    1533   __req.add_inout_arg( &_response ); 
    1534   __req.add_inout_arg( &_error ); 
     2021  __req.add_in_arg( &_sa_collection ); 
     2022  __req.add_inout_arg( &_sa_request ); 
     2023  __req.add_inout_arg( &_sa_response ); 
     2024  __req.add_inout_arg( &_sa_error ); 
    15352025 
    15362026  __req.invoke(); 
     
    15412031 
    15422032 
    1543 void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error ) 
    1544 { 
    1545   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1546   CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response ); 
    1547   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     2033#ifndef MICO_CONF_NO_POA 
     2034 
     2035void 
     2036gsdlInterface::corbaiface_stub_clp::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2037{ 
     2038  PortableServer::Servant _serv = _preinvoke (); 
     2039  if (_serv) { 
     2040    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2041    if (_myserv) { 
     2042      #ifdef HAVE_EXCEPTIONS 
     2043      try { 
     2044      #endif 
     2045        _myserv->getDocument(_par_collection, _par_request, _par_response, _par_error); 
     2046      #ifdef HAVE_EXCEPTIONS 
     2047      } 
     2048      catch (...) { 
     2049        _myserv->_remove_ref(); 
     2050        _postinvoke(); 
     2051        throw; 
     2052      } 
     2053      #endif 
     2054 
     2055      _myserv->_remove_ref(); 
     2056      _postinvoke (); 
     2057      return; 
     2058    } 
     2059    _postinvoke (); 
     2060  } 
     2061 
     2062  gsdlInterface::corbaiface_stub::getDocument(_par_collection, _par_request, _par_response, _par_error); 
     2063} 
     2064 
     2065#endif // MICO_CONF_NO_POA 
     2066 
     2067void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2068{ 
     2069  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2070  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response ); 
     2071  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    15482072  CORBA::StaticRequest __req( this, "getCollectInfo" ); 
    1549   __req.add_in_arg( &_collection ); 
    1550   __req.add_inout_arg( &_response ); 
    1551   __req.add_inout_arg( &_error ); 
     2073  __req.add_in_arg( &_sa_collection ); 
     2074  __req.add_inout_arg( &_sa_response ); 
     2075  __req.add_inout_arg( &_sa_error ); 
    15522076 
    15532077  __req.invoke(); 
     
    15582082 
    15592083 
    1560 void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error ) 
    1561 { 
    1562   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1563   CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames ); 
    1564   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     2084#ifndef MICO_CONF_NO_POA 
     2085 
     2086void 
     2087gsdlInterface::corbaiface_stub_clp::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2088{ 
     2089  PortableServer::Servant _serv = _preinvoke (); 
     2090  if (_serv) { 
     2091    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2092    if (_myserv) { 
     2093      #ifdef HAVE_EXCEPTIONS 
     2094      try { 
     2095      #endif 
     2096        _myserv->getCollectInfo(_par_collection, _par_response, _par_error); 
     2097      #ifdef HAVE_EXCEPTIONS 
     2098      } 
     2099      catch (...) { 
     2100        _myserv->_remove_ref(); 
     2101        _postinvoke(); 
     2102        throw; 
     2103      } 
     2104      #endif 
     2105 
     2106      _myserv->_remove_ref(); 
     2107      _postinvoke (); 
     2108      return; 
     2109    } 
     2110    _postinvoke (); 
     2111  } 
     2112 
     2113  gsdlInterface::corbaiface_stub::getCollectInfo(_par_collection, _par_response, _par_error); 
     2114} 
     2115 
     2116#endif // MICO_CONF_NO_POA 
     2117 
     2118void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error ) 
     2119{ 
     2120  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2121  CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames ); 
     2122  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    15652123  CORBA::StaticRequest __req( this, "getFilterInfo" ); 
    1566   __req.add_in_arg( &_collection ); 
    1567   __req.add_inout_arg( &_filterNames ); 
    1568   __req.add_inout_arg( &_error ); 
     2124  __req.add_in_arg( &_sa_collection ); 
     2125  __req.add_inout_arg( &_sa_filterNames ); 
     2126  __req.add_inout_arg( &_sa_error ); 
    15692127 
    15702128  __req.invoke(); 
     
    15752133 
    15762134 
    1577 void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error ) 
    1578 { 
    1579   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1580   CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option ); 
    1581   CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response ); 
    1582   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     2135#ifndef MICO_CONF_NO_POA 
     2136 
     2137void 
     2138gsdlInterface::corbaiface_stub_clp::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error ) 
     2139{ 
     2140  PortableServer::Servant _serv = _preinvoke (); 
     2141  if (_serv) { 
     2142    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2143    if (_myserv) { 
     2144      #ifdef HAVE_EXCEPTIONS 
     2145      try { 
     2146      #endif 
     2147        _myserv->getFilterInfo(_par_collection, _par_filterNames, _par_error); 
     2148      #ifdef HAVE_EXCEPTIONS 
     2149      } 
     2150      catch (...) { 
     2151        _myserv->_remove_ref(); 
     2152        _postinvoke(); 
     2153        throw; 
     2154      } 
     2155      #endif 
     2156 
     2157      _myserv->_remove_ref(); 
     2158      _postinvoke (); 
     2159      return; 
     2160    } 
     2161    _postinvoke (); 
     2162  } 
     2163 
     2164  gsdlInterface::corbaiface_stub::getFilterInfo(_par_collection, _par_filterNames, _par_error); 
     2165} 
     2166 
     2167#endif // MICO_CONF_NO_POA 
     2168 
     2169void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2170{ 
     2171  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2172  CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option ); 
     2173  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response ); 
     2174  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    15832175  CORBA::StaticRequest __req( this, "getFilterOptions" ); 
    1584   __req.add_in_arg( &_collection ); 
    1585   __req.add_in_arg( &_option ); 
    1586   __req.add_inout_arg( &_response ); 
    1587   __req.add_inout_arg( &_error ); 
     2176  __req.add_in_arg( &_sa_collection ); 
     2177  __req.add_in_arg( &_sa_option ); 
     2178  __req.add_inout_arg( &_sa_response ); 
     2179  __req.add_inout_arg( &_sa_error ); 
    15882180 
    15892181  __req.invoke(); 
     
    15942186 
    15952187 
    1596 void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error ) 
    1597 { 
    1598   CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection ); 
    1599   CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request ); 
    1600   CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response ); 
    1601   CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error ); 
     2188#ifndef MICO_CONF_NO_POA 
     2189 
     2190void 
     2191gsdlInterface::corbaiface_stub_clp::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2192{ 
     2193  PortableServer::Servant _serv = _preinvoke (); 
     2194  if (_serv) { 
     2195    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2196    if (_myserv) { 
     2197      #ifdef HAVE_EXCEPTIONS 
     2198      try { 
     2199      #endif 
     2200        _myserv->getFilterOptions(_par_collection, _par_option, _par_response, _par_error); 
     2201      #ifdef HAVE_EXCEPTIONS 
     2202      } 
     2203      catch (...) { 
     2204        _myserv->_remove_ref(); 
     2205        _postinvoke(); 
     2206        throw; 
     2207      } 
     2208      #endif 
     2209 
     2210      _myserv->_remove_ref(); 
     2211      _postinvoke (); 
     2212      return; 
     2213    } 
     2214    _postinvoke (); 
     2215  } 
     2216 
     2217  gsdlInterface::corbaiface_stub::getFilterOptions(_par_collection, _par_option, _par_response, _par_error); 
     2218} 
     2219 
     2220#endif // MICO_CONF_NO_POA 
     2221 
     2222void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2223{ 
     2224  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2225  CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request ); 
     2226  CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response ); 
     2227  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
    16022228  CORBA::StaticRequest __req( this, "filter" ); 
    1603   __req.add_in_arg( &_collection ); 
    1604   __req.add_in_arg( &_request ); 
    1605   __req.add_inout_arg( &_response ); 
    1606   __req.add_inout_arg( &_error ); 
     2229  __req.add_in_arg( &_sa_collection ); 
     2230  __req.add_in_arg( &_sa_request ); 
     2231  __req.add_inout_arg( &_sa_response ); 
     2232  __req.add_inout_arg( &_sa_error ); 
    16072233 
    16082234  __req.invoke(); 
     
    16132239 
    16142240 
    1615 #ifdef HAVE_NAMESPACE 
    1616 namespace gsdlInterface { vector<CORBA::Narrow_proto> * corbaiface::_narrow_helpers; } 
    1617 #else 
    1618 vector<CORBA::Narrow_proto> * gsdlInterface::corbaiface::_narrow_helpers; 
    1619 #endif 
    1620  
    1621 class _Marshaller_gsdlInterface_corbaiface : public CORBA::StaticTypeInfo { 
    1622     typedef gsdlInterface::corbaiface_ptr _MICO_T; 
     2241#ifndef MICO_CONF_NO_POA 
     2242 
     2243void 
     2244gsdlInterface::corbaiface_stub_clp::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error ) 
     2245{ 
     2246  PortableServer::Servant _serv = _preinvoke (); 
     2247  if (_serv) { 
     2248    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2249    if (_myserv) { 
     2250      #ifdef HAVE_EXCEPTIONS 
     2251      try { 
     2252      #endif 
     2253        _myserv->filter(_par_collection, _par_request, _par_response, _par_error); 
     2254      #ifdef HAVE_EXCEPTIONS 
     2255      } 
     2256      catch (...) { 
     2257        _myserv->_remove_ref(); 
     2258        _postinvoke(); 
     2259        throw; 
     2260      } 
     2261      #endif 
     2262 
     2263      _myserv->_remove_ref(); 
     2264      _postinvoke (); 
     2265      return; 
     2266    } 
     2267    _postinvoke (); 
     2268  } 
     2269 
     2270  gsdlInterface::corbaiface_stub::filter(_par_collection, _par_request, _par_response, _par_error); 
     2271} 
     2272 
     2273#endif // MICO_CONF_NO_POA 
     2274 
     2275void 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 ) 
     2276{ 
     2277  CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2278  CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome ); 
     2279  CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items ); 
     2280  CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2281  CORBA::StaticRequest __req( this, "getRssItems" ); 
     2282  __req.add_in_arg( &_sa_collection ); 
     2283  __req.add_in_arg( &_sa_gsdlhome ); 
     2284  __req.add_inout_arg( &_sa_rss_items ); 
     2285  __req.add_inout_arg( &_sa_error ); 
     2286 
     2287  __req.invoke(); 
     2288 
     2289  mico_sii_throw( &__req,  
     2290    0); 
     2291} 
     2292 
     2293 
     2294#ifndef MICO_CONF_NO_POA 
     2295 
     2296void 
     2297gsdlInterface::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 ) 
     2298{ 
     2299  PortableServer::Servant _serv = _preinvoke (); 
     2300  if (_serv) { 
     2301    POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); 
     2302    if (_myserv) { 
     2303      #ifdef HAVE_EXCEPTIONS 
     2304      try { 
     2305      #endif 
     2306        _myserv->getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error); 
     2307      #ifdef HAVE_EXCEPTIONS 
     2308      } 
     2309      catch (...) { 
     2310        _myserv->_remove_ref(); 
     2311        _postinvoke(); 
     2312        throw; 
     2313      } 
     2314      #endif 
     2315 
     2316      _myserv->_remove_ref(); 
     2317      _postinvoke (); 
     2318      return; 
     2319    } 
     2320    _postinvoke (); 
     2321  } 
     2322 
     2323  gsdlInterface::corbaiface_stub::getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error); 
     2324} 
     2325 
     2326#endif // MICO_CONF_NO_POA 
     2327 
     2328class _Marshaller__seq_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo { 
     2329    typedef SequenceTmpl< gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T; 
    16232330  public: 
     2331    ~_Marshaller__seq_gsdlInterface_corbatext_t(); 
    16242332    StaticValueType create () const; 
    16252333    void assign (StaticValueType dst, const StaticValueType src) const; 
    16262334    void free (StaticValueType) const; 
    1627     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1628     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2335    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2336    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    16292337}; 
    16302338 
    16312339 
    1632 CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const 
    1633 { 
    1634   return (StaticValueType) new _MICO_T( 0 ); 
    1635 } 
    1636  
    1637 void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const 
    1638 { 
    1639   *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s ); 
    1640 } 
    1641  
    1642 void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const 
    1643 { 
    1644   CORBA::release( *(_MICO_T *) v ); 
     2340_Marshaller__seq_gsdlInterface_corbatext_t::~_Marshaller__seq_gsdlInterface_corbatext_t() 
     2341{ 
     2342} 
     2343 
     2344::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const 
     2345{ 
     2346  return (StaticValueType) new _MICO_T; 
     2347} 
     2348 
     2349void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const 
     2350{ 
     2351  *(_MICO_T*) d = *(_MICO_T*) s; 
     2352} 
     2353 
     2354void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const 
     2355{ 
    16452356  delete (_MICO_T*) v; 
    16462357} 
    16472358 
    1648 CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1649 { 
    1650   CORBA::Object_ptr obj; 
    1651   if (!CORBA::_stc_Object->demarshal(dc, &obj)) 
    1652     return FALSE; 
    1653   *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj ); 
    1654   CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v); 
    1655   CORBA::release (obj); 
    1656   return ret; 
    1657 } 
    1658  
    1659 void _Marshaller_gsdlInterface_corbaiface::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1660 { 
    1661   CORBA::Object_ptr obj = *(_MICO_T *) v; 
    1662   CORBA::_stc_Object->marshal( ec, &obj ); 
    1663 } 
    1664  
    1665 CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface; 
    1666  
    1667 class _Marshaller__seq_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo { 
    1668     typedef SequenceTmpl<gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T; 
    1669   public: 
    1670     StaticValueType create () const; 
    1671     void assign (StaticValueType dst, const StaticValueType src) const; 
    1672     void free (StaticValueType) const; 
    1673     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1674     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
    1675 }; 
    1676  
    1677  
    1678 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const 
    1679 { 
    1680   return (StaticValueType) new _MICO_T; 
    1681 } 
    1682  
    1683 void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const 
    1684 { 
    1685   *(_MICO_T*) d = *(_MICO_T*) s; 
    1686 } 
    1687  
    1688 void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const 
    1689 { 
    1690   delete (_MICO_T*) v; 
    1691 } 
    1692  
    1693 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1694 { 
    1695   CORBA::ULong len; 
     2359::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2360{ 
     2361  ::CORBA::ULong len; 
    16962362  if( !dc.seq_begin( len ) ) 
    16972363    return FALSE; 
    16982364  ((_MICO_T *) v)->length( len ); 
    1699   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2365  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    17002366    if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    17012367      return FALSE; 
     
    17042370} 
    17052371 
    1706 void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1707 { 
    1708   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2372void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2373{ 
     2374  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    17092375  ec.seq_begin( len ); 
    1710   for( CORBA::ULong i = 0; i < len; i++ ) 
     2376  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    17112377    _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    17122378  ec.seq_end(); 
    17132379} 
    17142380 
    1715 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t; 
    1716  
    1717 class _Marshaller__seq_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo { 
    1718     typedef SequenceTmpl<gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T; 
     2381::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t; 
     2382 
     2383class _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo { 
     2384    typedef SequenceTmpl< gsdlInterface::corbatext_tcollectionmeta,MICO_TID_DEF> _MICO_T; 
    17192385  public: 
     2386    ~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta(); 
    17202387    StaticValueType create () const; 
    17212388    void assign (StaticValueType dst, const StaticValueType src) const; 
    17222389    void free (StaticValueType) const; 
    1723     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1724     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2390    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2391    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    17252392}; 
    17262393 
    17272394 
    1728 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const 
     2395_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta() 
     2396{ 
     2397} 
     2398 
     2399::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::create() const 
    17292400{ 
    17302401  return (StaticValueType) new _MICO_T; 
    17312402} 
    17322403 
    1733 void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const 
     2404void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const 
    17342405{ 
    17352406  *(_MICO_T*) d = *(_MICO_T*) s; 
    17362407} 
    17372408 
    1738 void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const 
     2409void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const 
    17392410{ 
    17402411  delete (_MICO_T*) v; 
    17412412} 
    17422413 
    1743 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1744 { 
    1745   CORBA::ULong len; 
     2414::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2415{ 
     2416  ::CORBA::ULong len; 
    17462417  if( !dc.seq_begin( len ) ) 
    17472418    return FALSE; 
    17482419  ((_MICO_T *) v)->length( len ); 
    1749   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2420  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
     2421    if( !_marshaller_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
     2422      return FALSE; 
     2423  } 
     2424  return dc.seq_end(); 
     2425} 
     2426 
     2427void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2428{ 
     2429  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2430  ec.seq_begin( len ); 
     2431  for( ::CORBA::ULong i = 0; i < len; i++ ) 
     2432    _marshaller_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &(*(_MICO_T*)v)[i] ); 
     2433  ec.seq_end(); 
     2434} 
     2435 
     2436::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta; 
     2437 
     2438class _Marshaller__seq_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo { 
     2439    typedef SequenceTmpl< gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T; 
     2440  public: 
     2441    ~_Marshaller__seq_gsdlInterface_corbaFilterOption(); 
     2442    StaticValueType create () const; 
     2443    void assign (StaticValueType dst, const StaticValueType src) const; 
     2444    void free (StaticValueType) const; 
     2445    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2446    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
     2447}; 
     2448 
     2449 
     2450_Marshaller__seq_gsdlInterface_corbaFilterOption::~_Marshaller__seq_gsdlInterface_corbaFilterOption() 
     2451{ 
     2452} 
     2453 
     2454::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const 
     2455{ 
     2456  return (StaticValueType) new _MICO_T; 
     2457} 
     2458 
     2459void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const 
     2460{ 
     2461  *(_MICO_T*) d = *(_MICO_T*) s; 
     2462} 
     2463 
     2464void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const 
     2465{ 
     2466  delete (_MICO_T*) v; 
     2467} 
     2468 
     2469::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2470{ 
     2471  ::CORBA::ULong len; 
     2472  if( !dc.seq_begin( len ) ) 
     2473    return FALSE; 
     2474  ((_MICO_T *) v)->length( len ); 
     2475  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    17502476    if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    17512477      return FALSE; 
     
    17542480} 
    17552481 
    1756 void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1757 { 
    1758   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2482void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2483{ 
     2484  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    17592485  ec.seq_begin( len ); 
    1760   for( CORBA::ULong i = 0; i < len; i++ ) 
     2486  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    17612487    _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    17622488  ec.seq_end(); 
    17632489} 
    17642490 
    1765 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption; 
    1766  
    1767 class _Marshaller__seq_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo { 
    1768     typedef SequenceTmpl<gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T; 
     2491::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption; 
     2492 
     2493class _Marshaller__seq_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo { 
     2494    typedef SequenceTmpl< gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T; 
    17692495  public: 
     2496    ~_Marshaller__seq_gsdlInterface_corbaOptionValue(); 
    17702497    StaticValueType create () const; 
    17712498    void assign (StaticValueType dst, const StaticValueType src) const; 
    17722499    void free (StaticValueType) const; 
    1773     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1774     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2500    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2501    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    17752502}; 
    17762503 
    17772504 
    1778 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const 
     2505_Marshaller__seq_gsdlInterface_corbaOptionValue::~_Marshaller__seq_gsdlInterface_corbaOptionValue() 
     2506{ 
     2507} 
     2508 
     2509::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const 
    17792510{ 
    17802511  return (StaticValueType) new _MICO_T; 
     
    17912522} 
    17922523 
    1793 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1794 { 
    1795   CORBA::ULong len; 
     2524::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2525{ 
     2526  ::CORBA::ULong len; 
    17962527  if( !dc.seq_begin( len ) ) 
    17972528    return FALSE; 
    17982529  ((_MICO_T *) v)->length( len ); 
    1799   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2530  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    18002531    if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    18012532      return FALSE; 
     
    18042535} 
    18052536 
    1806 void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1807 { 
    1808   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2537void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2538{ 
     2539  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    18092540  ec.seq_begin( len ); 
    1810   for( CORBA::ULong i = 0; i < len; i++ ) 
     2541  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    18112542    _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    18122543  ec.seq_end(); 
    18132544} 
    18142545 
    1815 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue; 
    1816  
    1817 class _Marshaller__seq_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo { 
    1818     typedef SequenceTmpl<gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T; 
     2546::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue; 
     2547 
     2548class _Marshaller__seq_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo { 
     2549    typedef SequenceTmpl< gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T; 
    18192550  public: 
     2551    ~_Marshaller__seq_gsdlInterface_corbaTermInfo(); 
    18202552    StaticValueType create () const; 
    18212553    void assign (StaticValueType dst, const StaticValueType src) const; 
    18222554    void free (StaticValueType) const; 
    1823     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1824     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2555    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2556    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    18252557}; 
    18262558 
    18272559 
    1828 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const 
     2560_Marshaller__seq_gsdlInterface_corbaTermInfo::~_Marshaller__seq_gsdlInterface_corbaTermInfo() 
     2561{ 
     2562} 
     2563 
     2564::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const 
    18292565{ 
    18302566  return (StaticValueType) new _MICO_T; 
     
    18412577} 
    18422578 
    1843 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1844 { 
    1845   CORBA::ULong len; 
     2579::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2580{ 
     2581  ::CORBA::ULong len; 
    18462582  if( !dc.seq_begin( len ) ) 
    18472583    return FALSE; 
    18482584  ((_MICO_T *) v)->length( len ); 
    1849   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2585  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    18502586    if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    18512587      return FALSE; 
     
    18542590} 
    18552591 
    1856 void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1857 { 
    1858   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2592void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2593{ 
     2594  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    18592595  ec.seq_begin( len ); 
    1860   for( CORBA::ULong i = 0; i < len; i++ ) 
     2596  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    18612597    _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    18622598  ec.seq_end(); 
    18632599} 
    18642600 
    1865 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo; 
    1866  
    1867 class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo { 
    1868     typedef SequenceTmpl<gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T; 
     2601::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo; 
     2602 
     2603class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo { 
     2604    typedef SequenceTmpl< gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T; 
    18692605  public: 
     2606    ~_Marshaller__seq_gsdlInterface_corbaMetadataInfo(); 
    18702607    StaticValueType create () const; 
    18712608    void assign (StaticValueType dst, const StaticValueType src) const; 
    18722609    void free (StaticValueType) const; 
    1873     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1874     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2610    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2611    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    18752612}; 
    18762613 
    18772614 
    1878 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const 
     2615_Marshaller__seq_gsdlInterface_corbaMetadataInfo::~_Marshaller__seq_gsdlInterface_corbaMetadataInfo() 
     2616{ 
     2617} 
     2618 
     2619::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const 
    18792620{ 
    18802621  return (StaticValueType) new _MICO_T; 
     
    18912632} 
    18922633 
    1893 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1894 { 
    1895   CORBA::ULong len; 
     2634::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2635{ 
     2636  ::CORBA::ULong len; 
    18962637  if( !dc.seq_begin( len ) ) 
    18972638    return FALSE; 
    18982639  ((_MICO_T *) v)->length( len ); 
    1899   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2640  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    19002641    if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    19012642      return FALSE; 
     
    19042645} 
    19052646 
    1906 void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1907 { 
    1908   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2647void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2648{ 
     2649  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    19092650  ec.seq_begin( len ); 
    1910   for( CORBA::ULong i = 0; i < len; i++ ) 
     2651  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    19112652    _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    19122653  ec.seq_end(); 
    19132654} 
    19142655 
    1915 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo; 
    1916  
    1917 class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo { 
    1918     typedef SequenceTmpl<gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T; 
     2656::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo; 
     2657 
     2658class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo { 
     2659    typedef SequenceTmpl< gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T; 
    19192660  public: 
     2661    ~_Marshaller__seq_gsdlInterface_corbaResultDocInfo(); 
    19202662    StaticValueType create () const; 
    19212663    void assign (StaticValueType dst, const StaticValueType src) const; 
    19222664    void free (StaticValueType) const; 
    1923     CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const; 
    1924     void marshal (CORBA::DataEncoder &, StaticValueType) const; 
     2665    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; 
     2666    void marshal (::CORBA::DataEncoder &, StaticValueType) const; 
    19252667}; 
    19262668 
    19272669 
    1928 CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const 
     2670_Marshaller__seq_gsdlInterface_corbaResultDocInfo::~_Marshaller__seq_gsdlInterface_corbaResultDocInfo() 
     2671{ 
     2672} 
     2673 
     2674::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const 
    19292675{ 
    19302676  return (StaticValueType) new _MICO_T; 
     
    19412687} 
    19422688 
    1943 CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const 
    1944 { 
    1945   CORBA::ULong len; 
     2689::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const 
     2690{ 
     2691  ::CORBA::ULong len; 
    19462692  if( !dc.seq_begin( len ) ) 
    19472693    return FALSE; 
    19482694  ((_MICO_T *) v)->length( len ); 
    1949   for( CORBA::ULong i = 0; i < len; i++ ) { 
     2695  for( ::CORBA::ULong i = 0; i < len; i++ ) { 
    19502696    if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) 
    19512697      return FALSE; 
     
    19542700} 
    19552701 
    1956 void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const 
    1957 { 
    1958   CORBA::ULong len = ((_MICO_T *) v)->length(); 
     2702void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const 
     2703{ 
     2704  ::CORBA::ULong len = ((_MICO_T *) v)->length(); 
    19592705  ec.seq_begin( len ); 
    1960   for( CORBA::ULong i = 0; i < len; i++ ) 
     2706  for( ::CORBA::ULong i = 0; i < len; i++ ) 
    19612707    _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); 
    19622708  ec.seq_end(); 
    19632709} 
    19642710 
    1965 CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo; 
     2711::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo; 
    19662712 
    19672713struct __tc_init_CORBAIFACE { 
     
    19702716    _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t; 
    19712717    _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap; 
     2718    _marshaller_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller_gsdlInterface_corbatext_tcollectionmeta; 
    19722719    _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError; 
    19732720    _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo; 
     
    19892736    _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface; 
    19902737    _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t; 
     2738    _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta; 
    19912739    _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption; 
    19922740    _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue; 
     
    19952743    _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo; 
    19962744  } 
     2745 
     2746  ~__tc_init_CORBAIFACE() 
     2747  { 
     2748    delete static_cast<_Marshaller_gsdlInterface_corbatext_t*>(_marshaller_gsdlInterface_corbatext_t); 
     2749    delete static_cast<_Marshaller_gsdlInterface_corbatext_tmap*>(_marshaller_gsdlInterface_corbatext_tmap); 
     2750    delete static_cast<_Marshaller_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller_gsdlInterface_corbatext_tcollectionmeta); 
     2751    delete static_cast<_Marshaller_gsdlInterface_corbaComError*>(_marshaller_gsdlInterface_corbaComError); 
     2752    delete static_cast<_Marshaller_gsdlInterface_corbaShortColInfo*>(_marshaller_gsdlInterface_corbaShortColInfo); 
     2753    delete static_cast<_Marshaller_gsdlInterface_corbaColInfoResponse*>(_marshaller_gsdlInterface_corbaColInfoResponse); 
     2754    delete static_cast<_Marshaller_gsdlInterface_corbaDocRequest*>(_marshaller_gsdlInterface_corbaDocRequest); 
     2755    delete static_cast<_Marshaller_gsdlInterface_corbaDocResponse*>(_marshaller_gsdlInterface_corbaDocResponse); 
     2756    delete static_cast<_Marshaller_gsdlInterface_corbaFilterType*>(_marshaller_gsdlInterface_corbaFilterType); 
     2757    delete static_cast<_Marshaller_gsdlInterface_corbaFilterRepeatable*>(_marshaller_gsdlInterface_corbaFilterRepeatable); 
     2758    delete static_cast<_Marshaller_gsdlInterface_corbaFilterOption*>(_marshaller_gsdlInterface_corbaFilterOption); 
     2759    delete static_cast<_Marshaller_gsdlInterface_corbaFilterOptionsResponse*>(_marshaller_gsdlInterface_corbaFilterOptionsResponse); 
     2760    delete static_cast<_Marshaller_gsdlInterface_corbaOptionValue*>(_marshaller_gsdlInterface_corbaOptionValue); 
     2761    delete static_cast<_Marshaller_gsdlInterface_corbaFilterRequest*>(_marshaller_gsdlInterface_corbaFilterRequest); 
     2762    delete static_cast<_Marshaller_gsdlInterface_corbaTermInfo*>(_marshaller_gsdlInterface_corbaTermInfo); 
     2763    delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo*>(_marshaller_gsdlInterface_corbaMetadataInfo); 
     2764    delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo_map*>(_marshaller_gsdlInterface_corbaMetadataInfo_map); 
     2765    delete static_cast<_Marshaller_gsdlInterface_corbaResultDocInfo*>(_marshaller_gsdlInterface_corbaResultDocInfo); 
     2766    delete static_cast<_Marshaller_gsdlInterface_corbaIsApprox*>(_marshaller_gsdlInterface_corbaIsApprox); 
     2767    delete static_cast<_Marshaller_gsdlInterface_corbaFilterResponse*>(_marshaller_gsdlInterface_corbaFilterResponse); 
     2768    delete static_cast<_Marshaller_gsdlInterface_corbaiface*>(_marshaller_gsdlInterface_corbaiface); 
     2769    delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_t*>(_marshaller__seq_gsdlInterface_corbatext_t); 
     2770    delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta); 
     2771    delete static_cast<_Marshaller__seq_gsdlInterface_corbaFilterOption*>(_marshaller__seq_gsdlInterface_corbaFilterOption); 
     2772    delete static_cast<_Marshaller__seq_gsdlInterface_corbaOptionValue*>(_marshaller__seq_gsdlInterface_corbaOptionValue); 
     2773    delete static_cast<_Marshaller__seq_gsdlInterface_corbaTermInfo*>(_marshaller__seq_gsdlInterface_corbaTermInfo); 
     2774    delete static_cast<_Marshaller__seq_gsdlInterface_corbaMetadataInfo*>(_marshaller__seq_gsdlInterface_corbaMetadataInfo); 
     2775    delete static_cast<_Marshaller__seq_gsdlInterface_corbaResultDocInfo*>(_marshaller__seq_gsdlInterface_corbaResultDocInfo); 
     2776  } 
    19972777}; 
    19982778 
    19992779static __tc_init_CORBAIFACE __init_CORBAIFACE; 
    20002780 
     2781//-------------------------------------------------------- 
     2782//  Implementation of skeletons 
     2783//-------------------------------------------------------- 
     2784 
     2785// PortableServer Skeleton Class for interface gsdlInterface::corbaiface 
     2786POA_gsdlInterface::corbaiface::~corbaiface() 
     2787{ 
     2788} 
     2789 
     2790::gsdlInterface::corbaiface_ptr 
     2791POA_gsdlInterface::corbaiface::_this () 
     2792{ 
     2793  CORBA::Object_var obj = PortableServer::ServantBase::_this(); 
     2794  return ::gsdlInterface::corbaiface::_narrow (obj); 
     2795} 
     2796 
     2797CORBA::Boolean 
     2798POA_gsdlInterface::corbaiface::_is_a (const char * repoid) 
     2799{ 
     2800  if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) { 
     2801    return TRUE; 
     2802  } 
     2803  return FALSE; 
     2804} 
     2805 
     2806CORBA::InterfaceDef_ptr 
     2807POA_gsdlInterface::corbaiface::_get_interface () 
     2808{ 
     2809  CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:gsdlInterface/corbaiface:1.0"); 
     2810 
     2811  if (CORBA::is_nil (ifd)) { 
     2812    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO)); 
     2813  } 
     2814 
     2815  return ifd; 
     2816} 
     2817 
     2818CORBA::RepositoryId 
     2819POA_gsdlInterface::corbaiface::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr) 
     2820{ 
     2821  return CORBA::string_dup ("IDL:gsdlInterface/corbaiface:1.0"); 
     2822} 
     2823 
     2824CORBA::Object_ptr 
     2825POA_gsdlInterface::corbaiface::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj) 
     2826{ 
     2827  return new ::gsdlInterface::corbaiface_stub_clp (poa, obj); 
     2828} 
     2829 
     2830bool 
     2831POA_gsdlInterface::corbaiface::dispatch (CORBA::StaticServerRequest_ptr __req) 
     2832{ 
     2833  #ifdef HAVE_EXCEPTIONS 
     2834  try { 
     2835  #endif 
     2836    switch (mico_string_hash (__req->op_name(), 17)) { 
     2837    case 0: 
     2838      if( strcmp( __req->op_name(), "collectionList" ) == 0 ) { 
     2839        ::gsdlInterface::corbatext_tarray _par_collist; 
     2840        CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist ); 
     2841        ::gsdlInterface::corbaComError _par_error; 
     2842        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2843 
     2844        __req->add_inout_arg( &_sa_collist ); 
     2845        __req->add_inout_arg( &_sa_error ); 
     2846 
     2847        if( !__req->read_args() ) 
     2848          return true; 
     2849 
     2850        collectionList( _par_collist, _par_error ); 
     2851        __req->write_results(); 
     2852        return true; 
     2853      } 
     2854      break; 
     2855    case 3: 
     2856      if( strcmp( __req->op_name(), "ping" ) == 0 ) { 
     2857        ::gsdlInterface::corbatext_t _par_collection; 
     2858        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2859        CORBA::Boolean _par_wasSuccess; 
     2860        CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess ); 
     2861        ::gsdlInterface::corbaComError _par_error; 
     2862        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2863 
     2864        __req->add_in_arg( &_sa_collection ); 
     2865        __req->add_inout_arg( &_sa_wasSuccess ); 
     2866        __req->add_inout_arg( &_sa_error ); 
     2867 
     2868        if( !__req->read_args() ) 
     2869          return true; 
     2870 
     2871        ping( _par_collection, _par_wasSuccess, _par_error ); 
     2872        __req->write_results(); 
     2873        return true; 
     2874      } 
     2875      break; 
     2876    case 7: 
     2877      if( strcmp( __req->op_name(), "filter" ) == 0 ) { 
     2878        ::gsdlInterface::corbatext_t _par_collection; 
     2879        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2880        ::gsdlInterface::corbaFilterRequest _par_request; 
     2881        CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request ); 
     2882        ::gsdlInterface::corbaFilterResponse _par_response; 
     2883        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response ); 
     2884        ::gsdlInterface::corbaComError _par_error; 
     2885        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2886 
     2887        __req->add_in_arg( &_sa_collection ); 
     2888        __req->add_in_arg( &_sa_request ); 
     2889        __req->add_inout_arg( &_sa_response ); 
     2890        __req->add_inout_arg( &_sa_error ); 
     2891 
     2892        if( !__req->read_args() ) 
     2893          return true; 
     2894 
     2895        filter( _par_collection, _par_request, _par_response, _par_error ); 
     2896        __req->write_results(); 
     2897        return true; 
     2898      } 
     2899      break; 
     2900    case 8: 
     2901      if( strcmp( __req->op_name(), "getRssItems" ) == 0 ) { 
     2902        ::gsdlInterface::corbatext_t _par_collection; 
     2903        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2904        ::gsdlInterface::corbatext_t _par_gsdlhome; 
     2905        CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome ); 
     2906        ::gsdlInterface::corbatext_t _par_rss_items; 
     2907        CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items ); 
     2908        ::gsdlInterface::corbaComError _par_error; 
     2909        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2910 
     2911        __req->add_in_arg( &_sa_collection ); 
     2912        __req->add_in_arg( &_sa_gsdlhome ); 
     2913        __req->add_inout_arg( &_sa_rss_items ); 
     2914        __req->add_inout_arg( &_sa_error ); 
     2915 
     2916        if( !__req->read_args() ) 
     2917          return true; 
     2918 
     2919        getRssItems( _par_collection, _par_gsdlhome, _par_rss_items, _par_error ); 
     2920        __req->write_results(); 
     2921        return true; 
     2922      } 
     2923      break; 
     2924    case 9: 
     2925      if( strcmp( __req->op_name(), "getFilterOptions" ) == 0 ) { 
     2926        ::gsdlInterface::corbatext_t _par_collection; 
     2927        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2928        ::gsdlInterface::corbatext_t _par_option; 
     2929        CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option ); 
     2930        ::gsdlInterface::corbaFilterOptionsResponse _par_response; 
     2931        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response ); 
     2932        ::gsdlInterface::corbaComError _par_error; 
     2933        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2934 
     2935        __req->add_in_arg( &_sa_collection ); 
     2936        __req->add_in_arg( &_sa_option ); 
     2937        __req->add_inout_arg( &_sa_response ); 
     2938        __req->add_inout_arg( &_sa_error ); 
     2939 
     2940        if( !__req->read_args() ) 
     2941          return true; 
     2942 
     2943        getFilterOptions( _par_collection, _par_option, _par_response, _par_error ); 
     2944        __req->write_results(); 
     2945        return true; 
     2946      } 
     2947      break; 
     2948    case 10: 
     2949      if( strcmp( __req->op_name(), "getCollectInfo" ) == 0 ) { 
     2950        ::gsdlInterface::corbatext_t _par_collection; 
     2951        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2952        ::gsdlInterface::corbaColInfoResponse _par_response; 
     2953        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response ); 
     2954        ::gsdlInterface::corbaComError _par_error; 
     2955        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2956 
     2957        __req->add_in_arg( &_sa_collection ); 
     2958        __req->add_inout_arg( &_sa_response ); 
     2959        __req->add_inout_arg( &_sa_error ); 
     2960 
     2961        if( !__req->read_args() ) 
     2962          return true; 
     2963 
     2964        getCollectInfo( _par_collection, _par_response, _par_error ); 
     2965        __req->write_results(); 
     2966        return true; 
     2967      } 
     2968      break; 
     2969    case 11: 
     2970      if( strcmp( __req->op_name(), "initialise" ) == 0 ) { 
     2971        ::gsdlInterface::corbaComError _par_error; 
     2972        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2973 
     2974        CORBA::Boolean _res; 
     2975        CORBA::StaticAny __res( CORBA::_stc_boolean, &_res ); 
     2976        __req->add_inout_arg( &_sa_error ); 
     2977        __req->set_result( &__res ); 
     2978 
     2979        if( !__req->read_args() ) 
     2980          return true; 
     2981 
     2982        _res = initialise( _par_error ); 
     2983        __req->write_results(); 
     2984        return true; 
     2985      } 
     2986      if( strcmp( __req->op_name(), "getFilterInfo" ) == 0 ) { 
     2987        ::gsdlInterface::corbatext_t _par_collection; 
     2988        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     2989        ::gsdlInterface::corbatext_tarray _par_filterNames; 
     2990        CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames ); 
     2991        ::gsdlInterface::corbaComError _par_error; 
     2992        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     2993 
     2994        __req->add_in_arg( &_sa_collection ); 
     2995        __req->add_inout_arg( &_sa_filterNames ); 
     2996        __req->add_inout_arg( &_sa_error ); 
     2997 
     2998        if( !__req->read_args() ) 
     2999          return true; 
     3000 
     3001        getFilterInfo( _par_collection, _par_filterNames, _par_error ); 
     3002        __req->write_results(); 
     3003        return true; 
     3004      } 
     3005      break; 
     3006    case 12: 
     3007      if( strcmp( __req->op_name(), "hasCollection" ) == 0 ) { 
     3008        ::gsdlInterface::corbatext_t _par_corbaCollection; 
     3009        CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection ); 
     3010        CORBA::Boolean _par_has; 
     3011        CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has ); 
     3012        ::gsdlInterface::corbaComError _par_error; 
     3013        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     3014 
     3015        __req->add_in_arg( &_sa_corbaCollection ); 
     3016        __req->add_inout_arg( &_sa_has ); 
     3017        __req->add_inout_arg( &_sa_error ); 
     3018 
     3019        if( !__req->read_args() ) 
     3020          return true; 
     3021 
     3022        hasCollection( _par_corbaCollection, _par_has, _par_error ); 
     3023        __req->write_results(); 
     3024        return true; 
     3025      } 
     3026      break; 
     3027    case 13: 
     3028      if( strcmp( __req->op_name(), "configure" ) == 0 ) { 
     3029        ::gsdlInterface::corbatext_t _par_key; 
     3030        CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key ); 
     3031        ::gsdlInterface::corbatext_tarray _par_cfgline; 
     3032        CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline ); 
     3033        ::gsdlInterface::corbaComError _par_error; 
     3034        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     3035 
     3036        __req->add_in_arg( &_sa_key ); 
     3037        __req->add_in_arg( &_sa_cfgline ); 
     3038        __req->add_inout_arg( &_sa_error ); 
     3039 
     3040        if( !__req->read_args() ) 
     3041          return true; 
     3042 
     3043        configure( _par_key, _par_cfgline, _par_error ); 
     3044        __req->write_results(); 
     3045        return true; 
     3046      } 
     3047      if( strcmp( __req->op_name(), "getDocument" ) == 0 ) { 
     3048        ::gsdlInterface::corbatext_t _par_collection; 
     3049        CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); 
     3050        ::gsdlInterface::corbaDocRequest _par_request; 
     3051        CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request ); 
     3052        ::gsdlInterface::corbaDocResponse _par_response; 
     3053        CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response ); 
     3054        ::gsdlInterface::corbaComError _par_error; 
     3055        CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); 
     3056 
     3057        __req->add_in_arg( &_sa_collection ); 
     3058        __req->add_inout_arg( &_sa_request ); 
     3059        __req->add_inout_arg( &_sa_response ); 
     3060        __req->add_inout_arg( &_sa_error ); 
     3061 
     3062        if( !__req->read_args() ) 
     3063          return true; 
     3064 
     3065        getDocument( _par_collection, _par_request, _par_response, _par_error ); 
     3066        __req->write_results(); 
     3067        return true; 
     3068      } 
     3069      break; 
     3070    } 
     3071  #ifdef HAVE_EXCEPTIONS 
     3072  } catch( CORBA::SystemException_catch &_ex ) { 
     3073    __req->set_exception( _ex->_clone() ); 
     3074    __req->write_results(); 
     3075    return true; 
     3076  } catch( ... ) { 
     3077    CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE); 
     3078    __req->set_exception (_ex->_clone()); 
     3079    __req->write_results (); 
     3080    return true; 
     3081  } 
     3082  #endif 
     3083 
     3084  return false; 
     3085} 
     3086 
     3087void 
     3088POA_gsdlInterface::corbaiface::invoke (CORBA::StaticServerRequest_ptr __req) 
     3089{ 
     3090  if (dispatch (__req)) { 
     3091      return; 
     3092  } 
     3093 
     3094  CORBA::Exception * ex =  
     3095    new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO); 
     3096  __req->set_exception (ex); 
     3097  __req->write_results(); 
     3098} 
     3099 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaproto.h

    r24959 r25231  
    3232#include "recptproto.h" 
    3333#include "corbaiface.h" 
     34 
     35 
    3436using namespace gsdlInterface; 
    3537 
     
    4042  collectservermapclass cservers; 
    4143  corbaiface_var        client; 
    42   CORBA::ORB_var        orb; 
    43   CORBA::BOA_var        boa; 
     44  //CORBA::ORB_var        orb; 
     45  //CORBA::BOA_var        boa; 
    4446  CORBA::Object_var     obj; 
    4547  text_t gsdlhome; 
  • main/trunk/greenstone2/runtime-src/src/corba/corbaproto.mpp

    r24961 r25231  
    2626 *********************************************************************/ 
    2727 
    28 #include <iostream.h> 
    29 #include <fstream.h> 
     28#define USE_POA 
     29 
     30#include <iostream> 
     31#include <fstream> 
    3032 
    3133#include "fileutil.h" 
     
    6365      here ++; 
    6466    } 
    65   //  cout << "Options " << i << endl; 
     67  //  std::cout << "Options " << i << std::endl; 
    6668} 
    6769 
     
    190192        } 
    191193 
    192       cout << "Parent " << mi << " " << (int) &mhere->second << " " << (int) mhere->second.parent << endl; 
     194      std::cout << "Parent " << mi << " " << (off_t) &mhere->second << " " << (off_t) mhere->second.parent << std::endl; 
    193195 
    194196      mhere ++; 
     
    308310 
    309311  CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" ); 
    310   CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" ); 
     312 
     313#if defined(USE_POA) 
     314    CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA"); 
     315    PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj); 
     316    poa->the_POAManager()->activate(); 
     317#else 
     318    CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" ); 
     319#endif 
    311320 
    312321  char objid_filename[256]; 
     
    344353  // DB // Try this out!! // **** 
    345354  CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" ); 
    346   CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" ); 
     355 
     356#if defined(USE_POA) 
     357    CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA"); 
     358    PortableServer::POA_var poa = PortableServer::POA::_narrow (poaobj); 
     359 
     360    poa->the_POAManager()->activate(); 
     361#else 
     362    CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" ); 
     363#endif 
    347364 
    348365  /*  char* site_name_chars = site_name.getcstr(); 
     
    375392  // created 
    376393 
    377   // cout << "Corbaproto::Configure" << endl; 
     394  // std::cout << "Corbaproto::Configure" << std::endl; 
    378395  corbatext_t      corbaKey; 
    379396  corbatext_tarray corbaCfgline; 
     
    403420// this init will configure and init each of the collection servers 
    404421bool corbaproto::init (comerror_t &err, ostream &logout) { 
    405 //  cout << "Corbaproto::Init" << endl; 
     422//  std::cout << "Corbaproto::Init" << std::endl; 
    406423  gsdlInterface::corbaComError error = corbaNoError; 
    407424 
     
    426443      text_t format_line = format_here->second; 
    427444 
    428       // cout << "*** format line = " << format_line << endl; // **** 
     445      // std::cout << "*** format line = " << format_line << std::endl; // **** 
    429446 
    430447      text_t::iterator fl_begin = format_line.begin(); 
     
    494511                     ostream &/*logout*/) { 
    495512 
    496   // cout << "Corbaproto::Collection list" << endl; 
     513  // std::cout << "Corbaproto::Collection list" << std::endl; 
    497514 
    498515  corbatext_tarray corba_collist; 
     
    516533void corbaproto::has_collection (const text_t &collection, bool &hascollection,  
    517534                comerror_t &err, ostream &/*logout*/) { 
    518   // cout << "Corbaproto::Has collection" << endl; 
     535  // std::cout << "Corbaproto::Has collection" << std::endl; 
    519536 
    520537  corbatext_t     corbaCollection; 
     
    539556void corbaproto::ping (const text_t &collection, bool &wassuccess,  
    540557              comerror_t &err, ostream &/*logout*/) { 
    541   // cout << "Corbaproto::Ping" << endl; 
     558  // std::cout << "Corbaproto::Ping" << std::endl; 
    542559 
    543560  corbatext_t corbaCollect; 
     
    558575  wassuccess = (success != 0); 
    559576  err = (comerror_t) corbaError;   
    560   cout << "Corbaproto::Ping" << err << endl; 
     577  std::cout << "Corbaproto::Ping" << err << std::endl; 
    561578} 
    562579 
     
    565582                 ColInfoResponse_t &collectinfo, 
    566583                 comerror_t &err, ostream &logout) { 
    567   //  cout << "Corbaproto::Collectinfo" << endl; 
     584  //  std::cout << "Corbaproto::Collectinfo" << std::endl; 
    568585 
    569586  corbatext_t          corbaCollection; 
     
    591608  collectinfo.numWords  = corbaCollectInfo.numWords; 
    592609  collectinfo.numBytes  = corbaCollectInfo.numBytes; 
    593   corbatext_corbaMapToMap(corbaCollectInfo.collectionMeta, collectinfo.collectionmeta); 
     610  corbatext_corbaColmetamapToColmetamap(corbaCollectInfo.collectionMeta, collectinfo.collectionmeta); 
    594611  corbatext_corbaMapToMap(corbaCollectInfo.format, collectinfo.format); 
    595612  corbatext_corbaMapToMap(corbaCollectInfo.building, collectinfo.building); 
     
    598615  corbaconv_text_t::setCorbatext(collectinfo.receptionist,corbaCollectInfo.receptionist); 
    599616 
     617  // Member variables in comtools mirrored in corbaiface (and corbaproto) on 14/03/2012. 
     618  // shortInfo (previously mistyped as "shoftInfo" in corbaiface.idl) has 3 simple fields 
     619  corbaconv_text_t::setCorbatext(collectinfo.shortInfo.name, corbaCollectInfo.shortInfo.name); 
     620  corbaconv_text_t::setCorbatext(collectinfo.shortInfo.host, corbaCollectInfo.shortInfo.host); 
     621  collectinfo.shortInfo.port = corbaCollectInfo.shortInfo.response; 
     622   
     623  collectinfo.isSegmented = corbaCollectInfo.isSegmented; 
     624  collectinfo.isCollectGroup = corbaCollectInfo.isCollectGroup; 
     625 
     626  collectinfo.numSections = corbaCollectInfo.numSections; 
     627  collectinfo.ccsOptions = corbaCollectInfo.ccsOptions; 
     628  collectinfo.stemIndexes = corbaCollectInfo.stemIndexes; 
     629 
     630  corbatext_corbaColmetamapToColmetamap(corbaCollectInfo.collection_macros, collectinfo.collection_macros); 
     631 
     632  corbaconv_text_t::setCorbatext(collectinfo.buildType,corbaCollectInfo.buildType); 
     633  corbaconv_text_t::setCorbatext(collectinfo.infodbType,corbaCollectInfo.infodbType); 
     634  corbaconv_text_t::setCorbatext(collectinfo.authenticate,corbaCollectInfo.authenticate); 
     635  corbaconv_text_t::setCorbatext(collectinfo.auth_group,corbaCollectInfo.auth_group); 
     636  corbaconv_text_t::setCorbatext(collectinfo.earliestDatestamp,corbaCollectInfo.earliestDatestamp); 
     637 
     638  corbatext_corbaMapToMap(corbaCollectInfo.public_documents, collectinfo.public_documents); 
     639  corbatext_corbaMapToMap(corbaCollectInfo.private_documents, collectinfo.private_documents); 
     640  corbatext_corbaMapToMap(corbaCollectInfo.dynamic_classifiers, collectinfo.dynamic_classifiers); 
     641 
     642 
    600643  cache_missing_icons(collectinfo.format,collectinfo.httpdomain, 
    601644              collectinfo.httpprefix); 
     
    608651                InfoFiltersResponse_t &response, 
    609652                comerror_t &err, ostream &logout) { 
    610   //  cout << "Corbaproto::Filterinfo" << endl; 
     653  //  std::cout << "Corbaproto::Filterinfo" << std::endl; 
    611654 
    612655  corbatext_t corbaCollection; 
     
    634677                   InfoFilterOptionsResponse_t &response,  
    635678                   comerror_t &err, ostream &logout) { 
    636   //  cout << "Corbaproto::Filteroptions" << endl; 
     679  //  std::cout << "Corbaproto::Filteroptions" << std::endl; 
    637680 
    638681  corbatext_t corbaCollection; 
     
    688731  corbaconv_text_t::getCorbatext(collection,corbaCollection); 
    689732  corbaconv_text_t::getCorbatext(gsdlhome,corbaGsdlHome); 
    690   corbaconv_text_t::getCorbatext(rss_items,corbaRssItems); 
    691  
    692   // get the corba client reference 
    693   // corbaiface_var lclient = this->getCorbaClient(); // **** 
    694   corbaiface_var lclient = client; 
    695  
    696   // execute the corba transaction 
    697   lclient->get_rss_items (corbaCollection, corbaGsdlHome, corbaRssItems, corbaError); 
     733 
     734  // get the corba client reference 
     735  // corbaiface_var lclient = this->getCorbaClient(); // **** 
     736  corbaiface_var lclient = client; 
     737 
     738  // execute the corba transaction 
     739  lclient->getRssItems (corbaCollection, corbaGsdlHome, corbaRssItems, corbaError); 
     740 
     741  err =  (comerror_t) corbaError; 
    698742 
    699743  // convert the response back to normal form 
    700   rss_items = corbaRssItems; 
     744  corbaconv_text_t::setCorbatext(rss_items,corbaRssItems); 
    701745} 
    702746 
     
    705749              FilterResponse_t &response, 
    706750              comerror_t &err, ostream &logout) { 
    707   //  cout << "Corbaproto::Filter" << endl; 
     751  //  std::cout << "Corbaproto::Filter" << std::endl; 
    708752 
    709753  corbaFilterRequest corbaRequest; 
     
    742786 
    743787  err = (comerror_t) corbaError; 
    744   //  cout << "Corbaproto::Filter" << endl; 
     788  //  std::cout << "Corbaproto::Filter" << std::endl; 
    745789} 
    746790 
     
    750794                   DocumentResponse_t &response, 
    751795                   comerror_t &err, ostream &logout) { 
    752   //  cout << "Corbaproto::Get Document" << endl; 
     796  //  std::cout << "Corbaproto::Get Document" << std::endl; 
    753797 
    754798  corbatext_t      corbaCollect; 
  • main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.h

    r15463 r25231  
     1#include "comtypes.h" 
     2 
    13void corbatext_fillChar(corbatext_t *t, char *text); 
    2 void corbatext_usvector(corbatext_t t, vector<unsigned short>& us); 
     4void corbatext_usvector(corbatext_t t, std::vector<unsigned short>& us); 
    35char *corbatext_string(corbatext_t t); 
    46#ifdef TEXT_T_H 
     
    1214int corbatext_corbatext(text_t t, corbatext_t_var ct); 
    1315#endif 
     16#ifdef COMTYPES_H 
     17void corbatext_colmetamapToCorbaColmetamap(collectionmeta_map cm, corbatext_tcollectionmeta_map *ccm); 
     18void corbatext_corbaColmetamapToColmetamap(corbatext_tcollectionmeta_map ccm, collectionmeta_map &cm); 
     19#endif 
  • main/trunk/greenstone2/runtime-src/src/corba/corbatext_t.mpp

    r15463 r25231  
    8585  ct->encoding = 0; 
    8686  cout << "C" << endl; 
     87 
     88  return 0; 
    8789} 
    8890 
     
    178180} 
    179181 
     182 
     183// map of metanames to array(lang, value). So each metaname[i] maps to array (lang, value). 
     184// Note that corbacollectionmeta_map is an array of pairs 
     185// each pair consists of (string, map) 
     186void corbatext_colmetamapToCorbaColmetamap(collectionmeta_map cm, corbatext_tcollectionmeta_map *ccm) 
     187{ 
     188  collectionmeta_map::iterator here = cm.begin(); 
     189  collectionmeta_map::iterator end  = cm.end(); 
     190  unsigned int i = 0; 
     191 
     192  while (here != end) 
     193    { 
     194      ccm->length(i+1); // increase size of array of (name, tuples) pairs by 1 each time 
     195 
     196      // fill in the metaname field 
     197      // metaname is of type text_t, get the corbatext value for the text_t key 
     198      (*ccm)[i].name = *corbatext_corbatext((*here).first); // metaname is of type text_t 
     199 
     200      // fill in the tuples field 
     201      corbatext_mapToCorbaMap((*here).second, &((*ccm)[i].tuples)); 
     202 
     203      here ++; 
     204      i ++; 
     205    } 
     206 
     207} 
     208 
     209void corbatext_corbaColmetamapToColmetamap(corbatext_tcollectionmeta_map ccm, collectionmeta_map &cm) 
     210{ 
     211  unsigned int i; 
     212 
     213  for (i = 0; i < ccm.length(); i ++)  
     214    { 
     215    // ccm is an array 
     216    // where each element is a pair of (name, tuples) 
     217 
     218    // 1. get the (corba_text_t) name and convert it to text_t 
     219    text_t* meta_name = new corbaconv_text_t(ccm[i].name); 
     220 
     221    corbatext_tmap corbameta_tuples = ccm[i].tuples; 
     222 
     223    text_tmap *tuples_map = new text_tmap(); 
     224    corbatext_corbaMapToMap(ccm[i].tuples, *tuples_map); 
     225 
     226 
     227    cm.insert(make_pair(*meta_name, 
     228                *tuples_map));           
     229    } 
     230} 
     231