Changeset 2126


Ignore:
Timestamp:
2001-03-07T16:09:50+13:00 (23 years ago)
Author:
say1
Message:

corba updates

Location:
trunk/gsdl
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsdl/lib/Makefile.in

    r2113 r2126  
    7777  corbaiface.mpp    corbatext_t.mpp  corbaconv_text_t.mpp
    7878CORBAOBJECTS = \
    79   corbaiface.o      corbatext_t.o    corbaconv_text_t.o
     79  corbaiface.o      corbatext_t.o    corbaconv_text_t.o  corbaiface_skel.o
    8080else
    8181CORBAHEADERS =
    … …  
    104104
    105105corbaiface.mpp: corbaiface.idl
    106     idl --c++-suffix=mpp $?
     106    idl --boa --no-poa --c++-skel --c++-suffix=mpp $?
    107107
    108108GSDLLIBOBJECTS = $(OBJECTS)

  • trunk/gsdl/lib/corbaiface.h

    r2113 r2126  
    524524};
    525525
    526 #ifndef MICO_CONF_NO_POA
    527 
    528 class corbaiface_stub_clp :
    529   virtual public corbaiface_stub,
    530   virtual public PortableServer::StubBase
    531 {
    532   public:
    533     corbaiface_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    534     virtual ~corbaiface_stub_clp ();
    535     CORBA::Boolean initialise( corbaComError& error );
    536     void configure( const corbatext_t& key, const corbatext_tarray& cfgline, corbaComError& error );
    537     void collectionList( corbatext_tarray& collist, corbaComError& error );
    538     void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error );
    539     CORBA::Boolean ping( const corbatext_t& collection, corbaComError& error );
    540     void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error );
    541     void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error );
    542     void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error );
    543     void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error );
    544     void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error );
    545 
    546   protected:
    547     corbaiface_stub_clp ();
    548   private:
    549     void operator=( const corbaiface_stub_clp & );
    550 };
    551 
    552 #endif // MICO_CONF_NO_POA
    553 
    554 #endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface)
    555 
    556 #ifndef MICO_NO_TOPLEVEL_MODULES
    557 
    558 } MICO_NAMESPACE_END_DECL
    559 #endif
    560 
    561 
    562 
    563 #ifndef MICO_CONF_NO_POA
    564 
    565 #ifndef MICO_NO_TOPLEVEL_MODULES
    566 MICO_NAMESPACE_DECL POA_gsdlInterface {
    567 #endif
    568 
    569 #if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_POA_gsdlInterface)
    570 
    571 
    572 class corbaiface : virtual public PortableServer::StaticImplementation
    573 {
    574   public:
    575     virtual ~corbaiface ();
    576     gsdlInterface::corbaiface_ptr _this ();
    577     bool dispatch (CORBA::StaticServerRequest_ptr);
    578     virtual void invoke (CORBA::StaticServerRequest_ptr);
    579     virtual CORBA::Boolean _is_a (const char *);
    580     virtual CORBA::InterfaceDef_ptr _get_interface ();
    581     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
    582 
    583     virtual void * _narrow_helper (const char *);
    584     static corbaiface * _narrow (PortableServer::Servant);
    585     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
    586 
    587     virtual CORBA::Boolean initialise( gsdlInterface::corbaComError& error ) = 0;
    588     virtual void configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error ) = 0;
    589     virtual void collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error ) = 0;
    590     virtual void hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error ) = 0;
    591     virtual CORBA::Boolean ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error ) = 0;
    592     virtual void getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error ) = 0;
    593     virtual void getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error ) = 0;
    594     virtual void getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error ) = 0;
    595     virtual void getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error ) = 0;
    596     virtual void filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error ) = 0;
    597 
    598   protected:
    599     corbaiface () {};
    600 
    601   private:
    602     corbaiface (const corbaiface &);
    603     void operator= (const corbaiface &);
    604 };
    605 
    606 #ifdef HAVE_NAMESPACE
    607 
    608 template<class T>
    609 class corbaiface_tie :
    610   virtual public POA_Tie_Base<T>,
     526class corbaiface_skel :
     527  virtual public StaticMethodDispatcher,
    611528  virtual public corbaiface
    612529{
    613530  public:
    614     corbaiface_tie (T &t)
    615       : POA_Tie_Base<T> (&t, PortableServer::POA::_nil(), FALSE)
    616     {}
    617     corbaiface_tie (T &t, PortableServer::POA_ptr _poa)
    618       : POA_Tie_Base<T> (&t, _poa, FALSE)
    619     {}
    620     corbaiface_tie (T *t, CORBA::Boolean _rel = TRUE)
    621       : POA_Tie_Base<T> (t, PortableServer::POA::_nil(), _rel)
    622     {}
    623     corbaiface_tie (T *t, PortableServer::POA_ptr _poa, CORBA::Boolean _rel = TRUE)
    624       : POA_Tie_Base<T> (t, _poa, _rel)
    625     {}
    626     virtual ~corbaiface_tie ();
    627 
    628     PortableServer::POA_ptr _default_POA ();
    629 
    630     CORBA::Boolean initialise( gsdlInterface::corbaComError& error );
    631     void configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error );
    632     void collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error );
    633     void hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error );
    634     CORBA::Boolean ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error );
    635     void getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error );
    636     void getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error );
    637     void getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error );
    638     void getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error );
    639     void filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error );
    640 
    641   protected:
    642     corbaiface_tie () {};
    643 
    644   private:
    645     corbaiface_tie (const corbaiface_tie<T> &);
    646     void operator= (const corbaiface_tie<T> &);
    647 };
    648 
    649 template<class T>
    650 corbaiface_tie<T>::~corbaiface_tie ()
    651 {
    652 }
    653 
    654 template<class T>
    655 PortableServer::POA_ptr
    656 corbaiface_tie<T>::_default_POA ()
    657 {
    658   if (!CORBA::is_nil (POA_Tie_Base<T>::poa)) {
    659     return PortableServer::POA::_duplicate (POA_Tie_Base<T>::poa);
    660   }
    661   typedef PortableServer::ServantBase _VCHACK__PortableServer__ServantBase;
    662   return _VCHACK__PortableServer__ServantBase::_default_POA ();
    663 }
    664 
    665 template<class T>
    666 CORBA::Boolean
    667 corbaiface_tie<T>::initialise (gsdlInterface::corbaComError& error)
    668 {
    669   return POA_Tie_Base<T>::ptr->initialise (error);
    670 }
    671 
    672 template<class T>
    673 void
    674 corbaiface_tie<T>::configure (const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error)
    675 {
    676   POA_Tie_Base<T>::ptr->configure (key, cfgline, error);
    677 }
    678 
    679 template<class T>
    680 void
    681 corbaiface_tie<T>::collectionList (gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error)
    682 {
    683   POA_Tie_Base<T>::ptr->collectionList (collist, error);
    684 }
    685 
    686 template<class T>
    687 void
    688 corbaiface_tie<T>::hasCollection (const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error)
    689 {
    690   POA_Tie_Base<T>::ptr->hasCollection (corbaCollection, has, error);
    691 }
    692 
    693 template<class T>
    694 CORBA::Boolean
    695 corbaiface_tie<T>::ping (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error)
    696 {
    697   return POA_Tie_Base<T>::ptr->ping (collection, error);
    698 }
    699 
    700 template<class T>
    701 void
    702 corbaiface_tie<T>::getDocument (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error)
    703 {
    704   POA_Tie_Base<T>::ptr->getDocument (collection, request, response, error);
    705 }
    706 
    707 template<class T>
    708 void
    709 corbaiface_tie<T>::getCollectInfo (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error)
    710 {
    711   POA_Tie_Base<T>::ptr->getCollectInfo (collection, response, error);
    712 }
    713 
    714 template<class T>
    715 void
    716 corbaiface_tie<T>::getFilterInfo (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error)
    717 {
    718   POA_Tie_Base<T>::ptr->getFilterInfo (collection, filterNames, error);
    719 }
    720 
    721 template<class T>
    722 void
    723 corbaiface_tie<T>::getFilterOptions (const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error)
    724 {
    725   POA_Tie_Base<T>::ptr->getFilterOptions (collection, option, response, error);
    726 }
    727 
    728 template<class T>
    729 void
    730 corbaiface_tie<T>::filter (const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error)
    731 {
    732   POA_Tie_Base<T>::ptr->filter (collection, request, response, error);
    733 }
    734 
    735 #endif
    736 
    737 #endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_POA_gsdlInterface)
     531    corbaiface_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
     532    virtual ~corbaiface_skel();
     533    corbaiface_skel( CORBA::Object_ptr obj );
     534    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
     535    corbaiface_ptr _this();
     536
     537};
     538
     539#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_gsdlInterface)
    738540
    739541#ifndef MICO_NO_TOPLEVEL_MODULES
    … …  
    744546
    745547
    746 #ifndef HAVE_NAMESPACE
    747 
    748 template<class T>
    749 class POA_gsdlInterface_corbaiface_tie :
    750   virtual public POA_Tie_Base<T>,
    751   virtual public POA_gsdlInterface::corbaiface
    752 {
    753   public:
    754     POA_gsdlInterface_corbaiface_tie (T &t)
    755       : POA_Tie_Base<T> (&t, PortableServer::POA::_nil(), FALSE)
    756     {}
    757     POA_gsdlInterface_corbaiface_tie (T &t, PortableServer::POA_ptr _poa)
    758       : POA_Tie_Base<T> (&t, _poa, FALSE)
    759     {}
    760     POA_gsdlInterface_corbaiface_tie (T *t, CORBA::Boolean _rel = TRUE)
    761       : POA_Tie_Base<T> (t, PortableServer::POA::_nil(), _rel)
    762     {}
    763     POA_gsdlInterface_corbaiface_tie (T *t, PortableServer::POA_ptr _poa, CORBA::Boolean _rel = TRUE)
    764       : POA_Tie_Base<T> (t, _poa, _rel)
    765     {}
    766     virtual ~POA_gsdlInterface_corbaiface_tie ();
    767 
    768     PortableServer::POA_ptr _default_POA ();
    769 
    770     CORBA::Boolean initialise( gsdlInterface::corbaComError& error );
    771     void configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error );
    772     void collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error );
    773     void hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error );
    774     CORBA::Boolean ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error );
    775     void getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error );
    776     void getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error );
    777     void getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error );
    778     void getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error );
    779     void filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error );
    780 
    781   protected:
    782     POA_gsdlInterface_corbaiface_tie () {};
    783 
    784   private:
    785     POA_gsdlInterface_corbaiface_tie (const POA_gsdlInterface_corbaiface_tie<T> &);
    786     void operator= (const POA_gsdlInterface_corbaiface_tie<T> &);
    787 };
    788 
    789 template<class T>
    790 POA_gsdlInterface_corbaiface_tie<T>::~POA_gsdlInterface_corbaiface_tie ()
    791 {
    792 }
    793 
    794 template<class T>
    795 PortableServer::POA_ptr
    796 POA_gsdlInterface_corbaiface_tie<T>::_default_POA ()
    797 {
    798   if (!CORBA::is_nil (POA_Tie_Base<T>::poa)) {
    799     return PortableServer::POA::_duplicate (POA_Tie_Base<T>::poa);
    800   }
    801   typedef PortableServer::ServantBase _VCHACK__PortableServer__ServantBase;
    802   return _VCHACK__PortableServer__ServantBase::_default_POA ();
    803 }
    804 
    805 template<class T>
    806 CORBA::Boolean
    807 POA_gsdlInterface_corbaiface_tie<T>::initialise (gsdlInterface::corbaComError& error)
    808 {
    809   return POA_Tie_Base<T>::ptr->initialise (error);
    810 }
    811 
    812 template<class T>
    813 void
    814 POA_gsdlInterface_corbaiface_tie<T>::configure (const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error)
    815 {
    816   POA_Tie_Base<T>::ptr->configure (key, cfgline, error);
    817 }
    818 
    819 template<class T>
    820 void
    821 POA_gsdlInterface_corbaiface_tie<T>::collectionList (gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error)
    822 {
    823   POA_Tie_Base<T>::ptr->collectionList (collist, error);
    824 }
    825 
    826 template<class T>
    827 void
    828 POA_gsdlInterface_corbaiface_tie<T>::hasCollection (const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error)
    829 {
    830   POA_Tie_Base<T>::ptr->hasCollection (corbaCollection, has, error);
    831 }
    832 
    833 template<class T>
    834 CORBA::Boolean
    835 POA_gsdlInterface_corbaiface_tie<T>::ping (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error)
    836 {
    837   return POA_Tie_Base<T>::ptr->ping (collection, error);
    838 }
    839 
    840 template<class T>
    841 void
    842 POA_gsdlInterface_corbaiface_tie<T>::getDocument (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error)
    843 {
    844   POA_Tie_Base<T>::ptr->getDocument (collection, request, response, error);
    845 }
    846 
    847 template<class T>
    848 void
    849 POA_gsdlInterface_corbaiface_tie<T>::getCollectInfo (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error)
    850 {
    851   POA_Tie_Base<T>::ptr->getCollectInfo (collection, response, error);
    852 }
    853 
    854 template<class T>
    855 void
    856 POA_gsdlInterface_corbaiface_tie<T>::getFilterInfo (const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error)
    857 {
    858   POA_Tie_Base<T>::ptr->getFilterInfo (collection, filterNames, error);
    859 }
    860 
    861 template<class T>
    862 void
    863 POA_gsdlInterface_corbaiface_tie<T>::getFilterOptions (const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error)
    864 {
    865   POA_Tie_Base<T>::ptr->getFilterOptions (collection, option, response, error);
    866 }
    867 
    868 template<class T>
    869 void
    870 POA_gsdlInterface_corbaiface_tie<T>::filter (const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error)
    871 {
    872   POA_Tie_Base<T>::ptr->filter (collection, request, response, error);
    873 }
    874 
    875 #endif
     548#ifndef MICO_CONF_NO_POA
    876549
    877550#endif // MICO_CONF_NO_POA

  • trunk/gsdl/lib/corbaiface.mpp

    r2113 r2126  
    14341434}
    14351435
    1436 #ifndef MICO_CONF_NO_POA
    1437 
    1438 void *
    1439 POA_gsdlInterface::corbaiface::_narrow_helper (const char * repoid)
    1440 {
    1441   if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
    1442     return (void *) this;
    1443   }
    1444   return NULL;
    1445 }
    1446 
    1447 POA_gsdlInterface::corbaiface *
    1448 POA_gsdlInterface::corbaiface::_narrow (PortableServer::Servant serv)
    1449 {
    1450   void * p;
    1451   if ((p = serv->_narrow_helper ("IDL:gsdlInterface/corbaiface:1.0")) != NULL) {
    1452     serv->_add_ref ();
    1453     return (POA_gsdlInterface::corbaiface *) p;
    1454   }
    1455   return NULL;
    1456 }
    1457 
    1458 gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp ()
    1459 {
    1460 }
    1461 
    1462 gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
    1463   : MICO_SCOPE(PortableServer,StubBase) (poa), MICO_SCOPE(CORBA,Object) (*obj)
    1464 {
    1465 }
    1466 
    1467 gsdlInterface::corbaiface_stub_clp::~corbaiface_stub_clp ()
    1468 {
    1469 }
    1470 
    1471 #endif // MICO_CONF_NO_POA
    1472 
    14731436CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& error )
    14741437{
    … …  
    14881451}
    14891452
    1490 
    1491 #ifndef MICO_CONF_NO_POA
    1492 
    1493 CORBA::Boolean
    1494 gsdlInterface::corbaiface_stub_clp::initialise( gsdlInterface::corbaComError& error )
    1495 {
    1496   PortableServer::Servant _serv = _preinvoke ();
    1497   if (_serv) {
    1498     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1499     if (_myserv) {
    1500       CORBA::Boolean __res;
    1501 
    1502       #ifdef HAVE_EXCEPTIONS
    1503       try {
    1504       #endif
    1505         __res = _myserv->initialise(error);
    1506       #ifdef HAVE_EXCEPTIONS
    1507       }
    1508       catch (...) {
    1509         _myserv->_remove_ref();
    1510         _postinvoke();
    1511         throw;
    1512       }
    1513       #endif
    1514 
    1515       _myserv->_remove_ref();
    1516       _postinvoke ();
    1517       return __res;
    1518     }
    1519     _postinvoke ();
    1520   }
    1521 
    1522   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1523   return _VCHACK__classname::initialise(error);
    1524 }
    1525 
    1526 #endif // MICO_CONF_NO_POA
    15271453
    15281454void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error )
    … …  
    15431469
    15441470
    1545 #ifndef MICO_CONF_NO_POA
    1546 
    1547 void
    1548 gsdlInterface::corbaiface_stub_clp::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error )
    1549 {
    1550   PortableServer::Servant _serv = _preinvoke ();
    1551   if (_serv) {
    1552     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1553     if (_myserv) {
    1554       #ifdef HAVE_EXCEPTIONS
    1555       try {
    1556       #endif
    1557         _myserv->configure(key, cfgline, error);
    1558       #ifdef HAVE_EXCEPTIONS
    1559       }
    1560       catch (...) {
    1561         _myserv->_remove_ref();
    1562         _postinvoke();
    1563         throw;
    1564       }
    1565       #endif
    1566 
    1567       _myserv->_remove_ref();
    1568       _postinvoke ();
    1569       return;
    1570     }
    1571     _postinvoke ();
    1572   }
    1573 
    1574   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1575   _VCHACK__classname::configure(key, cfgline, error);
    1576 }
    1577 
    1578 #endif // MICO_CONF_NO_POA
    1579 
    15801471void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error )
    15811472{
    … …  
    15921483}
    15931484
    1594 
    1595 #ifndef MICO_CONF_NO_POA
    1596 
    1597 void
    1598 gsdlInterface::corbaiface_stub_clp::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error )
    1599 {
    1600   PortableServer::Servant _serv = _preinvoke ();
    1601   if (_serv) {
    1602     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1603     if (_myserv) {
    1604       #ifdef HAVE_EXCEPTIONS
    1605       try {
    1606       #endif
    1607         _myserv->collectionList(collist, error);
    1608       #ifdef HAVE_EXCEPTIONS
    1609       }
    1610       catch (...) {
    1611         _myserv->_remove_ref();
    1612         _postinvoke();
    1613         throw;
    1614       }
    1615       #endif
    1616 
    1617       _myserv->_remove_ref();
    1618       _postinvoke ();
    1619       return;
    1620     }
    1621     _postinvoke ();
    1622   }
    1623 
    1624   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1625   _VCHACK__classname::collectionList(collist, error);
    1626 }
    1627 
    1628 #endif // MICO_CONF_NO_POA
    16291485
    16301486void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
    … …  
    16451501
    16461502
    1647 #ifndef MICO_CONF_NO_POA
    1648 
    1649 void
    1650 gsdlInterface::corbaiface_stub_clp::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
    1651 {
    1652   PortableServer::Servant _serv = _preinvoke ();
    1653   if (_serv) {
    1654     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1655     if (_myserv) {
    1656       #ifdef HAVE_EXCEPTIONS
    1657       try {
    1658       #endif
    1659         _myserv->hasCollection(corbaCollection, has, error);
    1660       #ifdef HAVE_EXCEPTIONS
    1661       }
    1662       catch (...) {
    1663         _myserv->_remove_ref();
    1664         _postinvoke();
    1665         throw;
    1666       }
    1667       #endif
    1668 
    1669       _myserv->_remove_ref();
    1670       _postinvoke ();
    1671       return;
    1672     }
    1673     _postinvoke ();
    1674   }
    1675 
    1676   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1677   _VCHACK__classname::hasCollection(corbaCollection, has, error);
    1678 }
    1679 
    1680 #endif // MICO_CONF_NO_POA
    1681 
    16821503CORBA::Boolean gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error )
    16831504{
    … …  
    16991520}
    17001521
    1701 
    1702 #ifndef MICO_CONF_NO_POA
    1703 
    1704 CORBA::Boolean
    1705 gsdlInterface::corbaiface_stub_clp::ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error )
    1706 {
    1707   PortableServer::Servant _serv = _preinvoke ();
    1708   if (_serv) {
    1709     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1710     if (_myserv) {
    1711       CORBA::Boolean __res;
    1712 
    1713       #ifdef HAVE_EXCEPTIONS
    1714       try {
    1715       #endif
    1716         __res = _myserv->ping(collection, error);
    1717       #ifdef HAVE_EXCEPTIONS
    1718       }
    1719       catch (...) {
    1720         _myserv->_remove_ref();
    1721         _postinvoke();
    1722         throw;
    1723       }
    1724       #endif
    1725 
    1726       _myserv->_remove_ref();
    1727       _postinvoke ();
    1728       return __res;
    1729     }
    1730     _postinvoke ();
    1731   }
    1732 
    1733   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1734   return _VCHACK__classname::ping(collection, error);
    1735 }
    1736 
    1737 #endif // MICO_CONF_NO_POA
    17381522
    17391523void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
    … …  
    17561540
    17571541
    1758 #ifndef MICO_CONF_NO_POA
    1759 
    1760 void
    1761 gsdlInterface::corbaiface_stub_clp::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
    1762 {
    1763   PortableServer::Servant _serv = _preinvoke ();
    1764   if (_serv) {
    1765     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1766     if (_myserv) {
    1767       #ifdef HAVE_EXCEPTIONS
    1768       try {
    1769       #endif
    1770         _myserv->getDocument(collection, request, response, error);
    1771       #ifdef HAVE_EXCEPTIONS
    1772       }
    1773       catch (...) {
    1774         _myserv->_remove_ref();
    1775         _postinvoke();
    1776         throw;
    1777       }
    1778       #endif
    1779 
    1780       _myserv->_remove_ref();
    1781       _postinvoke ();
    1782       return;
    1783     }
    1784     _postinvoke ();
    1785   }
    1786 
    1787   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1788   _VCHACK__classname::getDocument(collection, request, response, error);
    1789 }
    1790 
    1791 #endif // MICO_CONF_NO_POA
    1792 
    17931542void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
    17941543{
    … …  
    18081557
    18091558
    1810 #ifndef MICO_CONF_NO_POA
    1811 
    1812 void
    1813 gsdlInterface::corbaiface_stub_clp::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
    1814 {
    1815   PortableServer::Servant _serv = _preinvoke ();
    1816   if (_serv) {
    1817     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1818     if (_myserv) {
    1819       #ifdef HAVE_EXCEPTIONS
    1820       try {
    1821       #endif
    1822         _myserv->getCollectInfo(collection, response, error);
    1823       #ifdef HAVE_EXCEPTIONS
    1824       }
    1825       catch (...) {
    1826         _myserv->_remove_ref();
    1827         _postinvoke();
    1828         throw;
    1829       }
    1830       #endif
    1831 
    1832       _myserv->_remove_ref();
    1833       _postinvoke ();
    1834       return;
    1835     }
    1836     _postinvoke ();
    1837   }
    1838 
    1839   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1840   _VCHACK__classname::getCollectInfo(collection, response, error);
    1841 }
    1842 
    1843 #endif // MICO_CONF_NO_POA
    1844 
    18451559void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
    18461560{
    … …  
    18591573}
    18601574
    1861 
    1862 #ifndef MICO_CONF_NO_POA
    1863 
    1864 void
    1865 gsdlInterface::corbaiface_stub_clp::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
    1866 {
    1867   PortableServer::Servant _serv = _preinvoke ();
    1868   if (_serv) {
    1869     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1870     if (_myserv) {
    1871       #ifdef HAVE_EXCEPTIONS
    1872       try {
    1873       #endif
    1874         _myserv->getFilterInfo(collection, filterNames, error);
    1875       #ifdef HAVE_EXCEPTIONS
    1876       }
    1877       catch (...) {
    1878         _myserv->_remove_ref();
    1879         _postinvoke();
    1880         throw;
    1881       }
    1882       #endif
    1883 
    1884       _myserv->_remove_ref();
    1885       _postinvoke ();
    1886       return;
    1887     }
    1888     _postinvoke ();
    1889   }
    1890 
    1891   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1892   _VCHACK__classname::getFilterInfo(collection, filterNames, error);
    1893 }
    1894 
    1895 #endif // MICO_CONF_NO_POA
    18961575
    18971576void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
    … …  
    19141593
    19151594
    1916 #ifndef MICO_CONF_NO_POA
    1917 
    1918 void
    1919 gsdlInterface::corbaiface_stub_clp::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
    1920 {
    1921   PortableServer::Servant _serv = _preinvoke ();
    1922   if (_serv) {
    1923     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1924     if (_myserv) {
    1925       #ifdef HAVE_EXCEPTIONS
    1926       try {
    1927       #endif
    1928         _myserv->getFilterOptions(collection, option, response, error);
    1929       #ifdef HAVE_EXCEPTIONS
    1930       }
    1931       catch (...) {
    1932         _myserv->_remove_ref();
    1933         _postinvoke();
    1934         throw;
    1935       }
    1936       #endif
    1937 
    1938       _myserv->_remove_ref();
    1939       _postinvoke ();
    1940       return;
    1941     }
    1942     _postinvoke ();
    1943   }
    1944 
    1945   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    1946   _VCHACK__classname::getFilterOptions(collection, option, response, error);
    1947 }
    1948 
    1949 #endif // MICO_CONF_NO_POA
    1950 
    19511595void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
    19521596{
    … …  
    19671611}
    19681612
    1969 
    1970 #ifndef MICO_CONF_NO_POA
    1971 
    1972 void
    1973 gsdlInterface::corbaiface_stub_clp::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
    1974 {
    1975   PortableServer::Servant _serv = _preinvoke ();
    1976   if (_serv) {
    1977     POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
    1978     if (_myserv) {
    1979       #ifdef HAVE_EXCEPTIONS
    1980       try {
    1981       #endif
    1982         _myserv->filter(collection, request, response, error);
    1983       #ifdef HAVE_EXCEPTIONS
    1984       }
    1985       catch (...) {
    1986         _myserv->_remove_ref();
    1987         _postinvoke();
    1988         throw;
    1989       }
    1990       #endif
    1991 
    1992       _myserv->_remove_ref();
    1993       _postinvoke ();
    1994       return;
    1995     }
    1996     _postinvoke ();
    1997   }
    1998 
    1999   typedef gsdlInterface::corbaiface_stub _VCHACK__classname;
    2000   _VCHACK__classname::filter(collection, request, response, error);
    2001 }
    2002 
    2003 #endif // MICO_CONF_NO_POA
    20041613
    20051614#ifdef HAVE_NAMESPACE
    … …  
    23891998static __tc_init_CORBAIFACE __init_CORBAIFACE;
    23901999
    2391 //--------------------------------------------------------
    2392 //  Implementation of skeletons
    2393 //--------------------------------------------------------
    2394 
    2395 // PortableServer Skeleton Class for interface gsdlInterface::corbaiface
    2396 POA_gsdlInterface::corbaiface::~corbaiface()
    2397 {
    2398 }
    2399 
    2400 gsdlInterface::corbaiface_ptr
    2401 POA_gsdlInterface::corbaiface::_this ()
    2402 {
    2403   CORBA::Object_var obj = MICO_SCOPE(PortableServer,ServantBase::_this) ();
    2404   return gsdlInterface::corbaiface::_narrow (obj);
    2405 }
    2406 
    2407 CORBA::Boolean
    2408 POA_gsdlInterface::corbaiface::_is_a (const char * repoid)
    2409 {
    2410   if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
    2411     return TRUE;
    2412   }
    2413   return FALSE;
    2414 }
    2415 
    2416 CORBA::InterfaceDef_ptr
    2417 POA_gsdlInterface::corbaiface::_get_interface ()
    2418 {
    2419   CORBA::InterfaceDef_ptr ifd = MICO_SCOPE(PortableServer,ServantBase)::_get_interface ("IDL:gsdlInterface/corbaiface:1.0");
    2420 
    2421   if (CORBA::is_nil (ifd)) {
    2422     mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
    2423   }
    2424 
    2425   return ifd;
    2426 }
    2427 
    2428 CORBA::RepositoryId
    2429 POA_gsdlInterface::corbaiface::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
    2430 {
    2431   return CORBA::string_dup ("IDL:gsdlInterface/corbaiface:1.0");
    2432 }
    2433 
    2434 CORBA::Object_ptr
    2435 POA_gsdlInterface::corbaiface::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
    2436 {
    2437   return new gsdlInterface::corbaiface_stub_clp (poa, obj);
    2438 }
    2439 
    2440 bool
    2441 POA_gsdlInterface::corbaiface::dispatch (CORBA::StaticServerRequest_ptr _req)
    2442 {
    2443   #ifdef HAVE_EXCEPTIONS
    2444   try {
    2445   #endif
    2446     switch (mico_string_hash (_req->op_name(), 17)) {
    2447     case 0:
    2448       if( strcmp( _req->op_name(), "collectionList" ) == 0 ) {
    2449         gsdlInterface::corbatext_tarray collist;
    2450         CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
    2451         gsdlInterface::corbaComError error;
    2452         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2453 
    2454         _req->add_inout_arg( &_collist );
    2455         _req->add_inout_arg( &_error );
    2456 
    2457         if( !_req->read_args() )
    2458           return true;
    2459 
    2460         collectionList( collist, error );
    2461         _req->write_results();
    2462         return true;
    2463       }
    2464       break;
    2465     case 3:
    2466       if( strcmp( _req->op_name(), "ping" ) == 0 ) {
    2467         gsdlInterface::corbatext_t collection;
    2468         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2469         gsdlInterface::corbaComError error;
    2470         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2471 
    2472         CORBA::Boolean _res;
    2473         CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
    2474         _req->add_in_arg( &_collection );
    2475         _req->add_inout_arg( &_error );
    2476         _req->set_result( &__res );
    2477 
    2478         if( !_req->read_args() )
    2479           return true;
    2480 
    2481         _res = ping( collection, error );
    2482         _req->write_results();
    2483         return true;
    2484       }
    2485       break;
    2486     case 7:
    2487       if( strcmp( _req->op_name(), "filter" ) == 0 ) {
    2488         gsdlInterface::corbatext_t collection;
    2489         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2490         gsdlInterface::corbaFilterRequest request;
    2491         CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
    2492         gsdlInterface::corbaFilterResponse response;
    2493         CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
    2494         gsdlInterface::corbaComError error;
    2495         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2496 
    2497         _req->add_in_arg( &_collection );
    2498         _req->add_in_arg( &_request );
    2499         _req->add_inout_arg( &_response );
    2500         _req->add_inout_arg( &_error );
    2501 
    2502         if( !_req->read_args() )
    2503           return true;
    2504 
    2505         filter( collection, request, response, error );
    2506         _req->write_results();
    2507         return true;
    2508       }
    2509       break;
    2510     case 9:
    2511       if( strcmp( _req->op_name(), "getFilterOptions" ) == 0 ) {
    2512         gsdlInterface::corbatext_t collection;
    2513         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2514         gsdlInterface::corbatext_t option;
    2515         CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
    2516         gsdlInterface::corbaFilterOptionsResponse response;
    2517         CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
    2518         gsdlInterface::corbaComError error;
    2519         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2520 
    2521         _req->add_in_arg( &_collection );
    2522         _req->add_in_arg( &_option );
    2523         _req->add_inout_arg( &_response );
    2524         _req->add_inout_arg( &_error );
    2525 
    2526         if( !_req->read_args() )
    2527           return true;
    2528 
    2529         getFilterOptions( collection, option, response, error );
    2530         _req->write_results();
    2531         return true;
    2532       }
    2533       break;
    2534     case 10:
    2535       if( strcmp( _req->op_name(), "getCollectInfo" ) == 0 ) {
    2536         gsdlInterface::corbatext_t collection;
    2537         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2538         gsdlInterface::corbaColInfoResponse response;
    2539         CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
    2540         gsdlInterface::corbaComError error;
    2541         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2542 
    2543         _req->add_in_arg( &_collection );
    2544         _req->add_inout_arg( &_response );
    2545         _req->add_inout_arg( &_error );
    2546 
    2547         if( !_req->read_args() )
    2548           return true;
    2549 
    2550         getCollectInfo( collection, response, error );
    2551         _req->write_results();
    2552         return true;
    2553       }
    2554       break;
    2555     case 11:
    2556       if( strcmp( _req->op_name(), "initialise" ) == 0 ) {
    2557         gsdlInterface::corbaComError error;
    2558         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2559 
    2560         CORBA::Boolean _res;
    2561         CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
    2562         _req->add_inout_arg( &_error );
    2563         _req->set_result( &__res );
    2564 
    2565         if( !_req->read_args() )
    2566           return true;
    2567 
    2568         _res = initialise( error );
    2569         _req->write_results();
    2570         return true;
    2571       }
    2572       if( strcmp( _req->op_name(), "getFilterInfo" ) == 0 ) {
    2573         gsdlInterface::corbatext_t collection;
    2574         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2575         gsdlInterface::corbatext_tarray filterNames;
    2576         CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
    2577         gsdlInterface::corbaComError error;
    2578         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2579 
    2580         _req->add_in_arg( &_collection );
    2581         _req->add_inout_arg( &_filterNames );
    2582         _req->add_inout_arg( &_error );
    2583 
    2584         if( !_req->read_args() )
    2585           return true;
    2586 
    2587         getFilterInfo( collection, filterNames, error );
    2588         _req->write_results();
    2589         return true;
    2590       }
    2591       break;
    2592     case 12:
    2593       if( strcmp( _req->op_name(), "hasCollection" ) == 0 ) {
    2594         gsdlInterface::corbatext_t corbaCollection;
    2595         CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
    2596         CORBA::Boolean has;
    2597         CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
    2598         gsdlInterface::corbaComError error;
    2599         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2600 
    2601         _req->add_in_arg( &_corbaCollection );
    2602         _req->add_inout_arg( &_has );
    2603         _req->add_inout_arg( &_error );
    2604 
    2605         if( !_req->read_args() )
    2606           return true;
    2607 
    2608         hasCollection( corbaCollection, has, error );
    2609         _req->write_results();
    2610         return true;
    2611       }
    2612       break;
    2613     case 13:
    2614       if( strcmp( _req->op_name(), "configure" ) == 0 ) {
    2615         gsdlInterface::corbatext_t key;
    2616         CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
    2617         gsdlInterface::corbatext_tarray cfgline;
    2618         CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
    2619         gsdlInterface::corbaComError error;
    2620         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2621 
    2622         _req->add_in_arg( &_key );
    2623         _req->add_in_arg( &_cfgline );
    2624         _req->add_inout_arg( &_error );
    2625 
    2626         if( !_req->read_args() )
    2627           return true;
    2628 
    2629         configure( key, cfgline, error );
    2630         _req->write_results();
    2631         return true;
    2632       }
    2633       if( strcmp( _req->op_name(), "getDocument" ) == 0 ) {
    2634         gsdlInterface::corbatext_t collection;
    2635         CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
    2636         gsdlInterface::corbaDocRequest request;
    2637         CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
    2638         gsdlInterface::corbaDocResponse response;
    2639         CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
    2640         gsdlInterface::corbaComError error;
    2641         CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
    2642 
    2643         _req->add_in_arg( &_collection );
    2644         _req->add_inout_arg( &_request );
    2645         _req->add_inout_arg( &_response );
    2646         _req->add_inout_arg( &_error );
    2647 
    2648         if( !_req->read_args() )
    2649           return true;
    2650 
    2651         getDocument( collection, request, response, error );
    2652         _req->write_results();
    2653         return true;
    2654       }
    2655       break;
    2656     }
    2657   #ifdef HAVE_EXCEPTIONS
    2658   } catch( CORBA::SystemException_catch &_ex ) {
    2659     _req->set_exception( _ex->_clone() );
    2660     _req->write_results();
    2661     return true;
    2662   } catch( ... ) {
    2663     assert( 0 );
    2664     return true;
    2665   }
    2666   #endif
    2667 
    2668   return false;
    2669 }
    2670 
    2671 void
    2672 POA_gsdlInterface::corbaiface::invoke (CORBA::StaticServerRequest_ptr _req)
    2673 {
    2674   if (dispatch (_req)) {
    2675       return;
    2676   }
    2677 
    2678   CORBA::Exception * ex =
    2679     new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
    2680   _req->set_exception (ex);
    2681   _req->write_results();
    2682 }
    2683 

  • trunk/gsdl/src/colservr/Makefile.in

    r1860 r2126  
    118118  corbaServer.mpp
    119119CORBAOBJECTS = \
    120   corbaServer.o
     120  corbaServer.o ../../lib/corbaiface_skel.o
    121121else
    122122CORBAHEADERS =

  • trunk/gsdl/src/colservr/corbaServer.mpp

    r2113 r2126  
    1 // standard headers
     1// Standard headers
    22#include <iostream.h>
    33#include <fstream.h>
    … …  
    6363}
    6464
    65 class corbaServer : virtual public corbaiface_stub
     65class corbaServer : virtual public corbaiface_skel
    6666{
    6767private:
    … …  
    9999    cout << "Constructing set list server" << endl;
    100100    this->protocol = protocol;
    101   }
    102 
    103   CORBA::Boolean initialise()
     101
     102  }
     103 
     104  CORBA::Boolean initialise(corbaComError &err)
    104105  {
    105106      ofstream      logout;
    … …  
    113114    }
    114115
    115   void configure(const corbatext_t &corbaKey, const corbatext_tarray &corbaCfgline)
     116  void configure(const corbatext_t &corbaKey, const corbatext_tarray &corbaCfgline,corbaComError &err)
    116117    {
    117118      text_t        key;
    … …  
    392393  }
    393394
    394   void collectionList(corbatext_tarray &corbalist)
     395  void collectionList(corbatext_tarray &corbalist, corbaComError &error)
    395396  {
    396397    /* stringSeq *reply;
    … …  
    454455
    455456  corbaServer* server = new corbaServer(&protocol, gsdlhome);
     457
     458  cout << "Initialised server" << endl;
     459
    456460  CORBA::String_var ref = orb->object_to_string( server );
    457461

  • trunk/gsdl/src/recpt/Makefile.in

    r2113 r2126  
    308308RECPTLIB_OBJECTS = nullproto.o corbaproto.o \
    309309                   ../../lib/corbatext_t.o ../../lib/corbaconv_text_t.o \
    310            ../../lib/corbaiface.o
     310           ../../lib/corbaiface.o ../../lib/corbaiface_skel.o
    311311ifneq ($(USE_FASTCGI), 1)
    312312RLIBRARY_OBJS = $(COMMONOBJECTS) $(RECPTLIB_OBJECTS) $(COLSERVROBJECTS) \
    … …  
    337337CORBARECPT_OBJS = $(COMMONOBJECTS) $(CORBARECPT_OBJECTS) $(COLSERVROBJECTS) \
    338338    ../../lib/corbaiface.o \
     339    ../../lib/corbaiface_skel.o \
    339340    ../../lib/corbaconv_text_t.o \
    340341    ../../lib/corbatext_t.o \
    … …  
    347348CORBARECPT_OBJS = $(COMMONOBJECTS) $(CORBARECPT_OBJECTS) $(COLSERVROBJECTS) \
    348349    ../../lib/corbaiface.o \
     350    ../../lib/corbaiface_skel.o\
    349351    ../../lib/corbaconv_text_t.o \
    350352    ../../lib/corbatext_t.o \
Note: See TracChangeset for help on using the changeset viewer.