LTP GCOV extension - code coverage report
Current view: directory - gen/cpp/orb/CORBA - CORBAGen.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 911
Code covered: 4.2 % Executed lines: 38

       1                 : 
       2                 : // This file was automatically generated by YaOrb IDL->C++ compiler.
       3                 : // DO NOT EDIT !
       4                 : 
       5                 : #include <stdio.h>
       6                 : #include <yaorb/CORBA.h>
       7                 : #include <yaorb/YAORB.h>
       8                 : #include "CORBAGen.h"
       9                 : 
      10               0 : CORBA::Current::Current()
      11               0 :  : CORBA::Object()
      12                 : {}
      13                 : 
      14               0 : CORBA::Current::~Current()
      15               0 : {}
      16                 : 
      17                 : CORBA::Current_ptr
      18               0 : CORBA::Current::_duplicate(CORBA::Current_ptr obj)
      19                 : {
      20               0 :    if (CORBA::is_nil(obj))
      21                 :    {
      22               0 :       return _nil() ;
      23                 :    }
      24                 :    else
      25                 :    {
      26               0 :       (void) CORBA::Object::_duplicate(obj) ;
      27                 :       return obj ;
      28                 :    }
      29                 : }
      30                 : 
      31                 : CORBA::Current_ptr
      32               0 : CORBA::Current::_narrow(CORBA::Object_ptr obj)
      33                 : {
      34               0 :    if (CORBA::is_nil(obj))
      35                 :    {
      36               0 :       return _nil() ;
      37                 :    }
      38                 :    else
      39                 :    {
      40               0 :       void *that = NULL ;
      41               0 :       if (obj->_isA(& _info, that))
      42                 :       {
      43                 :          CORBA::Current_ptr ret ;
      44               0 :          ret = (CORBA::Current_ptr) that ;
      45               0 :          CORBA::Object::_duplicate(obj) ;
      46               0 :          return ret ;
      47                 :       }
      48                 :       else
      49                 :       {
      50               0 :          return _nil() ;
      51                 :       }
      52                 :    }
      53                 : }
      54                 : 
      55               0 : CORBA::Current_ptr CORBA::Current::_nil(void)
      56                 : {
      57                 :    return NULL ;
      58                 : }
      59                 : 
      60               0 : CORBA::Current_ptr CORBA::Current::_bind(YAORB::CDR* cdrs)
      61                 : {
      62               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
      63                 : }
      64                 : 
      65               0 : const YAORB::ClassInfo* CORBA::Current::_getInfo(void) const
      66                 : {
      67                 :    return & _info ;
      68                 : }
      69                 : 
      70               0 : bool CORBA::Current::_isA(const YAORB::ClassInfo* info, void*& that) const
      71                 : {
      72               0 :    if (_info.isEquiv(info))
      73                 :    {
      74               0 :       that = (void*) (const void*) this ;
      75                 :       return true ;
      76                 :    }
      77                 :    return false ;
      78                 : }
      79                 : 
      80              49 : const YAORB::ClassInfo CORBA::Current::_info("Current") ;
      81                 : 
      82               9 : CORBA::Policy::Policy()
      83               9 :  : CORBA::Object()
      84                 : {}
      85                 : 
      86               9 : CORBA::Policy::~Policy()
      87               0 : {}
      88                 : 
      89                 : CORBA::Policy_ptr
      90               9 : CORBA::Policy::_duplicate(CORBA::Policy_ptr obj)
      91                 : {
      92               9 :    if (CORBA::is_nil(obj))
      93                 :    {
      94               0 :       return _nil() ;
      95                 :    }
      96                 :    else
      97                 :    {
      98               9 :       (void) CORBA::Object::_duplicate(obj) ;
      99                 :       return obj ;
     100                 :    }
     101                 : }
     102                 : 
     103                 : CORBA::Policy_ptr
     104               0 : CORBA::Policy::_narrow(CORBA::Object_ptr obj)
     105                 : {
     106               0 :    if (CORBA::is_nil(obj))
     107                 :    {
     108               0 :       return _nil() ;
     109                 :    }
     110                 :    else
     111                 :    {
     112               0 :       void *that = NULL ;
     113               0 :       if (obj->_isA(& _info, that))
     114                 :       {
     115                 :          CORBA::Policy_ptr ret ;
     116               0 :          ret = (CORBA::Policy_ptr) that ;
     117               0 :          CORBA::Object::_duplicate(obj) ;
     118               0 :          return ret ;
     119                 :       }
     120                 :       else
     121                 :       {
     122               0 :          return _nil() ;
     123                 :       }
     124                 :    }
     125                 : }
     126                 : 
     127              11 : CORBA::Policy_ptr CORBA::Policy::_nil(void)
     128                 : {
     129                 :    return NULL ;
     130                 : }
     131                 : 
     132               0 : CORBA::Policy_ptr CORBA::Policy::_bind(YAORB::CDR* cdrs)
     133                 : {
     134               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     135                 : }
     136                 : 
     137               0 : const YAORB::ClassInfo* CORBA::Policy::_getInfo(void) const
     138                 : {
     139                 :    return & _info ;
     140                 : }
     141                 : 
     142               0 : bool CORBA::Policy::_isA(const YAORB::ClassInfo* info, void*& that) const
     143                 : {
     144               0 :    if (_info.isEquiv(info))
     145                 :    {
     146               0 :       that = (void*) (const void*) this ;
     147                 :       return true ;
     148                 :    }
     149                 :    return false ;
     150                 : }
     151                 : 
     152              49 : const YAORB::ClassInfo CORBA::Policy::_info("Policy") ;
     153                 : 
     154               0 : void CORBA::CDR_DefinitionKind(YAORB::CDR *cdrs, CORBA::DefinitionKind *e)
     155                 : {
     156                 :    CORBA::ULong value ;
     157               0 :    switch (cdrs->Op())
     158                 :    {
     159                 :       case YAORB::CDR_READ:
     160                 :       {
     161               0 :          cdrs->cdr_ULong(& value) ;
     162               0 :          *e = (CORBA::DefinitionKind) value ;
     163               0 :          break ;
     164                 :       }
     165                 :       case YAORB::CDR_WRITE:
     166                 :       {
     167               0 :          value = (CORBA::ULong) (*e) ;
     168               0 :          cdrs->cdr_ULong(& value) ;
     169                 :          break ;
     170                 :       }
     171                 :    }
     172                 : }
     173                 : 
     174               0 : CORBA::IRObject::IRObject()
     175               0 :  : CORBA::Object()
     176                 : {}
     177                 : 
     178               0 : CORBA::IRObject::~IRObject()
     179               0 : {}
     180                 : 
     181                 : CORBA::IRObject_ptr
     182               0 : CORBA::IRObject::_duplicate(CORBA::IRObject_ptr obj)
     183                 : {
     184               0 :    if (CORBA::is_nil(obj))
     185                 :    {
     186               0 :       return _nil() ;
     187                 :    }
     188                 :    else
     189                 :    {
     190               0 :       (void) CORBA::Object::_duplicate(obj) ;
     191                 :       return obj ;
     192                 :    }
     193                 : }
     194                 : 
     195                 : CORBA::IRObject_ptr
     196               0 : CORBA::IRObject::_narrow(CORBA::Object_ptr obj)
     197                 : {
     198               0 :    if (CORBA::is_nil(obj))
     199                 :    {
     200               0 :       return _nil() ;
     201                 :    }
     202                 :    else
     203                 :    {
     204               0 :       void *that = NULL ;
     205               0 :       if (obj->_isA(& _info, that))
     206                 :       {
     207                 :          CORBA::IRObject_ptr ret ;
     208               0 :          ret = (CORBA::IRObject_ptr) that ;
     209               0 :          CORBA::Object::_duplicate(obj) ;
     210               0 :          return ret ;
     211                 :       }
     212                 :       else
     213                 :       {
     214               0 :          return _nil() ;
     215                 :       }
     216                 :    }
     217                 : }
     218                 : 
     219               0 : CORBA::IRObject_ptr CORBA::IRObject::_nil(void)
     220                 : {
     221                 :    return NULL ;
     222                 : }
     223                 : 
     224               0 : CORBA::IRObject_ptr CORBA::IRObject::_bind(YAORB::CDR* cdrs)
     225                 : {
     226               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     227                 : }
     228                 : 
     229               0 : const YAORB::ClassInfo* CORBA::IRObject::_getInfo(void) const
     230                 : {
     231                 :    return & _info ;
     232                 : }
     233                 : 
     234               0 : bool CORBA::IRObject::_isA(const YAORB::ClassInfo* info, void*& that) const
     235                 : {
     236               0 :    if (_info.isEquiv(info))
     237                 :    {
     238               0 :       that = (void*) (const void*) this ;
     239                 :       return true ;
     240                 :    }
     241                 :    return false ;
     242                 : }
     243                 : 
     244              49 : const YAORB::ClassInfo CORBA::IRObject::_info("IRObject") ;
     245                 : 
     246               0 : CORBA::Contained::Contained()
     247                 : {}
     248                 : 
     249               0 : CORBA::Contained::~Contained()
     250               0 : {}
     251                 : 
     252                 : CORBA::Contained_ptr
     253               0 : CORBA::Contained::_duplicate(CORBA::Contained_ptr obj)
     254                 : {
     255               0 :    if (CORBA::is_nil(obj))
     256                 :    {
     257               0 :       return _nil() ;
     258                 :    }
     259                 :    else
     260                 :    {
     261               0 :       (void) CORBA::Object::_duplicate(obj) ;
     262                 :       return obj ;
     263                 :    }
     264                 : }
     265                 : 
     266                 : CORBA::Contained_ptr
     267               0 : CORBA::Contained::_narrow(CORBA::Object_ptr obj)
     268                 : {
     269               0 :    if (CORBA::is_nil(obj))
     270                 :    {
     271               0 :       return _nil() ;
     272                 :    }
     273                 :    else
     274                 :    {
     275               0 :       void *that = NULL ;
     276               0 :       if (obj->_isA(& _info, that))
     277                 :       {
     278                 :          CORBA::Contained_ptr ret ;
     279               0 :          ret = (CORBA::Contained_ptr) that ;
     280               0 :          CORBA::Object::_duplicate(obj) ;
     281               0 :          return ret ;
     282                 :       }
     283                 :       else
     284                 :       {
     285               0 :          return _nil() ;
     286                 :       }
     287                 :    }
     288                 : }
     289                 : 
     290               0 : CORBA::Contained_ptr CORBA::Contained::_nil(void)
     291                 : {
     292                 :    return NULL ;
     293                 : }
     294                 : 
     295               0 : CORBA::Contained_ptr CORBA::Contained::_bind(YAORB::CDR* cdrs)
     296                 : {
     297               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     298                 : }
     299                 : 
     300               0 : const YAORB::ClassInfo* CORBA::Contained::_getInfo(void) const
     301                 : {
     302                 :    return & _info ;
     303                 : }
     304                 : 
     305               0 : bool CORBA::Contained::_isA(const YAORB::ClassInfo* info, void*& that) const
     306                 : {
     307               0 :    if (_info.isEquiv(info))
     308                 :    {
     309               0 :       that = (void*) (const void*) this ;
     310               0 :       return true ;
     311                 :    }
     312               0 :    if (CORBA::IRObject::_isA(info, that))
     313                 :    {
     314                 :       return true ;
     315                 :    }
     316                 :    return false ;
     317                 : }
     318                 : 
     319              49 : const YAORB::ClassInfo CORBA::Contained::_info("Contained") ;
     320                 : 
     321               0 : void CORBA::Contained::Description::cdr(YAORB::CDR* __cdrs)
     322                 : {
     323               0 :    CORBA::CDR_DefinitionKind(__cdrs, & kind) ;
     324                 :    // FIXME CDR
     325                 : }
     326                 : 
     327               0 : void CORBA::StructMember::cdr(YAORB::CDR* __cdrs)
     328                 : {
     329               0 :    name.cdr(__cdrs) ;
     330               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     331               0 : type = CORBA::TypeCode::_nil() ;
     332               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     333               0 : type_def = CORBA::IDLType::_nil() ;
     334                 : }
     335                 : 
     336               0 : void CORBA::Initializer::cdr(YAORB::CDR* __cdrs)
     337                 : {
     338                 :    members.cdr(__cdrs) ;
     339               0 :    name.cdr(__cdrs) ;
     340                 : }
     341                 : 
     342               0 : void CORBA::UnionMember::cdr(YAORB::CDR* __cdrs)
     343                 : {
     344               0 :    name.cdr(__cdrs) ;
     345                 :    // FIXME CDR
     346               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     347               0 : type = CORBA::TypeCode::_nil() ;
     348               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     349               0 : type_def = CORBA::IDLType::_nil() ;
     350                 : }
     351                 : 
     352               0 : CORBA::Container::Container()
     353                 : {}
     354                 : 
     355               0 : CORBA::Container::~Container()
     356               0 : {}
     357                 : 
     358                 : CORBA::Container_ptr
     359               0 : CORBA::Container::_duplicate(CORBA::Container_ptr obj)
     360                 : {
     361               0 :    if (CORBA::is_nil(obj))
     362                 :    {
     363               0 :       return _nil() ;
     364                 :    }
     365                 :    else
     366                 :    {
     367               0 :       (void) CORBA::Object::_duplicate(obj) ;
     368                 :       return obj ;
     369                 :    }
     370                 : }
     371                 : 
     372                 : CORBA::Container_ptr
     373               0 : CORBA::Container::_narrow(CORBA::Object_ptr obj)
     374                 : {
     375               0 :    if (CORBA::is_nil(obj))
     376                 :    {
     377               0 :       return _nil() ;
     378                 :    }
     379                 :    else
     380                 :    {
     381               0 :       void *that = NULL ;
     382               0 :       if (obj->_isA(& _info, that))
     383                 :       {
     384                 :          CORBA::Container_ptr ret ;
     385               0 :          ret = (CORBA::Container_ptr) that ;
     386               0 :          CORBA::Object::_duplicate(obj) ;
     387               0 :          return ret ;
     388                 :       }
     389                 :       else
     390                 :       {
     391               0 :          return _nil() ;
     392                 :       }
     393                 :    }
     394                 : }
     395                 : 
     396               0 : CORBA::Container_ptr CORBA::Container::_nil(void)
     397                 : {
     398                 :    return NULL ;
     399                 : }
     400                 : 
     401               0 : CORBA::Container_ptr CORBA::Container::_bind(YAORB::CDR* cdrs)
     402                 : {
     403               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     404                 : }
     405                 : 
     406               0 : const YAORB::ClassInfo* CORBA::Container::_getInfo(void) const
     407                 : {
     408                 :    return & _info ;
     409                 : }
     410                 : 
     411               0 : bool CORBA::Container::_isA(const YAORB::ClassInfo* info, void*& that) const
     412                 : {
     413               0 :    if (_info.isEquiv(info))
     414                 :    {
     415               0 :       that = (void*) (const void*) this ;
     416               0 :       return true ;
     417                 :    }
     418               0 :    if (CORBA::IRObject::_isA(info, that))
     419                 :    {
     420                 :       return true ;
     421                 :    }
     422                 :    return false ;
     423                 : }
     424                 : 
     425              49 : const YAORB::ClassInfo CORBA::Container::_info("Container") ;
     426                 : 
     427               0 : void CORBA::Container::Description::cdr(YAORB::CDR* __cdrs)
     428                 : {
     429               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     430               0 : contained_object = CORBA::Contained::_nil() ;
     431               0 :    CORBA::CDR_DefinitionKind(__cdrs, & kind) ;
     432                 :    // FIXME CDR
     433                 : }
     434                 : 
     435               0 : CORBA::IDLType::IDLType()
     436                 : {}
     437                 : 
     438               0 : CORBA::IDLType::~IDLType()
     439               0 : {}
     440                 : 
     441                 : CORBA::IDLType_ptr
     442               0 : CORBA::IDLType::_duplicate(CORBA::IDLType_ptr obj)
     443                 : {
     444               0 :    if (CORBA::is_nil(obj))
     445                 :    {
     446               0 :       return _nil() ;
     447                 :    }
     448                 :    else
     449                 :    {
     450               0 :       (void) CORBA::Object::_duplicate(obj) ;
     451                 :       return obj ;
     452                 :    }
     453                 : }
     454                 : 
     455                 : CORBA::IDLType_ptr
     456               0 : CORBA::IDLType::_narrow(CORBA::Object_ptr obj)
     457                 : {
     458               0 :    if (CORBA::is_nil(obj))
     459                 :    {
     460               0 :       return _nil() ;
     461                 :    }
     462                 :    else
     463                 :    {
     464               0 :       void *that = NULL ;
     465               0 :       if (obj->_isA(& _info, that))
     466                 :       {
     467                 :          CORBA::IDLType_ptr ret ;
     468               0 :          ret = (CORBA::IDLType_ptr) that ;
     469               0 :          CORBA::Object::_duplicate(obj) ;
     470               0 :          return ret ;
     471                 :       }
     472                 :       else
     473                 :       {
     474               0 :          return _nil() ;
     475                 :       }
     476                 :    }
     477                 : }
     478                 : 
     479               0 : CORBA::IDLType_ptr CORBA::IDLType::_nil(void)
     480                 : {
     481                 :    return NULL ;
     482                 : }
     483                 : 
     484               0 : CORBA::IDLType_ptr CORBA::IDLType::_bind(YAORB::CDR* cdrs)
     485                 : {
     486               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     487                 : }
     488                 : 
     489               0 : const YAORB::ClassInfo* CORBA::IDLType::_getInfo(void) const
     490                 : {
     491                 :    return & _info ;
     492                 : }
     493                 : 
     494               0 : bool CORBA::IDLType::_isA(const YAORB::ClassInfo* info, void*& that) const
     495                 : {
     496               0 :    if (_info.isEquiv(info))
     497                 :    {
     498               0 :       that = (void*) (const void*) this ;
     499               0 :       return true ;
     500                 :    }
     501               0 :    if (CORBA::IRObject::_isA(info, that))
     502                 :    {
     503                 :       return true ;
     504                 :    }
     505                 :    return false ;
     506                 : }
     507                 : 
     508              49 : const YAORB::ClassInfo CORBA::IDLType::_info("IDLType") ;
     509                 : 
     510               0 : void CORBA::CDR_PrimitiveKind(YAORB::CDR *cdrs, CORBA::PrimitiveKind *e)
     511                 : {
     512                 :    CORBA::ULong value ;
     513               0 :    switch (cdrs->Op())
     514                 :    {
     515                 :       case YAORB::CDR_READ:
     516                 :       {
     517               0 :          cdrs->cdr_ULong(& value) ;
     518               0 :          *e = (CORBA::PrimitiveKind) value ;
     519               0 :          break ;
     520                 :       }
     521                 :       case YAORB::CDR_WRITE:
     522                 :       {
     523               0 :          value = (CORBA::ULong) (*e) ;
     524               0 :          cdrs->cdr_ULong(& value) ;
     525                 :          break ;
     526                 :       }
     527                 :    }
     528                 : }
     529                 : 
     530               0 : CORBA::Repository::Repository()
     531                 : {}
     532                 : 
     533               0 : CORBA::Repository::~Repository()
     534               0 : {}
     535                 : 
     536                 : CORBA::Repository_ptr
     537               0 : CORBA::Repository::_duplicate(CORBA::Repository_ptr obj)
     538                 : {
     539               0 :    if (CORBA::is_nil(obj))
     540                 :    {
     541               0 :       return _nil() ;
     542                 :    }
     543                 :    else
     544                 :    {
     545               0 :       (void) CORBA::Object::_duplicate(obj) ;
     546                 :       return obj ;
     547                 :    }
     548                 : }
     549                 : 
     550                 : CORBA::Repository_ptr
     551               0 : CORBA::Repository::_narrow(CORBA::Object_ptr obj)
     552                 : {
     553               0 :    if (CORBA::is_nil(obj))
     554                 :    {
     555               0 :       return _nil() ;
     556                 :    }
     557                 :    else
     558                 :    {
     559               0 :       void *that = NULL ;
     560               0 :       if (obj->_isA(& _info, that))
     561                 :       {
     562                 :          CORBA::Repository_ptr ret ;
     563               0 :          ret = (CORBA::Repository_ptr) that ;
     564               0 :          CORBA::Object::_duplicate(obj) ;
     565               0 :          return ret ;
     566                 :       }
     567                 :       else
     568                 :       {
     569               0 :          return _nil() ;
     570                 :       }
     571                 :    }
     572                 : }
     573                 : 
     574               0 : CORBA::Repository_ptr CORBA::Repository::_nil(void)
     575                 : {
     576                 :    return NULL ;
     577                 : }
     578                 : 
     579               0 : CORBA::Repository_ptr CORBA::Repository::_bind(YAORB::CDR* cdrs)
     580                 : {
     581               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     582                 : }
     583                 : 
     584               0 : const YAORB::ClassInfo* CORBA::Repository::_getInfo(void) const
     585                 : {
     586                 :    return & _info ;
     587                 : }
     588                 : 
     589               0 : bool CORBA::Repository::_isA(const YAORB::ClassInfo* info, void*& that) const
     590                 : {
     591               0 :    if (_info.isEquiv(info))
     592                 :    {
     593               0 :       that = (void*) (const void*) this ;
     594               0 :       return true ;
     595                 :    }
     596               0 :    if (CORBA::Container::_isA(info, that))
     597                 :    {
     598                 :       return true ;
     599                 :    }
     600                 :    return false ;
     601                 : }
     602                 : 
     603              49 : const YAORB::ClassInfo CORBA::Repository::_info("Repository") ;
     604                 : 
     605               0 : CORBA::ModuleDef::ModuleDef()
     606                 : {}
     607                 : 
     608               0 : CORBA::ModuleDef::~ModuleDef()
     609               0 : {}
     610                 : 
     611                 : CORBA::ModuleDef_ptr
     612               0 : CORBA::ModuleDef::_duplicate(CORBA::ModuleDef_ptr obj)
     613                 : {
     614               0 :    if (CORBA::is_nil(obj))
     615                 :    {
     616               0 :       return _nil() ;
     617                 :    }
     618                 :    else
     619                 :    {
     620               0 :       (void) CORBA::Object::_duplicate(obj) ;
     621                 :       return obj ;
     622                 :    }
     623                 : }
     624                 : 
     625                 : CORBA::ModuleDef_ptr
     626               0 : CORBA::ModuleDef::_narrow(CORBA::Object_ptr obj)
     627                 : {
     628               0 :    if (CORBA::is_nil(obj))
     629                 :    {
     630               0 :       return _nil() ;
     631                 :    }
     632                 :    else
     633                 :    {
     634               0 :       void *that = NULL ;
     635               0 :       if (obj->_isA(& _info, that))
     636                 :       {
     637                 :          CORBA::ModuleDef_ptr ret ;
     638               0 :          ret = (CORBA::ModuleDef_ptr) that ;
     639               0 :          CORBA::Object::_duplicate(obj) ;
     640               0 :          return ret ;
     641                 :       }
     642                 :       else
     643                 :       {
     644               0 :          return _nil() ;
     645                 :       }
     646                 :    }
     647                 : }
     648                 : 
     649               0 : CORBA::ModuleDef_ptr CORBA::ModuleDef::_nil(void)
     650                 : {
     651                 :    return NULL ;
     652                 : }
     653                 : 
     654               0 : CORBA::ModuleDef_ptr CORBA::ModuleDef::_bind(YAORB::CDR* cdrs)
     655                 : {
     656               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     657                 : }
     658                 : 
     659               0 : const YAORB::ClassInfo* CORBA::ModuleDef::_getInfo(void) const
     660                 : {
     661                 :    return & _info ;
     662                 : }
     663                 : 
     664               0 : bool CORBA::ModuleDef::_isA(const YAORB::ClassInfo* info, void*& that) const
     665                 : {
     666               0 :    if (_info.isEquiv(info))
     667                 :    {
     668               0 :       that = (void*) (const void*) this ;
     669               0 :       return true ;
     670                 :    }
     671               0 :    if (CORBA::Container::_isA(info, that))
     672                 :    {
     673                 :       return true ;
     674                 :    }
     675               0 :    if (CORBA::Contained::_isA(info, that))
     676                 :    {
     677                 :       return true ;
     678                 :    }
     679                 :    return false ;
     680                 : }
     681                 : 
     682              49 : const YAORB::ClassInfo CORBA::ModuleDef::_info("ModuleDef") ;
     683                 : 
     684               0 : void CORBA::ModuleDescription::cdr(YAORB::CDR* __cdrs)
     685                 : {
     686               0 :    name.cdr(__cdrs) ;
     687               0 :    id.cdr(__cdrs) ;
     688               0 :    defined_in.cdr(__cdrs) ;
     689               0 :    version.cdr(__cdrs) ;
     690                 : }
     691                 : 
     692               0 : CORBA::ConstantDef::ConstantDef()
     693                 : {}
     694                 : 
     695               0 : CORBA::ConstantDef::~ConstantDef()
     696               0 : {}
     697                 : 
     698                 : CORBA::ConstantDef_ptr
     699               0 : CORBA::ConstantDef::_duplicate(CORBA::ConstantDef_ptr obj)
     700                 : {
     701               0 :    if (CORBA::is_nil(obj))
     702                 :    {
     703               0 :       return _nil() ;
     704                 :    }
     705                 :    else
     706                 :    {
     707               0 :       (void) CORBA::Object::_duplicate(obj) ;
     708                 :       return obj ;
     709                 :    }
     710                 : }
     711                 : 
     712                 : CORBA::ConstantDef_ptr
     713               0 : CORBA::ConstantDef::_narrow(CORBA::Object_ptr obj)
     714                 : {
     715               0 :    if (CORBA::is_nil(obj))
     716                 :    {
     717               0 :       return _nil() ;
     718                 :    }
     719                 :    else
     720                 :    {
     721               0 :       void *that = NULL ;
     722               0 :       if (obj->_isA(& _info, that))
     723                 :       {
     724                 :          CORBA::ConstantDef_ptr ret ;
     725               0 :          ret = (CORBA::ConstantDef_ptr) that ;
     726               0 :          CORBA::Object::_duplicate(obj) ;
     727               0 :          return ret ;
     728                 :       }
     729                 :       else
     730                 :       {
     731               0 :          return _nil() ;
     732                 :       }
     733                 :    }
     734                 : }
     735                 : 
     736               0 : CORBA::ConstantDef_ptr CORBA::ConstantDef::_nil(void)
     737                 : {
     738                 :    return NULL ;
     739                 : }
     740                 : 
     741               0 : CORBA::ConstantDef_ptr CORBA::ConstantDef::_bind(YAORB::CDR* cdrs)
     742                 : {
     743               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     744                 : }
     745                 : 
     746               0 : const YAORB::ClassInfo* CORBA::ConstantDef::_getInfo(void) const
     747                 : {
     748                 :    return & _info ;
     749                 : }
     750                 : 
     751               0 : bool CORBA::ConstantDef::_isA(const YAORB::ClassInfo* info, void*& that) const
     752                 : {
     753               0 :    if (_info.isEquiv(info))
     754                 :    {
     755               0 :       that = (void*) (const void*) this ;
     756               0 :       return true ;
     757                 :    }
     758               0 :    if (CORBA::Contained::_isA(info, that))
     759                 :    {
     760                 :       return true ;
     761                 :    }
     762                 :    return false ;
     763                 : }
     764                 : 
     765              49 : const YAORB::ClassInfo CORBA::ConstantDef::_info("ConstantDef") ;
     766                 : 
     767               0 : void CORBA::ConstantDescription::cdr(YAORB::CDR* __cdrs)
     768                 : {
     769               0 :    name.cdr(__cdrs) ;
     770               0 :    id.cdr(__cdrs) ;
     771               0 :    defined_in.cdr(__cdrs) ;
     772               0 :    version.cdr(__cdrs) ;
     773               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     774               0 : type = CORBA::TypeCode::_nil() ;
     775                 :    // FIXME CDR
     776                 : }
     777                 : 
     778               0 : CORBA::TypedefDef::TypedefDef()
     779                 : {}
     780                 : 
     781               0 : CORBA::TypedefDef::~TypedefDef()
     782               0 : {}
     783                 : 
     784                 : CORBA::TypedefDef_ptr
     785               0 : CORBA::TypedefDef::_duplicate(CORBA::TypedefDef_ptr obj)
     786                 : {
     787               0 :    if (CORBA::is_nil(obj))
     788                 :    {
     789               0 :       return _nil() ;
     790                 :    }
     791                 :    else
     792                 :    {
     793               0 :       (void) CORBA::Object::_duplicate(obj) ;
     794                 :       return obj ;
     795                 :    }
     796                 : }
     797                 : 
     798                 : CORBA::TypedefDef_ptr
     799               0 : CORBA::TypedefDef::_narrow(CORBA::Object_ptr obj)
     800                 : {
     801               0 :    if (CORBA::is_nil(obj))
     802                 :    {
     803               0 :       return _nil() ;
     804                 :    }
     805                 :    else
     806                 :    {
     807               0 :       void *that = NULL ;
     808               0 :       if (obj->_isA(& _info, that))
     809                 :       {
     810                 :          CORBA::TypedefDef_ptr ret ;
     811               0 :          ret = (CORBA::TypedefDef_ptr) that ;
     812               0 :          CORBA::Object::_duplicate(obj) ;
     813               0 :          return ret ;
     814                 :       }
     815                 :       else
     816                 :       {
     817               0 :          return _nil() ;
     818                 :       }
     819                 :    }
     820                 : }
     821                 : 
     822               0 : CORBA::TypedefDef_ptr CORBA::TypedefDef::_nil(void)
     823                 : {
     824                 :    return NULL ;
     825                 : }
     826                 : 
     827               0 : CORBA::TypedefDef_ptr CORBA::TypedefDef::_bind(YAORB::CDR* cdrs)
     828                 : {
     829               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     830                 : }
     831                 : 
     832               0 : const YAORB::ClassInfo* CORBA::TypedefDef::_getInfo(void) const
     833                 : {
     834                 :    return & _info ;
     835                 : }
     836                 : 
     837               0 : bool CORBA::TypedefDef::_isA(const YAORB::ClassInfo* info, void*& that) const
     838                 : {
     839               0 :    if (_info.isEquiv(info))
     840                 :    {
     841               0 :       that = (void*) (const void*) this ;
     842               0 :       return true ;
     843                 :    }
     844               0 :    if (CORBA::Contained::_isA(info, that))
     845                 :    {
     846                 :       return true ;
     847                 :    }
     848               0 :    if (CORBA::IDLType::_isA(info, that))
     849                 :    {
     850                 :       return true ;
     851                 :    }
     852                 :    return false ;
     853                 : }
     854                 : 
     855              49 : const YAORB::ClassInfo CORBA::TypedefDef::_info("TypedefDef") ;
     856                 : 
     857               0 : void CORBA::TypeDescription::cdr(YAORB::CDR* __cdrs)
     858                 : {
     859               0 :    name.cdr(__cdrs) ;
     860               0 :    id.cdr(__cdrs) ;
     861               0 :    defined_in.cdr(__cdrs) ;
     862               0 :    version.cdr(__cdrs) ;
     863               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
     864               0 : type = CORBA::TypeCode::_nil() ;
     865                 : }
     866                 : 
     867               0 : CORBA::StructDef::StructDef()
     868                 : {}
     869                 : 
     870               0 : CORBA::StructDef::~StructDef()
     871               0 : {}
     872                 : 
     873                 : CORBA::StructDef_ptr
     874               0 : CORBA::StructDef::_duplicate(CORBA::StructDef_ptr obj)
     875                 : {
     876               0 :    if (CORBA::is_nil(obj))
     877                 :    {
     878               0 :       return _nil() ;
     879                 :    }
     880                 :    else
     881                 :    {
     882               0 :       (void) CORBA::Object::_duplicate(obj) ;
     883                 :       return obj ;
     884                 :    }
     885                 : }
     886                 : 
     887                 : CORBA::StructDef_ptr
     888               0 : CORBA::StructDef::_narrow(CORBA::Object_ptr obj)
     889                 : {
     890               0 :    if (CORBA::is_nil(obj))
     891                 :    {
     892               0 :       return _nil() ;
     893                 :    }
     894                 :    else
     895                 :    {
     896               0 :       void *that = NULL ;
     897               0 :       if (obj->_isA(& _info, that))
     898                 :       {
     899                 :          CORBA::StructDef_ptr ret ;
     900               0 :          ret = (CORBA::StructDef_ptr) that ;
     901               0 :          CORBA::Object::_duplicate(obj) ;
     902               0 :          return ret ;
     903                 :       }
     904                 :       else
     905                 :       {
     906               0 :          return _nil() ;
     907                 :       }
     908                 :    }
     909                 : }
     910                 : 
     911               0 : CORBA::StructDef_ptr CORBA::StructDef::_nil(void)
     912                 : {
     913                 :    return NULL ;
     914                 : }
     915                 : 
     916               0 : CORBA::StructDef_ptr CORBA::StructDef::_bind(YAORB::CDR* cdrs)
     917                 : {
     918               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     919                 : }
     920                 : 
     921               0 : const YAORB::ClassInfo* CORBA::StructDef::_getInfo(void) const
     922                 : {
     923                 :    return & _info ;
     924                 : }
     925                 : 
     926               0 : bool CORBA::StructDef::_isA(const YAORB::ClassInfo* info, void*& that) const
     927                 : {
     928               0 :    if (_info.isEquiv(info))
     929                 :    {
     930               0 :       that = (void*) (const void*) this ;
     931               0 :       return true ;
     932                 :    }
     933               0 :    if (CORBA::TypedefDef::_isA(info, that))
     934                 :    {
     935                 :       return true ;
     936                 :    }
     937               0 :    if (CORBA::Container::_isA(info, that))
     938                 :    {
     939                 :       return true ;
     940                 :    }
     941                 :    return false ;
     942                 : }
     943                 : 
     944              49 : const YAORB::ClassInfo CORBA::StructDef::_info("StructDef") ;
     945                 : 
     946               0 : CORBA::UnionDef::UnionDef()
     947                 : {}
     948                 : 
     949               0 : CORBA::UnionDef::~UnionDef()
     950               0 : {}
     951                 : 
     952                 : CORBA::UnionDef_ptr
     953               0 : CORBA::UnionDef::_duplicate(CORBA::UnionDef_ptr obj)
     954                 : {
     955               0 :    if (CORBA::is_nil(obj))
     956                 :    {
     957               0 :       return _nil() ;
     958                 :    }
     959                 :    else
     960                 :    {
     961               0 :       (void) CORBA::Object::_duplicate(obj) ;
     962                 :       return obj ;
     963                 :    }
     964                 : }
     965                 : 
     966                 : CORBA::UnionDef_ptr
     967               0 : CORBA::UnionDef::_narrow(CORBA::Object_ptr obj)
     968                 : {
     969               0 :    if (CORBA::is_nil(obj))
     970                 :    {
     971               0 :       return _nil() ;
     972                 :    }
     973                 :    else
     974                 :    {
     975               0 :       void *that = NULL ;
     976               0 :       if (obj->_isA(& _info, that))
     977                 :       {
     978                 :          CORBA::UnionDef_ptr ret ;
     979               0 :          ret = (CORBA::UnionDef_ptr) that ;
     980               0 :          CORBA::Object::_duplicate(obj) ;
     981               0 :          return ret ;
     982                 :       }
     983                 :       else
     984                 :       {
     985               0 :          return _nil() ;
     986                 :       }
     987                 :    }
     988                 : }
     989                 : 
     990               0 : CORBA::UnionDef_ptr CORBA::UnionDef::_nil(void)
     991                 : {
     992                 :    return NULL ;
     993                 : }
     994                 : 
     995               0 : CORBA::UnionDef_ptr CORBA::UnionDef::_bind(YAORB::CDR* cdrs)
     996                 : {
     997               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
     998                 : }
     999                 : 
    1000               0 : const YAORB::ClassInfo* CORBA::UnionDef::_getInfo(void) const
    1001                 : {
    1002                 :    return & _info ;
    1003                 : }
    1004                 : 
    1005               0 : bool CORBA::UnionDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1006                 : {
    1007               0 :    if (_info.isEquiv(info))
    1008                 :    {
    1009               0 :       that = (void*) (const void*) this ;
    1010               0 :       return true ;
    1011                 :    }
    1012               0 :    if (CORBA::TypedefDef::_isA(info, that))
    1013                 :    {
    1014                 :       return true ;
    1015                 :    }
    1016               0 :    if (CORBA::Container::_isA(info, that))
    1017                 :    {
    1018                 :       return true ;
    1019                 :    }
    1020                 :    return false ;
    1021                 : }
    1022                 : 
    1023              49 : const YAORB::ClassInfo CORBA::UnionDef::_info("UnionDef") ;
    1024                 : 
    1025               0 : CORBA::EnumDef::EnumDef()
    1026                 : {}
    1027                 : 
    1028               0 : CORBA::EnumDef::~EnumDef()
    1029               0 : {}
    1030                 : 
    1031                 : CORBA::EnumDef_ptr
    1032               0 : CORBA::EnumDef::_duplicate(CORBA::EnumDef_ptr obj)
    1033                 : {
    1034               0 :    if (CORBA::is_nil(obj))
    1035                 :    {
    1036               0 :       return _nil() ;
    1037                 :    }
    1038                 :    else
    1039                 :    {
    1040               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1041                 :       return obj ;
    1042                 :    }
    1043                 : }
    1044                 : 
    1045                 : CORBA::EnumDef_ptr
    1046               0 : CORBA::EnumDef::_narrow(CORBA::Object_ptr obj)
    1047                 : {
    1048               0 :    if (CORBA::is_nil(obj))
    1049                 :    {
    1050               0 :       return _nil() ;
    1051                 :    }
    1052                 :    else
    1053                 :    {
    1054               0 :       void *that = NULL ;
    1055               0 :       if (obj->_isA(& _info, that))
    1056                 :       {
    1057                 :          CORBA::EnumDef_ptr ret ;
    1058               0 :          ret = (CORBA::EnumDef_ptr) that ;
    1059               0 :          CORBA::Object::_duplicate(obj) ;
    1060               0 :          return ret ;
    1061                 :       }
    1062                 :       else
    1063                 :       {
    1064               0 :          return _nil() ;
    1065                 :       }
    1066                 :    }
    1067                 : }
    1068                 : 
    1069               0 : CORBA::EnumDef_ptr CORBA::EnumDef::_nil(void)
    1070                 : {
    1071                 :    return NULL ;
    1072                 : }
    1073                 : 
    1074               0 : CORBA::EnumDef_ptr CORBA::EnumDef::_bind(YAORB::CDR* cdrs)
    1075                 : {
    1076               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1077                 : }
    1078                 : 
    1079               0 : const YAORB::ClassInfo* CORBA::EnumDef::_getInfo(void) const
    1080                 : {
    1081                 :    return & _info ;
    1082                 : }
    1083                 : 
    1084               0 : bool CORBA::EnumDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1085                 : {
    1086               0 :    if (_info.isEquiv(info))
    1087                 :    {
    1088               0 :       that = (void*) (const void*) this ;
    1089               0 :       return true ;
    1090                 :    }
    1091               0 :    if (CORBA::TypedefDef::_isA(info, that))
    1092                 :    {
    1093                 :       return true ;
    1094                 :    }
    1095                 :    return false ;
    1096                 : }
    1097                 : 
    1098              49 : const YAORB::ClassInfo CORBA::EnumDef::_info("EnumDef") ;
    1099                 : 
    1100               0 : CORBA::AliasDef::AliasDef()
    1101                 : {}
    1102                 : 
    1103               0 : CORBA::AliasDef::~AliasDef()
    1104               0 : {}
    1105                 : 
    1106                 : CORBA::AliasDef_ptr
    1107               0 : CORBA::AliasDef::_duplicate(CORBA::AliasDef_ptr obj)
    1108                 : {
    1109               0 :    if (CORBA::is_nil(obj))
    1110                 :    {
    1111               0 :       return _nil() ;
    1112                 :    }
    1113                 :    else
    1114                 :    {
    1115               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1116                 :       return obj ;
    1117                 :    }
    1118                 : }
    1119                 : 
    1120                 : CORBA::AliasDef_ptr
    1121               0 : CORBA::AliasDef::_narrow(CORBA::Object_ptr obj)
    1122                 : {
    1123               0 :    if (CORBA::is_nil(obj))
    1124                 :    {
    1125               0 :       return _nil() ;
    1126                 :    }
    1127                 :    else
    1128                 :    {
    1129               0 :       void *that = NULL ;
    1130               0 :       if (obj->_isA(& _info, that))
    1131                 :       {
    1132                 :          CORBA::AliasDef_ptr ret ;
    1133               0 :          ret = (CORBA::AliasDef_ptr) that ;
    1134               0 :          CORBA::Object::_duplicate(obj) ;
    1135               0 :          return ret ;
    1136                 :       }
    1137                 :       else
    1138                 :       {
    1139               0 :          return _nil() ;
    1140                 :       }
    1141                 :    }
    1142                 : }
    1143                 : 
    1144               0 : CORBA::AliasDef_ptr CORBA::AliasDef::_nil(void)
    1145                 : {
    1146                 :    return NULL ;
    1147                 : }
    1148                 : 
    1149               0 : CORBA::AliasDef_ptr CORBA::AliasDef::_bind(YAORB::CDR* cdrs)
    1150                 : {
    1151               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1152                 : }
    1153                 : 
    1154               0 : const YAORB::ClassInfo* CORBA::AliasDef::_getInfo(void) const
    1155                 : {
    1156                 :    return & _info ;
    1157                 : }
    1158                 : 
    1159               0 : bool CORBA::AliasDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1160                 : {
    1161               0 :    if (_info.isEquiv(info))
    1162                 :    {
    1163               0 :       that = (void*) (const void*) this ;
    1164               0 :       return true ;
    1165                 :    }
    1166               0 :    if (CORBA::TypedefDef::_isA(info, that))
    1167                 :    {
    1168                 :       return true ;
    1169                 :    }
    1170                 :    return false ;
    1171                 : }
    1172                 : 
    1173              49 : const YAORB::ClassInfo CORBA::AliasDef::_info("AliasDef") ;
    1174                 : 
    1175               0 : CORBA::NativeDef::NativeDef()
    1176                 : {}
    1177                 : 
    1178               0 : CORBA::NativeDef::~NativeDef()
    1179               0 : {}
    1180                 : 
    1181                 : CORBA::NativeDef_ptr
    1182               0 : CORBA::NativeDef::_duplicate(CORBA::NativeDef_ptr obj)
    1183                 : {
    1184               0 :    if (CORBA::is_nil(obj))
    1185                 :    {
    1186               0 :       return _nil() ;
    1187                 :    }
    1188                 :    else
    1189                 :    {
    1190               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1191                 :       return obj ;
    1192                 :    }
    1193                 : }
    1194                 : 
    1195                 : CORBA::NativeDef_ptr
    1196               0 : CORBA::NativeDef::_narrow(CORBA::Object_ptr obj)
    1197                 : {
    1198               0 :    if (CORBA::is_nil(obj))
    1199                 :    {
    1200               0 :       return _nil() ;
    1201                 :    }
    1202                 :    else
    1203                 :    {
    1204               0 :       void *that = NULL ;
    1205               0 :       if (obj->_isA(& _info, that))
    1206                 :       {
    1207                 :          CORBA::NativeDef_ptr ret ;
    1208               0 :          ret = (CORBA::NativeDef_ptr) that ;
    1209               0 :          CORBA::Object::_duplicate(obj) ;
    1210               0 :          return ret ;
    1211                 :       }
    1212                 :       else
    1213                 :       {
    1214               0 :          return _nil() ;
    1215                 :       }
    1216                 :    }
    1217                 : }
    1218                 : 
    1219               0 : CORBA::NativeDef_ptr CORBA::NativeDef::_nil(void)
    1220                 : {
    1221                 :    return NULL ;
    1222                 : }
    1223                 : 
    1224               0 : CORBA::NativeDef_ptr CORBA::NativeDef::_bind(YAORB::CDR* cdrs)
    1225                 : {
    1226               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1227                 : }
    1228                 : 
    1229               0 : const YAORB::ClassInfo* CORBA::NativeDef::_getInfo(void) const
    1230                 : {
    1231                 :    return & _info ;
    1232                 : }
    1233                 : 
    1234               0 : bool CORBA::NativeDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1235                 : {
    1236               0 :    if (_info.isEquiv(info))
    1237                 :    {
    1238               0 :       that = (void*) (const void*) this ;
    1239               0 :       return true ;
    1240                 :    }
    1241               0 :    if (CORBA::TypedefDef::_isA(info, that))
    1242                 :    {
    1243                 :       return true ;
    1244                 :    }
    1245                 :    return false ;
    1246                 : }
    1247                 : 
    1248              49 : const YAORB::ClassInfo CORBA::NativeDef::_info("NativeDef") ;
    1249                 : 
    1250               0 : CORBA::PrimitiveDef::PrimitiveDef()
    1251                 : {}
    1252                 : 
    1253               0 : CORBA::PrimitiveDef::~PrimitiveDef()
    1254               0 : {}
    1255                 : 
    1256                 : CORBA::PrimitiveDef_ptr
    1257               0 : CORBA::PrimitiveDef::_duplicate(CORBA::PrimitiveDef_ptr obj)
    1258                 : {
    1259               0 :    if (CORBA::is_nil(obj))
    1260                 :    {
    1261               0 :       return _nil() ;
    1262                 :    }
    1263                 :    else
    1264                 :    {
    1265               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1266                 :       return obj ;
    1267                 :    }
    1268                 : }
    1269                 : 
    1270                 : CORBA::PrimitiveDef_ptr
    1271               0 : CORBA::PrimitiveDef::_narrow(CORBA::Object_ptr obj)
    1272                 : {
    1273               0 :    if (CORBA::is_nil(obj))
    1274                 :    {
    1275               0 :       return _nil() ;
    1276                 :    }
    1277                 :    else
    1278                 :    {
    1279               0 :       void *that = NULL ;
    1280               0 :       if (obj->_isA(& _info, that))
    1281                 :       {
    1282                 :          CORBA::PrimitiveDef_ptr ret ;
    1283               0 :          ret = (CORBA::PrimitiveDef_ptr) that ;
    1284               0 :          CORBA::Object::_duplicate(obj) ;
    1285               0 :          return ret ;
    1286                 :       }
    1287                 :       else
    1288                 :       {
    1289               0 :          return _nil() ;
    1290                 :       }
    1291                 :    }
    1292                 : }
    1293                 : 
    1294               0 : CORBA::PrimitiveDef_ptr CORBA::PrimitiveDef::_nil(void)
    1295                 : {
    1296                 :    return NULL ;
    1297                 : }
    1298                 : 
    1299               0 : CORBA::PrimitiveDef_ptr CORBA::PrimitiveDef::_bind(YAORB::CDR* cdrs)
    1300                 : {
    1301               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1302                 : }
    1303                 : 
    1304               0 : const YAORB::ClassInfo* CORBA::PrimitiveDef::_getInfo(void) const
    1305                 : {
    1306                 :    return & _info ;
    1307                 : }
    1308                 : 
    1309               0 : bool CORBA::PrimitiveDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1310                 : {
    1311               0 :    if (_info.isEquiv(info))
    1312                 :    {
    1313               0 :       that = (void*) (const void*) this ;
    1314               0 :       return true ;
    1315                 :    }
    1316               0 :    if (CORBA::IDLType::_isA(info, that))
    1317                 :    {
    1318                 :       return true ;
    1319                 :    }
    1320                 :    return false ;
    1321                 : }
    1322                 : 
    1323              49 : const YAORB::ClassInfo CORBA::PrimitiveDef::_info("PrimitiveDef") ;
    1324                 : 
    1325               0 : CORBA::StringDef::StringDef()
    1326                 : {}
    1327                 : 
    1328               0 : CORBA::StringDef::~StringDef()
    1329               0 : {}
    1330                 : 
    1331                 : CORBA::StringDef_ptr
    1332               0 : CORBA::StringDef::_duplicate(CORBA::StringDef_ptr obj)
    1333                 : {
    1334               0 :    if (CORBA::is_nil(obj))
    1335                 :    {
    1336               0 :       return _nil() ;
    1337                 :    }
    1338                 :    else
    1339                 :    {
    1340               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1341                 :       return obj ;
    1342                 :    }
    1343                 : }
    1344                 : 
    1345                 : CORBA::StringDef_ptr
    1346               0 : CORBA::StringDef::_narrow(CORBA::Object_ptr obj)
    1347                 : {
    1348               0 :    if (CORBA::is_nil(obj))
    1349                 :    {
    1350               0 :       return _nil() ;
    1351                 :    }
    1352                 :    else
    1353                 :    {
    1354               0 :       void *that = NULL ;
    1355               0 :       if (obj->_isA(& _info, that))
    1356                 :       {
    1357                 :          CORBA::StringDef_ptr ret ;
    1358               0 :          ret = (CORBA::StringDef_ptr) that ;
    1359               0 :          CORBA::Object::_duplicate(obj) ;
    1360               0 :          return ret ;
    1361                 :       }
    1362                 :       else
    1363                 :       {
    1364               0 :          return _nil() ;
    1365                 :       }
    1366                 :    }
    1367                 : }
    1368                 : 
    1369               0 : CORBA::StringDef_ptr CORBA::StringDef::_nil(void)
    1370                 : {
    1371                 :    return NULL ;
    1372                 : }
    1373                 : 
    1374               0 : CORBA::StringDef_ptr CORBA::StringDef::_bind(YAORB::CDR* cdrs)
    1375                 : {
    1376               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1377                 : }
    1378                 : 
    1379               0 : const YAORB::ClassInfo* CORBA::StringDef::_getInfo(void) const
    1380                 : {
    1381                 :    return & _info ;
    1382                 : }
    1383                 : 
    1384               0 : bool CORBA::StringDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1385                 : {
    1386               0 :    if (_info.isEquiv(info))
    1387                 :    {
    1388               0 :       that = (void*) (const void*) this ;
    1389               0 :       return true ;
    1390                 :    }
    1391               0 :    if (CORBA::IDLType::_isA(info, that))
    1392                 :    {
    1393                 :       return true ;
    1394                 :    }
    1395                 :    return false ;
    1396                 : }
    1397                 : 
    1398              49 : const YAORB::ClassInfo CORBA::StringDef::_info("StringDef") ;
    1399                 : 
    1400               0 : CORBA::WstringDef::WstringDef()
    1401                 : {}
    1402                 : 
    1403               0 : CORBA::WstringDef::~WstringDef()
    1404               0 : {}
    1405                 : 
    1406                 : CORBA::WstringDef_ptr
    1407               0 : CORBA::WstringDef::_duplicate(CORBA::WstringDef_ptr obj)
    1408                 : {
    1409               0 :    if (CORBA::is_nil(obj))
    1410                 :    {
    1411               0 :       return _nil() ;
    1412                 :    }
    1413                 :    else
    1414                 :    {
    1415               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1416                 :       return obj ;
    1417                 :    }
    1418                 : }
    1419                 : 
    1420                 : CORBA::WstringDef_ptr
    1421               0 : CORBA::WstringDef::_narrow(CORBA::Object_ptr obj)
    1422                 : {
    1423               0 :    if (CORBA::is_nil(obj))
    1424                 :    {
    1425               0 :       return _nil() ;
    1426                 :    }
    1427                 :    else
    1428                 :    {
    1429               0 :       void *that = NULL ;
    1430               0 :       if (obj->_isA(& _info, that))
    1431                 :       {
    1432                 :          CORBA::WstringDef_ptr ret ;
    1433               0 :          ret = (CORBA::WstringDef_ptr) that ;
    1434               0 :          CORBA::Object::_duplicate(obj) ;
    1435               0 :          return ret ;
    1436                 :       }
    1437                 :       else
    1438                 :       {
    1439               0 :          return _nil() ;
    1440                 :       }
    1441                 :    }
    1442                 : }
    1443                 : 
    1444               0 : CORBA::WstringDef_ptr CORBA::WstringDef::_nil(void)
    1445                 : {
    1446                 :    return NULL ;
    1447                 : }
    1448                 : 
    1449               0 : CORBA::WstringDef_ptr CORBA::WstringDef::_bind(YAORB::CDR* cdrs)
    1450                 : {
    1451               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1452                 : }
    1453                 : 
    1454               0 : const YAORB::ClassInfo* CORBA::WstringDef::_getInfo(void) const
    1455                 : {
    1456                 :    return & _info ;
    1457                 : }
    1458                 : 
    1459               0 : bool CORBA::WstringDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1460                 : {
    1461               0 :    if (_info.isEquiv(info))
    1462                 :    {
    1463               0 :       that = (void*) (const void*) this ;
    1464               0 :       return true ;
    1465                 :    }
    1466               0 :    if (CORBA::IDLType::_isA(info, that))
    1467                 :    {
    1468                 :       return true ;
    1469                 :    }
    1470                 :    return false ;
    1471                 : }
    1472                 : 
    1473              49 : const YAORB::ClassInfo CORBA::WstringDef::_info("WstringDef") ;
    1474                 : 
    1475               0 : CORBA::FixedDef::FixedDef()
    1476                 : {}
    1477                 : 
    1478               0 : CORBA::FixedDef::~FixedDef()
    1479               0 : {}
    1480                 : 
    1481                 : CORBA::FixedDef_ptr
    1482               0 : CORBA::FixedDef::_duplicate(CORBA::FixedDef_ptr obj)
    1483                 : {
    1484               0 :    if (CORBA::is_nil(obj))
    1485                 :    {
    1486               0 :       return _nil() ;
    1487                 :    }
    1488                 :    else
    1489                 :    {
    1490               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1491                 :       return obj ;
    1492                 :    }
    1493                 : }
    1494                 : 
    1495                 : CORBA::FixedDef_ptr
    1496               0 : CORBA::FixedDef::_narrow(CORBA::Object_ptr obj)
    1497                 : {
    1498               0 :    if (CORBA::is_nil(obj))
    1499                 :    {
    1500               0 :       return _nil() ;
    1501                 :    }
    1502                 :    else
    1503                 :    {
    1504               0 :       void *that = NULL ;
    1505               0 :       if (obj->_isA(& _info, that))
    1506                 :       {
    1507                 :          CORBA::FixedDef_ptr ret ;
    1508               0 :          ret = (CORBA::FixedDef_ptr) that ;
    1509               0 :          CORBA::Object::_duplicate(obj) ;
    1510               0 :          return ret ;
    1511                 :       }
    1512                 :       else
    1513                 :       {
    1514               0 :          return _nil() ;
    1515                 :       }
    1516                 :    }
    1517                 : }
    1518                 : 
    1519               0 : CORBA::FixedDef_ptr CORBA::FixedDef::_nil(void)
    1520                 : {
    1521                 :    return NULL ;
    1522                 : }
    1523                 : 
    1524               0 : CORBA::FixedDef_ptr CORBA::FixedDef::_bind(YAORB::CDR* cdrs)
    1525                 : {
    1526               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1527                 : }
    1528                 : 
    1529               0 : const YAORB::ClassInfo* CORBA::FixedDef::_getInfo(void) const
    1530                 : {
    1531                 :    return & _info ;
    1532                 : }
    1533                 : 
    1534               0 : bool CORBA::FixedDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1535                 : {
    1536               0 :    if (_info.isEquiv(info))
    1537                 :    {
    1538               0 :       that = (void*) (const void*) this ;
    1539               0 :       return true ;
    1540                 :    }
    1541               0 :    if (CORBA::IDLType::_isA(info, that))
    1542                 :    {
    1543                 :       return true ;
    1544                 :    }
    1545                 :    return false ;
    1546                 : }
    1547                 : 
    1548              49 : const YAORB::ClassInfo CORBA::FixedDef::_info("FixedDef") ;
    1549                 : 
    1550               0 : CORBA::SequenceDef::SequenceDef()
    1551                 : {}
    1552                 : 
    1553               0 : CORBA::SequenceDef::~SequenceDef()
    1554               0 : {}
    1555                 : 
    1556                 : CORBA::SequenceDef_ptr
    1557               0 : CORBA::SequenceDef::_duplicate(CORBA::SequenceDef_ptr obj)
    1558                 : {
    1559               0 :    if (CORBA::is_nil(obj))
    1560                 :    {
    1561               0 :       return _nil() ;
    1562                 :    }
    1563                 :    else
    1564                 :    {
    1565               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1566                 :       return obj ;
    1567                 :    }
    1568                 : }
    1569                 : 
    1570                 : CORBA::SequenceDef_ptr
    1571               0 : CORBA::SequenceDef::_narrow(CORBA::Object_ptr obj)
    1572                 : {
    1573               0 :    if (CORBA::is_nil(obj))
    1574                 :    {
    1575               0 :       return _nil() ;
    1576                 :    }
    1577                 :    else
    1578                 :    {
    1579               0 :       void *that = NULL ;
    1580               0 :       if (obj->_isA(& _info, that))
    1581                 :       {
    1582                 :          CORBA::SequenceDef_ptr ret ;
    1583               0 :          ret = (CORBA::SequenceDef_ptr) that ;
    1584               0 :          CORBA::Object::_duplicate(obj) ;
    1585               0 :          return ret ;
    1586                 :       }
    1587                 :       else
    1588                 :       {
    1589               0 :          return _nil() ;
    1590                 :       }
    1591                 :    }
    1592                 : }
    1593                 : 
    1594               0 : CORBA::SequenceDef_ptr CORBA::SequenceDef::_nil(void)
    1595                 : {
    1596                 :    return NULL ;
    1597                 : }
    1598                 : 
    1599               0 : CORBA::SequenceDef_ptr CORBA::SequenceDef::_bind(YAORB::CDR* cdrs)
    1600                 : {
    1601               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1602                 : }
    1603                 : 
    1604               0 : const YAORB::ClassInfo* CORBA::SequenceDef::_getInfo(void) const
    1605                 : {
    1606                 :    return & _info ;
    1607                 : }
    1608                 : 
    1609               0 : bool CORBA::SequenceDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1610                 : {
    1611               0 :    if (_info.isEquiv(info))
    1612                 :    {
    1613               0 :       that = (void*) (const void*) this ;
    1614               0 :       return true ;
    1615                 :    }
    1616               0 :    if (CORBA::IDLType::_isA(info, that))
    1617                 :    {
    1618                 :       return true ;
    1619                 :    }
    1620                 :    return false ;
    1621                 : }
    1622                 : 
    1623              49 : const YAORB::ClassInfo CORBA::SequenceDef::_info("SequenceDef") ;
    1624                 : 
    1625               0 : CORBA::ArrayDef::ArrayDef()
    1626                 : {}
    1627                 : 
    1628               0 : CORBA::ArrayDef::~ArrayDef()
    1629               0 : {}
    1630                 : 
    1631                 : CORBA::ArrayDef_ptr
    1632               0 : CORBA::ArrayDef::_duplicate(CORBA::ArrayDef_ptr obj)
    1633                 : {
    1634               0 :    if (CORBA::is_nil(obj))
    1635                 :    {
    1636               0 :       return _nil() ;
    1637                 :    }
    1638                 :    else
    1639                 :    {
    1640               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1641                 :       return obj ;
    1642                 :    }
    1643                 : }
    1644                 : 
    1645                 : CORBA::ArrayDef_ptr
    1646               0 : CORBA::ArrayDef::_narrow(CORBA::Object_ptr obj)
    1647                 : {
    1648               0 :    if (CORBA::is_nil(obj))
    1649                 :    {
    1650               0 :       return _nil() ;
    1651                 :    }
    1652                 :    else
    1653                 :    {
    1654               0 :       void *that = NULL ;
    1655               0 :       if (obj->_isA(& _info, that))
    1656                 :       {
    1657                 :          CORBA::ArrayDef_ptr ret ;
    1658               0 :          ret = (CORBA::ArrayDef_ptr) that ;
    1659               0 :          CORBA::Object::_duplicate(obj) ;
    1660               0 :          return ret ;
    1661                 :       }
    1662                 :       else
    1663                 :       {
    1664               0 :          return _nil() ;
    1665                 :       }
    1666                 :    }
    1667                 : }
    1668                 : 
    1669               0 : CORBA::ArrayDef_ptr CORBA::ArrayDef::_nil(void)
    1670                 : {
    1671                 :    return NULL ;
    1672                 : }
    1673                 : 
    1674               0 : CORBA::ArrayDef_ptr CORBA::ArrayDef::_bind(YAORB::CDR* cdrs)
    1675                 : {
    1676               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1677                 : }
    1678                 : 
    1679               0 : const YAORB::ClassInfo* CORBA::ArrayDef::_getInfo(void) const
    1680                 : {
    1681                 :    return & _info ;
    1682                 : }
    1683                 : 
    1684               0 : bool CORBA::ArrayDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1685                 : {
    1686               0 :    if (_info.isEquiv(info))
    1687                 :    {
    1688               0 :       that = (void*) (const void*) this ;
    1689               0 :       return true ;
    1690                 :    }
    1691               0 :    if (CORBA::IDLType::_isA(info, that))
    1692                 :    {
    1693                 :       return true ;
    1694                 :    }
    1695                 :    return false ;
    1696                 : }
    1697                 : 
    1698              49 : const YAORB::ClassInfo CORBA::ArrayDef::_info("ArrayDef") ;
    1699                 : 
    1700               0 : CORBA::ExceptionDef::ExceptionDef()
    1701                 : {}
    1702                 : 
    1703               0 : CORBA::ExceptionDef::~ExceptionDef()
    1704               0 : {}
    1705                 : 
    1706                 : CORBA::ExceptionDef_ptr
    1707               0 : CORBA::ExceptionDef::_duplicate(CORBA::ExceptionDef_ptr obj)
    1708                 : {
    1709               0 :    if (CORBA::is_nil(obj))
    1710                 :    {
    1711               0 :       return _nil() ;
    1712                 :    }
    1713                 :    else
    1714                 :    {
    1715               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1716                 :       return obj ;
    1717                 :    }
    1718                 : }
    1719                 : 
    1720                 : CORBA::ExceptionDef_ptr
    1721               0 : CORBA::ExceptionDef::_narrow(CORBA::Object_ptr obj)
    1722                 : {
    1723               0 :    if (CORBA::is_nil(obj))
    1724                 :    {
    1725               0 :       return _nil() ;
    1726                 :    }
    1727                 :    else
    1728                 :    {
    1729               0 :       void *that = NULL ;
    1730               0 :       if (obj->_isA(& _info, that))
    1731                 :       {
    1732                 :          CORBA::ExceptionDef_ptr ret ;
    1733               0 :          ret = (CORBA::ExceptionDef_ptr) that ;
    1734               0 :          CORBA::Object::_duplicate(obj) ;
    1735               0 :          return ret ;
    1736                 :       }
    1737                 :       else
    1738                 :       {
    1739               0 :          return _nil() ;
    1740                 :       }
    1741                 :    }
    1742                 : }
    1743                 : 
    1744               0 : CORBA::ExceptionDef_ptr CORBA::ExceptionDef::_nil(void)
    1745                 : {
    1746                 :    return NULL ;
    1747                 : }
    1748                 : 
    1749               0 : CORBA::ExceptionDef_ptr CORBA::ExceptionDef::_bind(YAORB::CDR* cdrs)
    1750                 : {
    1751               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1752                 : }
    1753                 : 
    1754               0 : const YAORB::ClassInfo* CORBA::ExceptionDef::_getInfo(void) const
    1755                 : {
    1756                 :    return & _info ;
    1757                 : }
    1758                 : 
    1759               0 : bool CORBA::ExceptionDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1760                 : {
    1761               0 :    if (_info.isEquiv(info))
    1762                 :    {
    1763               0 :       that = (void*) (const void*) this ;
    1764               0 :       return true ;
    1765                 :    }
    1766               0 :    if (CORBA::Contained::_isA(info, that))
    1767                 :    {
    1768                 :       return true ;
    1769                 :    }
    1770               0 :    if (CORBA::Container::_isA(info, that))
    1771                 :    {
    1772                 :       return true ;
    1773                 :    }
    1774                 :    return false ;
    1775                 : }
    1776                 : 
    1777              49 : const YAORB::ClassInfo CORBA::ExceptionDef::_info("ExceptionDef") ;
    1778                 : 
    1779               0 : void CORBA::ExceptionDescription::cdr(YAORB::CDR* __cdrs)
    1780                 : {
    1781               0 :    name.cdr(__cdrs) ;
    1782               0 :    id.cdr(__cdrs) ;
    1783               0 :    defined_in.cdr(__cdrs) ;
    1784               0 :    version.cdr(__cdrs) ;
    1785               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    1786               0 : type = CORBA::TypeCode::_nil() ;
    1787                 : }
    1788                 : 
    1789               0 : void CORBA::CDR_AttributeMode(YAORB::CDR *cdrs, CORBA::AttributeMode *e)
    1790                 : {
    1791                 :    CORBA::ULong value ;
    1792               0 :    switch (cdrs->Op())
    1793                 :    {
    1794                 :       case YAORB::CDR_READ:
    1795                 :       {
    1796               0 :          cdrs->cdr_ULong(& value) ;
    1797               0 :          *e = (CORBA::AttributeMode) value ;
    1798               0 :          break ;
    1799                 :       }
    1800                 :       case YAORB::CDR_WRITE:
    1801                 :       {
    1802               0 :          value = (CORBA::ULong) (*e) ;
    1803               0 :          cdrs->cdr_ULong(& value) ;
    1804                 :          break ;
    1805                 :       }
    1806                 :    }
    1807                 : }
    1808                 : 
    1809               0 : CORBA::AttributeDef::AttributeDef()
    1810                 : {}
    1811                 : 
    1812               0 : CORBA::AttributeDef::~AttributeDef()
    1813               0 : {}
    1814                 : 
    1815                 : CORBA::AttributeDef_ptr
    1816               0 : CORBA::AttributeDef::_duplicate(CORBA::AttributeDef_ptr obj)
    1817                 : {
    1818               0 :    if (CORBA::is_nil(obj))
    1819                 :    {
    1820               0 :       return _nil() ;
    1821                 :    }
    1822                 :    else
    1823                 :    {
    1824               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1825                 :       return obj ;
    1826                 :    }
    1827                 : }
    1828                 : 
    1829                 : CORBA::AttributeDef_ptr
    1830               0 : CORBA::AttributeDef::_narrow(CORBA::Object_ptr obj)
    1831                 : {
    1832               0 :    if (CORBA::is_nil(obj))
    1833                 :    {
    1834               0 :       return _nil() ;
    1835                 :    }
    1836                 :    else
    1837                 :    {
    1838               0 :       void *that = NULL ;
    1839               0 :       if (obj->_isA(& _info, that))
    1840                 :       {
    1841                 :          CORBA::AttributeDef_ptr ret ;
    1842               0 :          ret = (CORBA::AttributeDef_ptr) that ;
    1843               0 :          CORBA::Object::_duplicate(obj) ;
    1844               0 :          return ret ;
    1845                 :       }
    1846                 :       else
    1847                 :       {
    1848               0 :          return _nil() ;
    1849                 :       }
    1850                 :    }
    1851                 : }
    1852                 : 
    1853               0 : CORBA::AttributeDef_ptr CORBA::AttributeDef::_nil(void)
    1854                 : {
    1855                 :    return NULL ;
    1856                 : }
    1857                 : 
    1858               0 : CORBA::AttributeDef_ptr CORBA::AttributeDef::_bind(YAORB::CDR* cdrs)
    1859                 : {
    1860               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1861                 : }
    1862                 : 
    1863               0 : const YAORB::ClassInfo* CORBA::AttributeDef::_getInfo(void) const
    1864                 : {
    1865                 :    return & _info ;
    1866                 : }
    1867                 : 
    1868               0 : bool CORBA::AttributeDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    1869                 : {
    1870               0 :    if (_info.isEquiv(info))
    1871                 :    {
    1872               0 :       that = (void*) (const void*) this ;
    1873               0 :       return true ;
    1874                 :    }
    1875               0 :    if (CORBA::Contained::_isA(info, that))
    1876                 :    {
    1877                 :       return true ;
    1878                 :    }
    1879                 :    return false ;
    1880                 : }
    1881                 : 
    1882              49 : const YAORB::ClassInfo CORBA::AttributeDef::_info("AttributeDef") ;
    1883                 : 
    1884               0 : void CORBA::AttributeDescription::cdr(YAORB::CDR* __cdrs)
    1885                 : {
    1886               0 :    name.cdr(__cdrs) ;
    1887               0 :    id.cdr(__cdrs) ;
    1888               0 :    defined_in.cdr(__cdrs) ;
    1889               0 :    version.cdr(__cdrs) ;
    1890               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    1891               0 : type = CORBA::TypeCode::_nil() ;
    1892               0 :    CORBA::CDR_AttributeMode(__cdrs, & mode) ;
    1893                 : }
    1894                 : 
    1895               0 : void CORBA::CDR_OperationMode(YAORB::CDR *cdrs, CORBA::OperationMode *e)
    1896                 : {
    1897                 :    CORBA::ULong value ;
    1898               0 :    switch (cdrs->Op())
    1899                 :    {
    1900                 :       case YAORB::CDR_READ:
    1901                 :       {
    1902               0 :          cdrs->cdr_ULong(& value) ;
    1903               0 :          *e = (CORBA::OperationMode) value ;
    1904               0 :          break ;
    1905                 :       }
    1906                 :       case YAORB::CDR_WRITE:
    1907                 :       {
    1908               0 :          value = (CORBA::ULong) (*e) ;
    1909               0 :          cdrs->cdr_ULong(& value) ;
    1910                 :          break ;
    1911                 :       }
    1912                 :    }
    1913                 : }
    1914                 : 
    1915               0 : void CORBA::CDR_ParameterMode(YAORB::CDR *cdrs, CORBA::ParameterMode *e)
    1916                 : {
    1917                 :    CORBA::ULong value ;
    1918               0 :    switch (cdrs->Op())
    1919                 :    {
    1920                 :       case YAORB::CDR_READ:
    1921                 :       {
    1922               0 :          cdrs->cdr_ULong(& value) ;
    1923               0 :          *e = (CORBA::ParameterMode) value ;
    1924               0 :          break ;
    1925                 :       }
    1926                 :       case YAORB::CDR_WRITE:
    1927                 :       {
    1928               0 :          value = (CORBA::ULong) (*e) ;
    1929               0 :          cdrs->cdr_ULong(& value) ;
    1930                 :          break ;
    1931                 :       }
    1932                 :    }
    1933                 : }
    1934                 : 
    1935               0 : void CORBA::ParameterDescription::cdr(YAORB::CDR* __cdrs)
    1936                 : {
    1937               0 :    name.cdr(__cdrs) ;
    1938               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    1939               0 : type = CORBA::TypeCode::_nil() ;
    1940               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    1941               0 : type_def = CORBA::IDLType::_nil() ;
    1942               0 :    CORBA::CDR_ParameterMode(__cdrs, & mode) ;
    1943                 : }
    1944                 : 
    1945               0 : CORBA::OperationDef::OperationDef()
    1946                 : {}
    1947                 : 
    1948               0 : CORBA::OperationDef::~OperationDef()
    1949               0 : {}
    1950                 : 
    1951                 : CORBA::OperationDef_ptr
    1952               0 : CORBA::OperationDef::_duplicate(CORBA::OperationDef_ptr obj)
    1953                 : {
    1954               0 :    if (CORBA::is_nil(obj))
    1955                 :    {
    1956               0 :       return _nil() ;
    1957                 :    }
    1958                 :    else
    1959                 :    {
    1960               0 :       (void) CORBA::Object::_duplicate(obj) ;
    1961                 :       return obj ;
    1962                 :    }
    1963                 : }
    1964                 : 
    1965                 : CORBA::OperationDef_ptr
    1966               0 : CORBA::OperationDef::_narrow(CORBA::Object_ptr obj)
    1967                 : {
    1968               0 :    if (CORBA::is_nil(obj))
    1969                 :    {
    1970               0 :       return _nil() ;
    1971                 :    }
    1972                 :    else
    1973                 :    {
    1974               0 :       void *that = NULL ;
    1975               0 :       if (obj->_isA(& _info, that))
    1976                 :       {
    1977                 :          CORBA::OperationDef_ptr ret ;
    1978               0 :          ret = (CORBA::OperationDef_ptr) that ;
    1979               0 :          CORBA::Object::_duplicate(obj) ;
    1980               0 :          return ret ;
    1981                 :       }
    1982                 :       else
    1983                 :       {
    1984               0 :          return _nil() ;
    1985                 :       }
    1986                 :    }
    1987                 : }
    1988                 : 
    1989               0 : CORBA::OperationDef_ptr CORBA::OperationDef::_nil(void)
    1990                 : {
    1991                 :    return NULL ;
    1992                 : }
    1993                 : 
    1994               0 : CORBA::OperationDef_ptr CORBA::OperationDef::_bind(YAORB::CDR* cdrs)
    1995                 : {
    1996               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    1997                 : }
    1998                 : 
    1999               0 : const YAORB::ClassInfo* CORBA::OperationDef::_getInfo(void) const
    2000                 : {
    2001                 :    return & _info ;
    2002                 : }
    2003                 : 
    2004               0 : bool CORBA::OperationDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    2005                 : {
    2006               0 :    if (_info.isEquiv(info))
    2007                 :    {
    2008               0 :       that = (void*) (const void*) this ;
    2009               0 :       return true ;
    2010                 :    }
    2011               0 :    if (CORBA::Contained::_isA(info, that))
    2012                 :    {
    2013                 :       return true ;
    2014                 :    }
    2015                 :    return false ;
    2016                 : }
    2017                 : 
    2018              49 : const YAORB::ClassInfo CORBA::OperationDef::_info("OperationDef") ;
    2019                 : 
    2020               0 : void CORBA::OperationDescription::cdr(YAORB::CDR* __cdrs)
    2021                 : {
    2022               0 :    name.cdr(__cdrs) ;
    2023               0 :    id.cdr(__cdrs) ;
    2024               0 :    defined_in.cdr(__cdrs) ;
    2025               0 :    version.cdr(__cdrs) ;
    2026               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    2027               0 : result = CORBA::TypeCode::_nil() ;
    2028               0 :    CORBA::CDR_OperationMode(__cdrs, & mode) ;
    2029                 :    contexts.cdr(__cdrs) ;
    2030                 :    parameters.cdr(__cdrs) ;
    2031                 :    exceptions.cdr(__cdrs) ;
    2032                 : }
    2033                 : 
    2034               0 : CORBA::InterfaceDef::InterfaceDef()
    2035                 : {}
    2036                 : 
    2037               0 : CORBA::InterfaceDef::~InterfaceDef()
    2038               0 : {}
    2039                 : 
    2040                 : CORBA::InterfaceDef_ptr
    2041               0 : CORBA::InterfaceDef::_duplicate(CORBA::InterfaceDef_ptr obj)
    2042                 : {
    2043               0 :    if (CORBA::is_nil(obj))
    2044                 :    {
    2045               0 :       return _nil() ;
    2046                 :    }
    2047                 :    else
    2048                 :    {
    2049               0 :       (void) CORBA::Object::_duplicate(obj) ;
    2050                 :       return obj ;
    2051                 :    }
    2052                 : }
    2053                 : 
    2054                 : CORBA::InterfaceDef_ptr
    2055               0 : CORBA::InterfaceDef::_narrow(CORBA::Object_ptr obj)
    2056                 : {
    2057               0 :    if (CORBA::is_nil(obj))
    2058                 :    {
    2059               0 :       return _nil() ;
    2060                 :    }
    2061                 :    else
    2062                 :    {
    2063               0 :       void *that = NULL ;
    2064               0 :       if (obj->_isA(& _info, that))
    2065                 :       {
    2066                 :          CORBA::InterfaceDef_ptr ret ;
    2067               0 :          ret = (CORBA::InterfaceDef_ptr) that ;
    2068               0 :          CORBA::Object::_duplicate(obj) ;
    2069               0 :          return ret ;
    2070                 :       }
    2071                 :       else
    2072                 :       {
    2073               0 :          return _nil() ;
    2074                 :       }
    2075                 :    }
    2076                 : }
    2077                 : 
    2078               0 : CORBA::InterfaceDef_ptr CORBA::InterfaceDef::_nil(void)
    2079                 : {
    2080                 :    return NULL ;
    2081                 : }
    2082                 : 
    2083               0 : CORBA::InterfaceDef_ptr CORBA::InterfaceDef::_bind(YAORB::CDR* cdrs)
    2084                 : {
    2085               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    2086                 : }
    2087                 : 
    2088               0 : const YAORB::ClassInfo* CORBA::InterfaceDef::_getInfo(void) const
    2089                 : {
    2090                 :    return & _info ;
    2091                 : }
    2092                 : 
    2093               0 : bool CORBA::InterfaceDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    2094                 : {
    2095               0 :    if (_info.isEquiv(info))
    2096                 :    {
    2097               0 :       that = (void*) (const void*) this ;
    2098               0 :       return true ;
    2099                 :    }
    2100               0 :    if (CORBA::Container::_isA(info, that))
    2101                 :    {
    2102                 :       return true ;
    2103                 :    }
    2104               0 :    if (CORBA::Contained::_isA(info, that))
    2105                 :    {
    2106                 :       return true ;
    2107                 :    }
    2108               0 :    if (CORBA::IDLType::_isA(info, that))
    2109                 :    {
    2110                 :       return true ;
    2111                 :    }
    2112                 :    return false ;
    2113                 : }
    2114                 : 
    2115              49 : const YAORB::ClassInfo CORBA::InterfaceDef::_info("InterfaceDef") ;
    2116                 : 
    2117               0 : void CORBA::InterfaceDef::FullInterfaceDescription::cdr(YAORB::CDR* __cdrs)
    2118                 : {
    2119               0 :    name.cdr(__cdrs) ;
    2120               0 :    id.cdr(__cdrs) ;
    2121               0 :    defined_in.cdr(__cdrs) ;
    2122               0 :    version.cdr(__cdrs) ;
    2123                 :    operations.cdr(__cdrs) ;
    2124                 :    attributes.cdr(__cdrs) ;
    2125                 :    base_interfaces.cdr(__cdrs) ;
    2126               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    2127               0 : type = CORBA::TypeCode::_nil() ;
    2128               0 :    __cdrs->cdr_Boolean( & is_abstract) ;
    2129                 : }
    2130                 : 
    2131               0 : void CORBA::InterfaceDescription::cdr(YAORB::CDR* __cdrs)
    2132                 : {
    2133               0 :    name.cdr(__cdrs) ;
    2134               0 :    id.cdr(__cdrs) ;
    2135               0 :    defined_in.cdr(__cdrs) ;
    2136               0 :    version.cdr(__cdrs) ;
    2137                 :    base_interfaces.cdr(__cdrs) ;
    2138               0 :    __cdrs->cdr_Boolean( & is_abstract) ;
    2139                 : }
    2140                 : 
    2141               0 : void CORBA::ValueMember::cdr(YAORB::CDR* __cdrs)
    2142                 : {
    2143               0 :    name.cdr(__cdrs) ;
    2144               0 :    id.cdr(__cdrs) ;
    2145               0 :    defined_in.cdr(__cdrs) ;
    2146               0 :    version.cdr(__cdrs) ;
    2147               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    2148               0 : type = CORBA::TypeCode::_nil() ;
    2149               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    2150               0 : type_def = CORBA::IDLType::_nil() ;
    2151               0 :    __cdrs->cdr_Short(& access) ;
    2152                 : }
    2153                 : 
    2154               0 : CORBA::ValueMemberDef::ValueMemberDef()
    2155                 : {}
    2156                 : 
    2157               0 : CORBA::ValueMemberDef::~ValueMemberDef()
    2158               0 : {}
    2159                 : 
    2160                 : CORBA::ValueMemberDef_ptr
    2161               0 : CORBA::ValueMemberDef::_duplicate(CORBA::ValueMemberDef_ptr obj)
    2162                 : {
    2163               0 :    if (CORBA::is_nil(obj))
    2164                 :    {
    2165               0 :       return _nil() ;
    2166                 :    }
    2167                 :    else
    2168                 :    {
    2169               0 :       (void) CORBA::Object::_duplicate(obj) ;
    2170                 :       return obj ;
    2171                 :    }
    2172                 : }
    2173                 : 
    2174                 : CORBA::ValueMemberDef_ptr
    2175               0 : CORBA::ValueMemberDef::_narrow(CORBA::Object_ptr obj)
    2176                 : {
    2177               0 :    if (CORBA::is_nil(obj))
    2178                 :    {
    2179               0 :       return _nil() ;
    2180                 :    }
    2181                 :    else
    2182                 :    {
    2183               0 :       void *that = NULL ;
    2184               0 :       if (obj->_isA(& _info, that))
    2185                 :       {
    2186                 :          CORBA::ValueMemberDef_ptr ret ;
    2187               0 :          ret = (CORBA::ValueMemberDef_ptr) that ;
    2188               0 :          CORBA::Object::_duplicate(obj) ;
    2189               0 :          return ret ;
    2190                 :       }
    2191                 :       else
    2192                 :       {
    2193               0 :          return _nil() ;
    2194                 :       }
    2195                 :    }
    2196                 : }
    2197                 : 
    2198               0 : CORBA::ValueMemberDef_ptr CORBA::ValueMemberDef::_nil(void)
    2199                 : {
    2200                 :    return NULL ;
    2201                 : }
    2202                 : 
    2203               0 : CORBA::ValueMemberDef_ptr CORBA::ValueMemberDef::_bind(YAORB::CDR* cdrs)
    2204                 : {
    2205               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    2206                 : }
    2207                 : 
    2208               0 : const YAORB::ClassInfo* CORBA::ValueMemberDef::_getInfo(void) const
    2209                 : {
    2210                 :    return & _info ;
    2211                 : }
    2212                 : 
    2213               0 : bool CORBA::ValueMemberDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    2214                 : {
    2215               0 :    if (_info.isEquiv(info))
    2216                 :    {
    2217               0 :       that = (void*) (const void*) this ;
    2218               0 :       return true ;
    2219                 :    }
    2220               0 :    if (CORBA::Contained::_isA(info, that))
    2221                 :    {
    2222                 :       return true ;
    2223                 :    }
    2224                 :    return false ;
    2225                 : }
    2226                 : 
    2227              49 : const YAORB::ClassInfo CORBA::ValueMemberDef::_info("ValueMemberDef") ;
    2228                 : 
    2229               0 : CORBA::ValueDef::ValueDef()
    2230                 : {}
    2231                 : 
    2232               0 : CORBA::ValueDef::~ValueDef()
    2233               0 : {}
    2234                 : 
    2235                 : CORBA::ValueDef_ptr
    2236               0 : CORBA::ValueDef::_duplicate(CORBA::ValueDef_ptr obj)
    2237                 : {
    2238               0 :    if (CORBA::is_nil(obj))
    2239                 :    {
    2240               0 :       return _nil() ;
    2241                 :    }
    2242                 :    else
    2243                 :    {
    2244               0 :       (void) CORBA::Object::_duplicate(obj) ;
    2245                 :       return obj ;
    2246                 :    }
    2247                 : }
    2248                 : 
    2249                 : CORBA::ValueDef_ptr
    2250               0 : CORBA::ValueDef::_narrow(CORBA::Object_ptr obj)
    2251                 : {
    2252               0 :    if (CORBA::is_nil(obj))
    2253                 :    {
    2254               0 :       return _nil() ;
    2255                 :    }
    2256                 :    else
    2257                 :    {
    2258               0 :       void *that = NULL ;
    2259               0 :       if (obj->_isA(& _info, that))
    2260                 :       {
    2261                 :          CORBA::ValueDef_ptr ret ;
    2262               0 :          ret = (CORBA::ValueDef_ptr) that ;
    2263               0 :          CORBA::Object::_duplicate(obj) ;
    2264               0 :          return ret ;
    2265                 :       }
    2266                 :       else
    2267                 :       {
    2268               0 :          return _nil() ;
    2269                 :       }
    2270                 :    }
    2271                 : }
    2272                 : 
    2273               0 : CORBA::ValueDef_ptr CORBA::ValueDef::_nil(void)
    2274                 : {
    2275                 :    return NULL ;
    2276                 : }
    2277                 : 
    2278               0 : CORBA::ValueDef_ptr CORBA::ValueDef::_bind(YAORB::CDR* cdrs)
    2279                 : {
    2280               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    2281                 : }
    2282                 : 
    2283               0 : const YAORB::ClassInfo* CORBA::ValueDef::_getInfo(void) const
    2284                 : {
    2285                 :    return & _info ;
    2286                 : }
    2287                 : 
    2288               0 : bool CORBA::ValueDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    2289                 : {
    2290               0 :    if (_info.isEquiv(info))
    2291                 :    {
    2292               0 :       that = (void*) (const void*) this ;
    2293               0 :       return true ;
    2294                 :    }
    2295               0 :    if (CORBA::Container::_isA(info, that))
    2296                 :    {
    2297                 :       return true ;
    2298                 :    }
    2299               0 :    if (CORBA::Contained::_isA(info, that))
    2300                 :    {
    2301                 :       return true ;
    2302                 :    }
    2303               0 :    if (CORBA::IDLType::_isA(info, that))
    2304                 :    {
    2305                 :       return true ;
    2306                 :    }
    2307                 :    return false ;
    2308                 : }
    2309                 : 
    2310              49 : const YAORB::ClassInfo CORBA::ValueDef::_info("ValueDef") ;
    2311                 : 
    2312               0 : void CORBA::ValueDef::FullValueDescription::cdr(YAORB::CDR* __cdrs)
    2313                 : {
    2314               0 :    name.cdr(__cdrs) ;
    2315               0 :    id.cdr(__cdrs) ;
    2316               0 :    __cdrs->cdr_Boolean( & is_abstract) ;
    2317               0 :    __cdrs->cdr_Boolean( & is_custom) ;
    2318               0 :    defined_in.cdr(__cdrs) ;
    2319               0 :    version.cdr(__cdrs) ;
    2320                 :    operations.cdr(__cdrs) ;
    2321                 :    attributes.cdr(__cdrs) ;
    2322                 :    members.cdr(__cdrs) ;
    2323                 :    initializers.cdr(__cdrs) ;
    2324                 :    supported_interfaces.cdr(__cdrs) ;
    2325                 :    abstract_base_values.cdr(__cdrs) ;
    2326               0 :    __cdrs->cdr_Boolean( & is_truncatable) ;
    2327               0 :    base_value.cdr(__cdrs) ;
    2328               0 :    NON_DEV("LangCpp::PrintCDRInterface") ;
    2329               0 : type = CORBA::TypeCode::_nil() ;
    2330                 : }
    2331                 : 
    2332               0 : void CORBA::ValueDescription::cdr(YAORB::CDR* __cdrs)
    2333                 : {
    2334               0 :    name.cdr(__cdrs) ;
    2335               0 :    id.cdr(__cdrs) ;
    2336               0 :    __cdrs->cdr_Boolean( & is_abstract) ;
    2337               0 :    __cdrs->cdr_Boolean( & is_custom) ;
    2338               0 :    defined_in.cdr(__cdrs) ;
    2339               0 :    version.cdr(__cdrs) ;
    2340                 :    supported_interfaces.cdr(__cdrs) ;
    2341                 :    abstract_base_values.cdr(__cdrs) ;
    2342               0 :    __cdrs->cdr_Boolean( & is_truncatable) ;
    2343               0 :    base_value.cdr(__cdrs) ;
    2344                 : }
    2345                 : 
    2346               0 : CORBA::ValueBoxDef::ValueBoxDef()
    2347                 : {}
    2348                 : 
    2349               0 : CORBA::ValueBoxDef::~ValueBoxDef()
    2350               0 : {}
    2351                 : 
    2352                 : CORBA::ValueBoxDef_ptr
    2353               0 : CORBA::ValueBoxDef::_duplicate(CORBA::ValueBoxDef_ptr obj)
    2354                 : {
    2355               0 :    if (CORBA::is_nil(obj))
    2356                 :    {
    2357               0 :       return _nil() ;
    2358                 :    }
    2359                 :    else
    2360                 :    {
    2361               0 :       (void) CORBA::Object::_duplicate(obj) ;
    2362                 :       return obj ;
    2363                 :    }
    2364                 : }
    2365                 : 
    2366                 : CORBA::ValueBoxDef_ptr
    2367               0 : CORBA::ValueBoxDef::_narrow(CORBA::Object_ptr obj)
    2368                 : {
    2369               0 :    if (CORBA::is_nil(obj))
    2370                 :    {
    2371               0 :       return _nil() ;
    2372                 :    }
    2373                 :    else
    2374                 :    {
    2375               0 :       void *that = NULL ;
    2376               0 :       if (obj->_isA(& _info, that))
    2377                 :       {
    2378                 :          CORBA::ValueBoxDef_ptr ret ;
    2379               0 :          ret = (CORBA::ValueBoxDef_ptr) that ;
    2380               0 :          CORBA::Object::_duplicate(obj) ;
    2381               0 :          return ret ;
    2382                 :       }
    2383                 :       else
    2384                 :       {
    2385               0 :          return _nil() ;
    2386                 :       }
    2387                 :    }
    2388                 : }
    2389                 : 
    2390               0 : CORBA::ValueBoxDef_ptr CORBA::ValueBoxDef::_nil(void)
    2391                 : {
    2392                 :    return NULL ;
    2393                 : }
    2394                 : 
    2395               0 : CORBA::ValueBoxDef_ptr CORBA::ValueBoxDef::_bind(YAORB::CDR* cdrs)
    2396                 : {
    2397               0 :    return _narrow(CORBA::Object::_bind(cdrs)) ;
    2398                 : }
    2399                 : 
    2400               0 : const YAORB::ClassInfo* CORBA::ValueBoxDef::_getInfo(void) const
    2401                 : {
    2402                 :    return & _info ;
    2403                 : }
    2404                 : 
    2405               0 : bool CORBA::ValueBoxDef::_isA(const YAORB::ClassInfo* info, void*& that) const
    2406                 : {
    2407               0 :    if (_info.isEquiv(info))
    2408                 :    {
    2409               0 :       that = (void*) (const void*) this ;
    2410               0 :       return true ;
    2411                 :    }
    2412               0 :    if (CORBA::TypedefDef::_isA(info, that))
    2413                 :    {
    2414                 :       return true ;
    2415                 :    }
    2416                 :    return false ;
    2417                 : }
    2418                 : 
    2419              49 : const YAORB::ClassInfo CORBA::ValueBoxDef::_info("ValueBoxDef") ;
    2420                 : 
    2421               0 : void CORBA::CDR_TCKind(YAORB::CDR *cdrs, CORBA::TCKind *e)
    2422                 : {
    2423                 :    CORBA::ULong value ;
    2424               0 :    switch (cdrs->Op())
    2425                 :    {
    2426                 :       case YAORB::CDR_READ:
    2427                 :       {
    2428               0 :          cdrs->cdr_ULong(& value) ;
    2429               0 :          *e = (CORBA::TCKind) value ;
    2430               0 :          break ;
    2431                 :       }
    2432                 :       case YAORB::CDR_WRITE:
    2433                 :       {
    2434               0 :          value = (CORBA::ULong) (*e) ;
    2435               0 :          cdrs->cdr_ULong(& value) ;
    2436                 :          break ;
    2437                 :       }
    2438                 :    }
    2439                 : }
    2440                 : 
    2441               0 : CORBA::TypeCode_ptr CORBA::TypeCode::_nil(void)
    2442                 : {
    2443                 :    return NULL ;
    2444                 : }
    2445                 : 
    2446                 : 
    2447               0 : CORBA::TypeCode::Bounds::Bounds()
    2448               0 : : CORBA::UserException()
    2449                 : {}
    2450                 : 
    2451               0 : CORBA::TypeCode::Bounds::Bounds(const CORBA::TypeCode::Bounds& except)
    2452               0 : : CORBA::UserException(except)
    2453                 : {}
    2454                 : 
    2455               0 : CORBA::TypeCode::Bounds::~Bounds()
    2456               0 : {}
    2457                 : 
    2458               0 : void CORBA::TypeCode::Bounds::_raise(void) const
    2459                 : {
    2460               0 :    throw *this ;
    2461                 : }
    2462                 : 
    2463               0 : CORBA::TypeCode::BadKind::BadKind()
    2464               0 : : CORBA::UserException()
    2465                 : {}
    2466                 : 
    2467               0 : CORBA::TypeCode::BadKind::BadKind(const CORBA::TypeCode::BadKind& except)
    2468               0 : : CORBA::UserException(except)
    2469                 : {}
    2470                 : 
    2471               0 : CORBA::TypeCode::BadKind::~BadKind()
    2472               0 : {}
    2473                 : 
    2474               0 : void CORBA::TypeCode::BadKind::_raise(void) const
    2475                 : {
    2476               0 :    throw *this ;
    2477                 : }
    2478                 : 
    2479               2 : CORBA::ORB_ptr CORBA::ORB::_nil(void)
    2480                 : {
    2481                 :    return NULL ;
    2482                 : }
    2483                 : 
    2484                 : 
    2485               0 : CORBA::Environment_ptr CORBA::Environment::_nil(void)
    2486                 : {
    2487                 :    return NULL ;
    2488              49 : }
    2489              49 : 
    2490               0 : 

Generated by: LTP GCOV extension version 1.4