stoc/source/tdmanager/tdmgr_check.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: tdmgr_check.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_stoc.hxx"
  33
  34 #include "tdmgr_common.hxx"
  35 #include "rtl/ustrbuf.hxx"
  36 #include "typelib/typedescription.h"
  37 #include "com/sun/star/beans/PropertyAttribute.hpp"
  38 #include "com/sun/star/reflection/XConstantsTypeDescription.hpp"
  39 #include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
  40 #include "com/sun/star/reflection/XEnumTypeDescription.hpp"
  41 #include "com/sun/star/reflection/XStructTypeDescription.hpp"
  42 #include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
  43 #include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
  44 #include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
  45 #include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
  46 #include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
  47
  48
  49 using ::rtl::OUString;
  50 using ::rtl::OUStringBuffer;
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::stoc_tdmgr;
  54
  55 namespace {
  56
  57 OUString getTypeClassName( TypeClass tc )
  58 {
  59     typelib_EnumTypeDescription * typeDescr = 0;
  60     OUString name = OUSTR("com.sun.star.uno.TypeClass");
  61     typelib_typedescription_getByName(
  62         reinterpret_cast<typelib_TypeDescription **>(&typeDescr), name.pData );
  63     OSL_ASSERT( typeDescr != 0 );
  64     if (typeDescr == 0)
  65         return OUSTR("Cannot get type description of ") + name;
  66     typelib_typedescription_complete(
  67         reinterpret_cast<typelib_TypeDescription **>(&typeDescr) );
  68
  69     sal_Int32 const * pValues = typeDescr->pEnumValues;
  70     sal_Int32 nPos = typeDescr->nEnumValues;
  71     while (nPos--)
  72     {
  73         if (pValues[ nPos ] == (sal_Int32) tc)
  74             break;
  75     }
  76     if (nPos >= 0)
  77         name = typeDescr->ppEnumNames[ nPos ];
  78     else
  79         name = OUSTR("unknown TypeClass value: ") +
  80             OUString::valueOf( (sal_Int32) tc );
  81
  82     typelib_typedescription_release(
  83         reinterpret_cast<typelib_TypeDescription *>(typeDescr) );
  84     return name;
  85 }
  86
  87 OUString getPropertyFlagsAsString( sal_Int16 attributes )
  88 {
  89     OUStringBuffer buf;
  90     if ((attributes & beans::PropertyAttribute::MAYBEVOID) != 0)
  91         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEVOID, ") );
  92     if ((attributes & beans::PropertyAttribute::BOUND) != 0)
  93         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("BOUND, ") );
  94     if ((attributes & beans::PropertyAttribute::CONSTRAINED) != 0)
  95         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("CONSTRAINED, ") );
  96     if ((attributes & beans::PropertyAttribute::TRANSIENT) != 0)
  97         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("TRANSIENT, ") );
  98     if ((attributes & beans::PropertyAttribute::READONLY) != 0)
  99         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("READONLY, ") );
 100     if ((attributes & beans::PropertyAttribute::MAYBEAMBIGUOUS) != 0)
 101         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEAMBIGUOUS, ") );
 102     if ((attributes & beans::PropertyAttribute::MAYBEDEFAULT) != 0)
 103         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEDEFAULT, ") );
 104     if ((attributes & beans::PropertyAttribute::REMOVEABLE) != 0)
 105         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("REMOVEABLE, ") );
 106     if ((attributes & beans::PropertyAttribute::OPTIONAL) != 0)
 107         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("OPTIONAL") );
 108     else if (buf.getLength() > 0)
 109         buf.setLength( buf.getLength() - 2 ); // truncate ", "
 110     return buf.makeStringAndClear();
 111 }
 112
 113 void typeError( OUString const & msg, OUString const & context )
 114 {
 115     OUStringBuffer buf;
 116     if (context.getLength() > 0) {
 117         buf.append( static_cast<sal_Unicode>('[') );
 118         buf.append( context );
 119         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("] ") );
 120     }
 121     buf.append( msg );
 122     throw IncompatibleTypeException( buf.makeStringAndClear() );
 123 }
 124
 125 template<typename T>
 126 void checkSeq( Sequence< Reference<T> > const & newTypes,
 127             Sequence< Reference<T> > const & existingTypes,
 128             OUString const & context,
 129             bool optionalMode = false )
 130 {
 131     sal_Int32 len = newTypes.getLength();
 132     if (len != existingTypes.getLength())
 133     {
 134         if (!optionalMode || len < newTypes.getLength())
 135             typeError( OUSTR("Different number of types!"), context );
 136         len = existingTypes.getLength();
 137     }
 138
 139     Reference<T> const * pNewTypes = newTypes.getConstArray();
 140     Reference<T> const * pExistingTypes = existingTypes.getConstArray();
 141     for ( sal_Int32 pos = 0; pos < len; ++pos )
 142     {
 143         OUStringBuffer buf;
 144         buf.append( context );
 145         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", position ") );
 146         buf.append( pos );
 147         check( pNewTypes[pos].get(), pExistingTypes[pos].get(),
 148                buf.makeStringAndClear() );
 149     }
 150 }
 151
 152 void checkEnum(
 153     Reference<reflection::XEnumTypeDescription> const & xNewTD,
 154     Reference<reflection::XEnumTypeDescription> const & xExistingTD )
 155 {
 156     if (xNewTD->getEnumNames() != xExistingTD->getEnumNames())
 157         typeError( OUSTR("ENUM names don't match!"), xNewTD->getName() );
 158     if (xNewTD->getEnumValues() != xExistingTD->getEnumValues())
 159         typeError( OUSTR("ENUM values don't match!"), xNewTD->getName() );
 160 }
 161
 162 void checkStruct(
 163     Reference<reflection::XCompoundTypeDescription> const & xNewTD,
 164     Reference<reflection::XCompoundTypeDescription> const & xExistingTD )
 165 {
 166     check( xNewTD->getBaseType(), xExistingTD->getBaseType(),
 167            xNewTD->getName() + OUSTR(", base type") );
 168     checkSeq( xNewTD->getMemberTypes(), xExistingTD->getMemberTypes(),
 169               xNewTD->getName() + OUSTR(", member types") );
 170
 171     if (xNewTD->getMemberNames() != xExistingTD->getMemberNames())
 172         typeError( OUSTR("Different member names!"), xNewTD->getName() );
 173
 174     if (xNewTD->getTypeClass() == TypeClass_STRUCT)
 175     {
 176         Reference<reflection::XStructTypeDescription> xNewStructTD(
 177             xNewTD, UNO_QUERY );
 178         Reference<reflection::XStructTypeDescription> xExistingStructTD(
 179             xExistingTD, UNO_QUERY );
 180         if (xNewStructTD.is() && xExistingStructTD.is())
 181         {
 182             if (xNewStructTD->getTypeParameters() !=
 183                 xExistingStructTD->getTypeParameters())
 184                 typeError( OUSTR("Different type parameters of instantiated "
 185                                  "polymorphic STRUCT!"), xNewTD->getName() );
 186             checkSeq( xNewStructTD->getTypeArguments(),
 187                       xExistingStructTD->getTypeArguments(),
 188                       xNewTD->getName() + OUSTR(", argument types") );
 189         }
 190         else if (xNewStructTD.is() || xExistingStructTD.is())
 191             typeError( OUSTR("Mixing polymorphic STRUCT types "
 192                              "with non-polymorphic!"), xNewTD->getName() );
 193     }
 194 }
 195
 196 void checkInterface(
 197     Reference<reflection::XInterfaceTypeDescription2> const & xNewTD,
 198     Reference<reflection::XInterfaceTypeDescription2> const & xExistingTD )
 199 {
 200     checkSeq( xNewTD->getBaseTypes(), xExistingTD->getBaseTypes(),
 201               xNewTD->getName() + OUSTR(", base types") );
 202     checkSeq(xNewTD->getOptionalBaseTypes(),xExistingTD->getOptionalBaseTypes(),
 203              xNewTD->getName() + OUSTR(", optional base types") );
 204     checkSeq( xNewTD->getMembers(), xExistingTD->getMembers(),
 205               xNewTD->getName() + OUSTR(", members") );
 206 }
 207
 208 void checkRestParam( Reference<reflection::XParameter> const & xNewParam,
 209                      Reference<reflection::XParameter> const & xExistingParam,
 210                      OUString const & context )
 211 {
 212     if (xNewParam->isRestParameter() != xExistingParam->isRestParameter())
 213         typeError( OUSTR("Different ... parameters specified!"), context );
 214 }
 215
 216 void checkRestParam( Reference<reflection::XMethodParameter> const &,
 217                      Reference<reflection::XMethodParameter> const &,
 218                      OUString const & )
 219 {
 220 }
 221
 222 template<typename T>
 223 void checkParameters( Sequence< Reference<T> > const & newParams,
 224                       Sequence< Reference<T> > const & existingParams,
 225                       OUString const & context_ )
 226 {
 227     sal_Int32 len = newParams.getLength();
 228     if (len != existingParams.getLength())
 229         typeError( OUSTR("Different number of parameters!"), context_ );
 230     Reference<T> const * pNewParams = newParams.getConstArray();
 231     Reference<T> const * pExistingParams = existingParams.getConstArray();
 232     for ( sal_Int32 pos = 0; pos < len; ++pos )
 233     {
 234         Reference<T> const & xNewParam = pNewParams[pos];
 235         Reference<T> const & xExistingParam = pExistingParams[pos];
 236
 237         OUStringBuffer buf;
 238         buf.append( context_ );
 239         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", parameter ") );
 240         buf.append( pos );
 241         OSL_ASSERT( pos == xNewParam->getPosition() &&
 242                     pos == xExistingParam->getPosition() );
 243         OUString context( buf.makeStringAndClear() );
 244
 245         if (xNewParam->getName() != xExistingParam->getName())
 246         {
 247             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Name differs: ") );
 248             buf.append( xNewParam->getName() );
 249             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") );
 250             buf.append( xExistingParam->getName() );
 251             typeError( buf.makeStringAndClear(), context );
 252         }
 253         check( xNewParam->getType(), xExistingParam->getType(), context );
 254
 255         if (xNewParam->isIn() != xExistingParam->isIn())
 256             typeError( OUSTR("IN attribute differs!"), context );
 257         if (xNewParam->isOut() != xExistingParam->isOut())
 258             typeError( OUSTR("OUT attribute differs!"), context );
 259         checkRestParam( xNewParam, xExistingParam, context );
 260     }
 261 }
 262
 263 static void checkMethod(
 264     Reference<reflection::XInterfaceMethodTypeDescription> const & xNewTD,
 265     Reference<reflection::XInterfaceMethodTypeDescription> const & xExistingTD )
 266 {
 267     check( xNewTD->getReturnType(), xExistingTD->getReturnType(),
 268            xNewTD->getName() );
 269
 270     if (xNewTD->isOneway() != xExistingTD->isOneway())
 271         typeError( OUSTR("Methods have differing OneWay attribute!"),
 272                    xNewTD->getName() );
 273
 274     checkParameters( xNewTD->getParameters(), xExistingTD->getParameters(),
 275                      xNewTD->getName() );
 276
 277     checkSeq( xNewTD->getExceptions(), xExistingTD->getExceptions(),
 278               xNewTD->getName() + OUSTR(", declared exceptions") );
 279 }
 280
 281 void checkAttribute(
 282     Reference<reflection::XInterfaceAttributeTypeDescription2> const & xNewTD,
 283     Reference<reflection::XInterfaceAttributeTypeDescription2>
 284     const & xExistingTD )
 285 {
 286     if (xNewTD->isReadOnly() != xExistingTD->isReadOnly())
 287         typeError( OUSTR("ReadOnly attribute differs!"), xNewTD->getName() );
 288
 289     check( xNewTD->getType(), xExistingTD->getType(),
 290            xNewTD->getName() + OUSTR(", attribute type") );
 291
 292     if (xNewTD->isBound() != xExistingTD->isBound())
 293         typeError( OUSTR("Bound attribute differs!"), xNewTD->getName() );
 294
 295     checkSeq( xNewTD->getGetExceptions(), xExistingTD->getGetExceptions(),
 296               xNewTD->getName() + OUSTR(", getter exceptions") );
 297     checkSeq( xNewTD->getSetExceptions(), xExistingTD->getSetExceptions(),
 298               xNewTD->getName() + OUSTR(", setter exceptions") );
 299 }
 300
 301 void checkProperty(
 302     Reference<reflection::XPropertyTypeDescription> const & xNewTD,
 303     Reference<reflection::XPropertyTypeDescription> const & xExistingTD )
 304 {
 305     if (xNewTD->getPropertyFlags() != xExistingTD->getPropertyFlags())
 306     {
 307         OUStringBuffer buf;
 308         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
 309                              "Different set of property flags: { ") );
 310         buf.append( getPropertyFlagsAsString(
 311                         xNewTD->getPropertyFlags() ) );
 312         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (new), { ") );
 313         buf.append( getPropertyFlagsAsString(
 314                         xExistingTD->getPropertyFlags() ) );
 315         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (existing)!") );
 316         typeError( buf.makeStringAndClear(), xNewTD->getName() );
 317     }
 318
 319     check( xNewTD->getPropertyTypeDescription(),
 320            xExistingTD->getPropertyTypeDescription(),
 321            xNewTD->getName() );
 322 }
 323
 324 void checkSingleton(
 325     Reference<reflection::XSingletonTypeDescription2> const & xNewTD,
 326     Reference<reflection::XSingletonTypeDescription2> const & xExistingTD )
 327 {
 328     sal_Bool ifaceBased = xNewTD->isInterfaceBased();
 329     if (ifaceBased != xExistingTD->isInterfaceBased())
 330         typeError(
 331             OUSTR("Mixing interface and NON-interface based singletons!"),
 332             xNewTD->getName() );
 333     if (ifaceBased)
 334         check( xNewTD->getInterface(), xExistingTD->getInterface(),
 335                xNewTD->getName() );
 336     else
 337         check( xNewTD->getService().get(), xExistingTD->getService().get(),
 338                xNewTD->getName() );
 339 }
 340
 341 void checkService(
 342     Reference<reflection::XServiceTypeDescription2> const & xNewTD,
 343     Reference<reflection::XServiceTypeDescription2> const & xExistingTD )
 344 {
 345     sal_Bool singleIfaceBased = xNewTD->isSingleInterfaceBased();
 346     if (singleIfaceBased != xExistingTD->isSingleInterfaceBased())
 347         typeError( OUSTR("Mixing interface and NON-interface based services!"),
 348                    xNewTD->getName() );
 349     if (singleIfaceBased)
 350     {
 351         check( xNewTD->getInterface(), xExistingTD->getInterface(),
 352                xNewTD->getName() );
 353         Sequence< Reference<reflection::XServiceConstructorDescription> >
 354             newCtors( xNewTD->getConstructors() );
 355         Sequence< Reference<reflection::XServiceConstructorDescription> >
 356             existingCtors( xExistingTD->getConstructors() );
 357         sal_Int32 len = newCtors.getLength();
 358         if (len != existingCtors.getLength())
 359             typeError( OUSTR("Different number of service constructors!"),
 360                        xNewTD->getName() );
 361         Reference<reflection::XServiceConstructorDescription> const *
 362             pNewCtors = newCtors.getConstArray();
 363         Reference<reflection::XServiceConstructorDescription> const *
 364             pExistingCtors = existingCtors.getConstArray();
 365         for ( sal_Int32 pos = 0; pos < len; ++pos )
 366         {
 367             Reference<reflection::XServiceConstructorDescription> const &
 368                 xNewCtor = pNewCtors[pos];
 369             Reference<reflection::XServiceConstructorDescription> const &
 370                 xExistingCtor = pExistingCtors[pos];
 371
 372             if (xNewCtor->getName() != xExistingCtor->getName())
 373             {
 374                 OUStringBuffer buf;
 375                 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
 376                                      "Different constructor names: ") );
 377                 buf.append( xNewCtor->getName() );
 378                 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
 379                 buf.append( xExistingCtor->getName() );
 380                 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
 381                 typeError( buf.makeStringAndClear(), xNewTD->getName() );
 382             }
 383
 384             OUStringBuffer buf;
 385             buf.append( xNewTD->getName() );
 386             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", constructor ") );
 387             buf.append( xNewCtor->getName() );
 388             OUString context( buf.makeStringAndClear() );
 389             checkParameters( xNewCtor->getParameters(),
 390                              xExistingCtor->getParameters(),
 391                              context );
 392             checkSeq( xNewCtor->getExceptions(), xExistingCtor->getExceptions(),
 393                       context + OUSTR(", exceptions") );
 394         }
 395     }
 396     else // old-style service descriptions:
 397     {
 398         checkSeq( xNewTD->getMandatoryServices(),
 399                   xExistingTD->getMandatoryServices(),
 400                   xNewTD->getName() + OUSTR(", mandatory services") );
 401         checkSeq( xNewTD->getOptionalServices(),
 402                   xExistingTD->getOptionalServices(),
 403                   xNewTD->getName() + OUSTR(", optional services"),
 404                   true /* optionalMode */ );
 405         checkSeq( xNewTD->getMandatoryInterfaces(),
 406                   xExistingTD->getMandatoryInterfaces(),
 407                   xNewTD->getName() + OUSTR(", mandatory interfaces") );
 408         checkSeq( xNewTD->getOptionalInterfaces(),
 409                   xExistingTD->getOptionalInterfaces(),
 410                   xNewTD->getName() + OUSTR(", optional interfaces"),
 411                   true /* optionalMode */ );
 412
 413         Sequence< Reference<reflection::XPropertyTypeDescription> >
 414             newProperties( xNewTD->getProperties() );
 415         Sequence< Reference<reflection::XPropertyTypeDescription> >
 416             existingProperties( xExistingTD->getProperties() );
 417         checkSeq( newProperties, existingProperties,
 418                   xNewTD->getName() + OUSTR(", properties"),
 419                   true /* optionalMode */ );
 420         if (newProperties.getLength() > existingProperties.getLength())
 421         {
 422             // check whether all added properties are OPTIONAL:
 423             Reference<reflection::XPropertyTypeDescription> const *
 424                 pNewProperties = newProperties.getConstArray();
 425             for ( sal_Int32 pos = existingProperties.getLength() + 1;
 426                   pos < newProperties.getLength(); ++pos )
 427             {
 428                 if ((pNewProperties[pos]->getPropertyFlags() &
 429                      beans::PropertyAttribute::OPTIONAL) == 0)
 430                     typeError( OUSTR("New property is not OPTIONAL!"),
 431                                pNewProperties[pos]->getName() );
 432             }
 433         }
 434     }
 435 }
 436
 437 }
 438
 439 namespace stoc_tdmgr {
 440
 441 void check( Reference<reflection::XTypeDescription> const & xNewTD,
 442             Reference<reflection::XTypeDescription> const & xExistingTD,
 443             OUString const & context )
 444 {
 445     if (xNewTD == xExistingTD)
 446         return;
 447     if (xNewTD->getName() != xExistingTD->getName())
 448     {
 449         OUStringBuffer buf;
 450         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Different type names: ") );
 451         buf.append( xNewTD->getName() );
 452         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
 453         buf.append( xExistingTD->getName() );
 454         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
 455         typeError( buf.makeStringAndClear(), context );
 456     }
 457
 458     TypeClass tc = xNewTD->getTypeClass();
 459     if (tc != xExistingTD->getTypeClass())
 460     {
 461         OUStringBuffer buf;
 462         buf.append( xNewTD->getName() );
 463         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
 464                              " has different type classes: ") );
 465         buf.append( getTypeClassName( tc ) );
 466         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
 467         buf.append( getTypeClassName( xExistingTD->getTypeClass() ) );
 468         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
 469         typeError( buf.makeStringAndClear(), context );
 470     }
 471
 472     switch (tc)
 473     {
 474     case TypeClass_ENUM:
 475         checkEnum( Reference<reflection::XEnumTypeDescription>(
 476                        xNewTD, UNO_QUERY_THROW ),
 477                    Reference<reflection::XEnumTypeDescription>(
 478                        xExistingTD, UNO_QUERY_THROW ) );
 479         break;
 480
 481     case TypeClass_TYPEDEF:
 482     case TypeClass_SEQUENCE:
 483         check( Reference<reflection::XIndirectTypeDescription>(
 484                    xNewTD, UNO_QUERY_THROW )->getReferencedType(),
 485                Reference<reflection::XIndirectTypeDescription>(
 486                    xExistingTD, UNO_QUERY_THROW )->getReferencedType() );
 487         break;
 488
 489     case TypeClass_STRUCT:
 490     case TypeClass_EXCEPTION:
 491         checkStruct( Reference<reflection::XCompoundTypeDescription>(
 492                          xNewTD, UNO_QUERY_THROW ),
 493                      Reference<reflection::XCompoundTypeDescription>(
 494                          xExistingTD, UNO_QUERY_THROW ) );
 495         break;
 496
 497     case TypeClass_INTERFACE:
 498         checkInterface( Reference<reflection::XInterfaceTypeDescription2>(
 499                             xNewTD, UNO_QUERY_THROW ),
 500                         Reference<reflection::XInterfaceTypeDescription2>(
 501                             xExistingTD, UNO_QUERY_THROW ) );
 502         break;
 503
 504     case TypeClass_SERVICE:
 505         checkService( Reference<reflection::XServiceTypeDescription2>(
 506                           xNewTD, UNO_QUERY_THROW ),
 507                       Reference<reflection::XServiceTypeDescription2>(
 508                           xExistingTD, UNO_QUERY_THROW ) );
 509         break;
 510
 511     case TypeClass_INTERFACE_METHOD:
 512         checkMethod( Reference<reflection::XInterfaceMethodTypeDescription>(
 513                          xNewTD, UNO_QUERY_THROW ),
 514                      Reference<reflection::XInterfaceMethodTypeDescription>(
 515                          xExistingTD, UNO_QUERY_THROW ) );
 516         break;
 517     case TypeClass_INTERFACE_ATTRIBUTE:
 518         checkAttribute(
 519             Reference<reflection::XInterfaceAttributeTypeDescription2>(
 520                 xNewTD, UNO_QUERY_THROW ),
 521             Reference<reflection::XInterfaceAttributeTypeDescription2>(
 522                 xExistingTD, UNO_QUERY_THROW ) );
 523         break;
 524
 525     case TypeClass_PROPERTY:
 526         checkProperty( Reference<reflection::XPropertyTypeDescription>(
 527                            xNewTD, UNO_QUERY_THROW ),
 528                        Reference<reflection::XPropertyTypeDescription>(
 529                            xExistingTD, UNO_QUERY_THROW ) );
 530         break;
 531
 532     case TypeClass_CONSTANT:
 533         if (Reference<reflection::XConstantTypeDescription>(
 534                 xNewTD, UNO_QUERY_THROW )->getConstantValue() !=
 535             Reference<reflection::XConstantTypeDescription>(
 536                 xExistingTD, UNO_QUERY_THROW )->getConstantValue())
 537             typeError( OUSTR("Different constant value!"), xNewTD->getName() );
 538         break;
 539     case TypeClass_CONSTANTS:
 540         checkSeq( Reference<reflection::XConstantsTypeDescription>(
 541                       xNewTD, UNO_QUERY_THROW )->getConstants(),
 542                   Reference<reflection::XConstantsTypeDescription>(
 543                       xExistingTD, UNO_QUERY_THROW )->getConstants(),
 544                   xNewTD->getName() );
 545         break;
 546
 547     case TypeClass_SINGLETON:
 548         checkSingleton( Reference<reflection::XSingletonTypeDescription2>(
 549                             xNewTD, UNO_QUERY_THROW ),
 550                         Reference<reflection::XSingletonTypeDescription2>(
 551                             xExistingTD, UNO_QUERY_THROW ) );
 552         break;
 553
 554     default:
 555         break;
 556     }
 557 }
 558
 559 }