INTEGRATION: CWS unotlc (1.1.2); FILE ADDED

2004/08/04 09:58:29 dbo 1.1.2.2: #i20303# fixing scope
2004/07/12 13:32:29 dbo 1.1.2.1: #i20303# compatibility type checks upon insertion of providers

1 files changed, 584 insertions, 0 deletions

diff --git a/stoc/source/tdmanager/tdmgr_check.cxx b/stoc/source/tdmanager/tdmgr_check.cxx
new file mode 100644
index 000000000000..a7a4cd721ec1
--- /dev/null
+++ b/stoc/source/tdmanager/tdmgr_check.cxx
@@ -0,0 +1,584 @@
+/*************************************************************************
+ *
+ *  $RCSfile: tdmgr_check.cxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: obo $ $Date: 2004-08-12 12:19:24 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include "tdmgr_common.hxx"
+#include "rtl/ustrbuf.hxx"
+#include "typelib/typedescription.h"
+#include "com/sun/star/beans/PropertyAttribute.hpp"
+#include "com/sun/star/reflection/XConstantsTypeDescription.hpp"
+#include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
+#include "com/sun/star/reflection/XEnumTypeDescription.hpp"
+#include "com/sun/star/reflection/XStructTypeDescription.hpp"
+#include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
+#include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
+#include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
+#include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
+#include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
+
+
+using ::rtl::OUString;
+using ::rtl::OUStringBuffer;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::stoc_tdmgr;
+
+namespace {
+
+OUString getTypeClassName( TypeClass tc )
+{
+    typelib_EnumTypeDescription * typeDescr = 0;
+    OUString name = OUSTR("com.sun.star.uno.TypeClass");
+    typelib_typedescription_getByName(
+        reinterpret_cast<typelib_TypeDescription **>(&typeDescr), name.pData );
+    OSL_ASSERT( typeDescr != 0 );
+    if (typeDescr == 0)
+        return OUSTR("Cannot get type description of ") + name;
+    typelib_typedescription_complete(
+        reinterpret_cast<typelib_TypeDescription **>(&typeDescr) );
+
+    sal_Int32 const * pValues = typeDescr->pEnumValues;
+    sal_Int32 nPos = typeDescr->nEnumValues;
+    while (nPos--)
+    {
+        if (pValues[ nPos ] == (sal_Int32) tc)
+            break;
+    }
+    if (nPos >= 0)
+        name = typeDescr->ppEnumNames[ nPos ];
+    else
+        name = OUSTR("unknown TypeClass value: ") +
+            OUString::valueOf( (sal_Int32) tc );
+
+    typelib_typedescription_release(
+        reinterpret_cast<typelib_TypeDescription *>(typeDescr) );
+    return name;
+}
+
+OUString getPropertyFlagsAsString( sal_Int16 attributes )
+{
+    OUStringBuffer buf;
+    if ((attributes & beans::PropertyAttribute::MAYBEVOID) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEVOID, ") );
+    if ((attributes & beans::PropertyAttribute::BOUND) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("BOUND, ") );
+    if ((attributes & beans::PropertyAttribute::CONSTRAINED) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("CONSTRAINED, ") );
+    if ((attributes & beans::PropertyAttribute::TRANSIENT) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("TRANSIENT, ") );
+    if ((attributes & beans::PropertyAttribute::READONLY) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("READONLY, ") );
+    if ((attributes & beans::PropertyAttribute::MAYBEAMBIGUOUS) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEAMBIGUOUS, ") );
+    if ((attributes & beans::PropertyAttribute::MAYBEDEFAULT) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEDEFAULT, ") );
+    if ((attributes & beans::PropertyAttribute::REMOVEABLE) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("REMOVEABLE, ") );
+    if ((attributes & beans::PropertyAttribute::OPTIONAL) != 0)
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("OPTIONAL") );
+    else if (buf.getLength() > 0)
+        buf.setLength( buf.getLength() - 2 ); // truncate ", "
+    return buf.makeStringAndClear();
+}
+
+void typeError( OUString const & msg, OUString const & context )
+{
+    OUStringBuffer buf;
+    if (context.getLength() > 0) {
+        buf.append( static_cast<sal_Unicode>('[') );
+        buf.append( context );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("] ") );
+    }
+    buf.append( msg );
+    throw IncompatibleTypeException( buf.makeStringAndClear() );
+}
+
+template<typename T>
+void checkSeq( Sequence< Reference<T> > const & newTypes,
+            Sequence< Reference<T> > const & existingTypes,
+            OUString const & context,
+            bool optionalMode = false )
+{
+    sal_Int32 len = newTypes.getLength();
+    if (len != existingTypes.getLength())
+    {
+        if (!optionalMode || len < newTypes.getLength())
+            typeError( OUSTR("Different number of types!"), context );
+        len = existingTypes.getLength();
+    }
+
+    Reference<T> const * pNewTypes = newTypes.getConstArray();
+    Reference<T> const * pExistingTypes = existingTypes.getConstArray();
+    for ( sal_Int32 pos = 0; pos < len; ++pos )
+    {
+        OUStringBuffer buf;
+        buf.append( context );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", position ") );
+        buf.append( pos );
+        check( pNewTypes[pos].get(), pExistingTypes[pos].get(),
+               buf.makeStringAndClear() );
+    }
+}
+
+void checkEnum(
+    Reference<reflection::XEnumTypeDescription> const & xNewTD,
+    Reference<reflection::XEnumTypeDescription> const & xExistingTD )
+{
+    if (xNewTD->getEnumNames() != xExistingTD->getEnumNames())
+        typeError( OUSTR("ENUM names don't match!"), xNewTD->getName() );
+    if (xNewTD->getEnumValues() != xExistingTD->getEnumValues())
+        typeError( OUSTR("ENUM values don't match!"), xNewTD->getName() );
+}
+
+void checkStruct(
+    Reference<reflection::XCompoundTypeDescription> const & xNewTD,
+    Reference<reflection::XCompoundTypeDescription> const & xExistingTD )
+{
+    check( xNewTD->getBaseType(), xExistingTD->getBaseType(),
+           xNewTD->getName() + OUSTR(", base type") );
+    checkSeq( xNewTD->getMemberTypes(), xExistingTD->getMemberTypes(),
+              xNewTD->getName() + OUSTR(", member types") );
+
+    if (xNewTD->getMemberNames() != xExistingTD->getMemberNames())
+        typeError( OUSTR("Different member names!"), xNewTD->getName() );
+
+    if (xNewTD->getTypeClass() == TypeClass_STRUCT)
+    {
+        Reference<reflection::XStructTypeDescription> xNewStructTD(
+            xNewTD, UNO_QUERY );
+        Reference<reflection::XStructTypeDescription> xExistingStructTD(
+            xExistingTD, UNO_QUERY );
+        if (xNewStructTD.is() && xExistingStructTD.is())
+        {
+            if (xNewStructTD->getTypeParameters() !=
+                xExistingStructTD->getTypeParameters())
+                typeError( OUSTR("Different type parameters of instantiated "
+                                 "polymorphic STRUCT!"), xNewTD->getName() );
+            checkSeq( xNewStructTD->getTypeArguments(),
+                      xExistingStructTD->getTypeArguments(),
+                      xNewTD->getName() + OUSTR(", argument types") );
+        }
+        else if (xNewStructTD.is() || xExistingStructTD.is())
+            typeError( OUSTR("Mixing polymorphic STRUCT types "
+                             "with non-polymorphic!"), xNewTD->getName() );
+    }
+}
+
+void checkInterface(
+    Reference<reflection::XInterfaceTypeDescription2> const & xNewTD,
+    Reference<reflection::XInterfaceTypeDescription2> const & xExistingTD )
+{
+    checkSeq( xNewTD->getBaseTypes(), xExistingTD->getBaseTypes(),
+              xNewTD->getName() + OUSTR(", base types") );
+    checkSeq(xNewTD->getOptionalBaseTypes(),xExistingTD->getOptionalBaseTypes(),
+             xNewTD->getName() + OUSTR(", optional base types") );
+    checkSeq( xNewTD->getMembers(), xExistingTD->getMembers(),
+              xNewTD->getName() + OUSTR(", members") );
+}
+
+void checkRestParam( Reference<reflection::XParameter> const & xNewParam,
+                     Reference<reflection::XParameter> const & xExistingParam,
+                     OUString const & context )
+{
+    if (xNewParam->isRestParameter() != xExistingParam->isRestParameter())
+        typeError( OUSTR("Different ... parameters specified!"), context );
+}
+
+void checkRestParam( Reference<reflection::XMethodParameter> const &,
+                     Reference<reflection::XMethodParameter> const &,
+                     OUString const & )
+{
+}
+
+template<typename T>
+void checkParameters( Sequence< Reference<T> > const & newParams,
+                      Sequence< Reference<T> > const & existingParams,
+                      OUString const & context_ )
+{
+    sal_Int32 len = newParams.getLength();
+    if (len != existingParams.getLength())
+        typeError( OUSTR("Different number of parameters!"), context_ );
+    Reference<T> const * pNewParams = newParams.getConstArray();
+    Reference<T> const * pExistingParams = existingParams.getConstArray();
+    for ( sal_Int32 pos = 0; pos < len; ++pos )
+    {
+        Reference<T> const & xNewParam = pNewParams[pos];
+        Reference<T> const & xExistingParam = pExistingParams[pos];
+
+        OUStringBuffer buf;
+        buf.append( context_ );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", parameter ") );
+        buf.append( pos );
+        OSL_ASSERT( pos == xNewParam->getPosition() &&
+                    pos == xExistingParam->getPosition() );
+        OUString context( buf.makeStringAndClear() );
+
+        if (xNewParam->getName() != xExistingParam->getName())
+        {
+            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Name differs: ") );
+            buf.append( xNewParam->getName() );
+            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") );
+            buf.append( xExistingParam->getName() );
+            typeError( buf.makeStringAndClear(), context );
+        }
+        check( xNewParam->getType(), xExistingParam->getType(), context );
+
+        if (xNewParam->isIn() != xExistingParam->isIn())
+            typeError( OUSTR("IN attribute differs!"), context );
+        if (xNewParam->isOut() != xExistingParam->isOut())
+            typeError( OUSTR("OUT attribute differs!"), context );
+        checkRestParam( xNewParam, xExistingParam, context );
+    }
+}
+
+static void checkMethod(
+    Reference<reflection::XInterfaceMethodTypeDescription> const & xNewTD,
+    Reference<reflection::XInterfaceMethodTypeDescription> const & xExistingTD )
+{
+    check( xNewTD->getReturnType(), xExistingTD->getReturnType(),
+           xNewTD->getName() );
+
+    if (xNewTD->isOneway() != xExistingTD->isOneway())
+        typeError( OUSTR("Methods have differing OneWay attribute!"),
+                   xNewTD->getName() );
+
+    checkParameters( xNewTD->getParameters(), xExistingTD->getParameters(),
+                     xNewTD->getName() );
+
+    checkSeq( xNewTD->getExceptions(), xExistingTD->getExceptions(),
+              xNewTD->getName() + OUSTR(", declared exceptions") );
+}
+
+void checkAttribute(
+    Reference<reflection::XInterfaceAttributeTypeDescription2> const & xNewTD,
+    Reference<reflection::XInterfaceAttributeTypeDescription2>
+    const & xExistingTD )
+{
+    if (xNewTD->isReadOnly() != xExistingTD->isReadOnly())
+        typeError( OUSTR("ReadOnly attribute differs!"), xNewTD->getName() );
+
+    check( xNewTD->getType(), xExistingTD->getType(),
+           xNewTD->getName() + OUSTR(", attribute type") );
+
+    if (xNewTD->isBound() != xExistingTD->isBound())
+        typeError( OUSTR("Bound attribute differs!"), xNewTD->getName() );
+
+    checkSeq( xNewTD->getGetExceptions(), xExistingTD->getGetExceptions(),
+              xNewTD->getName() + OUSTR(", getter exceptions") );
+    checkSeq( xNewTD->getSetExceptions(), xExistingTD->getSetExceptions(),
+              xNewTD->getName() + OUSTR(", setter exceptions") );
+}
+
+void checkProperty(
+    Reference<reflection::XPropertyTypeDescription> const & xNewTD,
+    Reference<reflection::XPropertyTypeDescription> const & xExistingTD )
+{
+    if (xNewTD->getPropertyFlags() != xExistingTD->getPropertyFlags())
+    {
+        OUStringBuffer buf;
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
+                             "Different set of property flags: { ") );
+        buf.append( getPropertyFlagsAsString(
+                        xNewTD->getPropertyFlags() ) );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (new), { ") );
+        buf.append( getPropertyFlagsAsString(
+                        xExistingTD->getPropertyFlags() ) );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (existing)!") );
+        typeError( buf.makeStringAndClear(), xNewTD->getName() );
+    }
+
+    check( xNewTD->getPropertyTypeDescription(),
+           xExistingTD->getPropertyTypeDescription(),
+           xNewTD->getName() );
+}
+
+void checkSingleton(
+    Reference<reflection::XSingletonTypeDescription2> const & xNewTD,
+    Reference<reflection::XSingletonTypeDescription2> const & xExistingTD )
+{
+    sal_Bool ifaceBased = xNewTD->isInterfaceBased();
+    if (ifaceBased != xExistingTD->isInterfaceBased())
+        typeError(
+            OUSTR("Mixing interface and NON-interface based singletons!"),
+            xNewTD->getName() );
+    if (ifaceBased)
+        check( xNewTD->getInterface(), xExistingTD->getInterface(),
+               xNewTD->getName() );
+    else
+        check( xNewTD->getService().get(), xExistingTD->getService().get(),
+               xNewTD->getName() );
+}
+
+void checkService(
+    Reference<reflection::XServiceTypeDescription2> const & xNewTD,
+    Reference<reflection::XServiceTypeDescription2> const & xExistingTD )
+{
+    sal_Bool singleIfaceBased = xNewTD->isSingleInterfaceBased();
+    if (singleIfaceBased != xExistingTD->isSingleInterfaceBased())
+        typeError( OUSTR("Mixing interface and NON-interface based services!"),
+                   xNewTD->getName() );
+    if (singleIfaceBased)
+    {
+        check( xNewTD->getInterface(), xExistingTD->getInterface(),
+               xNewTD->getName() );
+        Sequence< Reference<reflection::XServiceConstructorDescription> >
+            newCtors( xNewTD->getConstructors() );
+        Sequence< Reference<reflection::XServiceConstructorDescription> >
+            existingCtors( xExistingTD->getConstructors() );
+        sal_Int32 len = newCtors.getLength();
+        if (len != existingCtors.getLength())
+            typeError( OUSTR("Different number of service constructors!"),
+                       xNewTD->getName() );
+        Reference<reflection::XServiceConstructorDescription> const *
+            pNewCtors = newCtors.getConstArray();
+        Reference<reflection::XServiceConstructorDescription> const *
+            pExistingCtors = existingCtors.getConstArray();
+        for ( sal_Int32 pos = 0; pos < len; ++pos )
+        {
+            Reference<reflection::XServiceConstructorDescription> const &
+                xNewCtor = pNewCtors[pos];
+            Reference<reflection::XServiceConstructorDescription> const &
+                xExistingCtor = pExistingCtors[pos];
+
+            if (xNewCtor->getName() != xExistingCtor->getName())
+            {
+                OUStringBuffer buf;
+                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
+                                     "Different constructor names: ") );
+                buf.append( xNewCtor->getName() );
+                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
+                buf.append( xExistingCtor->getName() );
+                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
+                typeError( buf.makeStringAndClear(), xNewTD->getName() );
+            }
+
+            OUStringBuffer buf;
+            buf.append( xNewTD->getName() );
+            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", constructor ") );
+            buf.append( xNewCtor->getName() );
+            OUString context( buf.makeStringAndClear() );
+            checkParameters( xNewCtor->getParameters(),
+                             xExistingCtor->getParameters(),
+                             context );
+            checkSeq( xNewCtor->getExceptions(), xExistingCtor->getExceptions(),
+                      context + OUSTR(", exceptions") );
+        }
+    }
+    else // old-style service descriptions:
+    {
+        checkSeq( xNewTD->getMandatoryServices(),
+                  xExistingTD->getMandatoryServices(),
+                  xNewTD->getName() + OUSTR(", mandatory services") );
+        checkSeq( xNewTD->getOptionalServices(),
+                  xExistingTD->getOptionalServices(),
+                  xNewTD->getName() + OUSTR(", optional services"),
+                  true /* optionalMode */ );
+        checkSeq( xNewTD->getMandatoryInterfaces(),
+                  xExistingTD->getMandatoryInterfaces(),
+                  xNewTD->getName() + OUSTR(", mandatory interfaces") );
+        checkSeq( xNewTD->getOptionalInterfaces(),
+                  xExistingTD->getOptionalInterfaces(),
+                  xNewTD->getName() + OUSTR(", optional interfaces"),
+                  true /* optionalMode */ );
+
+        Sequence< Reference<reflection::XPropertyTypeDescription> >
+            newProperties( xNewTD->getProperties() );
+        Sequence< Reference<reflection::XPropertyTypeDescription> >
+            existingProperties( xExistingTD->getProperties() );
+        checkSeq( newProperties, existingProperties,
+                  xNewTD->getName() + OUSTR(", properties"),
+                  true /* optionalMode */ );
+        if (newProperties.getLength() > existingProperties.getLength())
+        {
+            // check whether all added properties are OPTIONAL:
+            Reference<reflection::XPropertyTypeDescription> const *
+                pNewProperties = newProperties.getConstArray();
+            for ( sal_Int32 pos = existingProperties.getLength() + 1;
+                  pos < newProperties.getLength(); ++pos )
+            {
+                if ((pNewProperties[pos]->getPropertyFlags() &
+                     beans::PropertyAttribute::OPTIONAL) == 0)
+                    typeError( OUSTR("New property is not OPTIONAL!"),
+                               pNewProperties[pos]->getName() );
+            }
+        }
+    }
+}
+
+}
+
+namespace stoc_tdmgr {
+
+void check( Reference<reflection::XTypeDescription> const & xNewTD,
+            Reference<reflection::XTypeDescription> const & xExistingTD,
+            OUString const & context )
+{
+    if (xNewTD == xExistingTD)
+        return;
+    if (xNewTD->getName() != xExistingTD->getName())
+    {
+        OUStringBuffer buf;
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Different type names: ") );
+        buf.append( xNewTD->getName() );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
+        buf.append( xExistingTD->getName() );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
+        typeError( buf.makeStringAndClear(), context );
+    }
+
+    TypeClass tc = xNewTD->getTypeClass();
+    if (tc != xExistingTD->getTypeClass())
+    {
+        OUStringBuffer buf;
+        buf.append( xNewTD->getName() );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
+                             " has different type classes: ") );
+        buf.append( getTypeClassName( tc ) );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
+        buf.append( getTypeClassName( xExistingTD->getTypeClass() ) );
+        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
+        typeError( buf.makeStringAndClear(), context );
+    }
+
+    switch (tc)
+    {
+    case TypeClass_ENUM:
+        checkEnum( Reference<reflection::XEnumTypeDescription>(
+                       xNewTD, UNO_QUERY_THROW ),
+                   Reference<reflection::XEnumTypeDescription>(
+                       xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_TYPEDEF:
+    case TypeClass_SEQUENCE:
+        check( Reference<reflection::XIndirectTypeDescription>(
+                   xNewTD, UNO_QUERY_THROW )->getReferencedType(),
+               Reference<reflection::XIndirectTypeDescription>(
+                   xExistingTD, UNO_QUERY_THROW )->getReferencedType() );
+        break;
+
+    case TypeClass_STRUCT:
+    case TypeClass_EXCEPTION:
+        checkStruct( Reference<reflection::XCompoundTypeDescription>(
+                         xNewTD, UNO_QUERY_THROW ),
+                     Reference<reflection::XCompoundTypeDescription>(
+                         xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_INTERFACE:
+        checkInterface( Reference<reflection::XInterfaceTypeDescription2>(
+                            xNewTD, UNO_QUERY_THROW ),
+                        Reference<reflection::XInterfaceTypeDescription2>(
+                            xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_SERVICE:
+        checkService( Reference<reflection::XServiceTypeDescription2>(
+                          xNewTD, UNO_QUERY_THROW ),
+                      Reference<reflection::XServiceTypeDescription2>(
+                          xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_INTERFACE_METHOD:
+        checkMethod( Reference<reflection::XInterfaceMethodTypeDescription>(
+                         xNewTD, UNO_QUERY_THROW ),
+                     Reference<reflection::XInterfaceMethodTypeDescription>(
+                         xExistingTD, UNO_QUERY_THROW ) );
+        break;
+    case TypeClass_INTERFACE_ATTRIBUTE:
+        checkAttribute(
+            Reference<reflection::XInterfaceAttributeTypeDescription2>(
+                xNewTD, UNO_QUERY_THROW ),
+            Reference<reflection::XInterfaceAttributeTypeDescription2>(
+                xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_PROPERTY:
+        checkProperty( Reference<reflection::XPropertyTypeDescription>(
+                           xNewTD, UNO_QUERY_THROW ),
+                       Reference<reflection::XPropertyTypeDescription>(
+                           xExistingTD, UNO_QUERY_THROW ) );
+        break;
+
+    case TypeClass_CONSTANT:
+        if (Reference<reflection::XConstantTypeDescription>(
+                xNewTD, UNO_QUERY_THROW )->getConstantValue() !=
+            Reference<reflection::XConstantTypeDescription>(
+                xExistingTD, UNO_QUERY_THROW )->getConstantValue())
+            typeError( OUSTR("Different constant value!"), xNewTD->getName() );
+        break;
+    case TypeClass_CONSTANTS:
+        checkSeq( Reference<reflection::XConstantsTypeDescription>(
+                      xNewTD, UNO_QUERY_THROW )->getConstants(),
+                  Reference<reflection::XConstantsTypeDescription>(
+                      xExistingTD, UNO_QUERY_THROW )->getConstants(),
+                  xNewTD->getName() );
+        break;
+
+    case TypeClass_SINGLETON:
+        checkSingleton( Reference<reflection::XSingletonTypeDescription2>(
+                            xNewTD, UNO_QUERY_THROW ),
+                        Reference<reflection::XSingletonTypeDescription2>(
+                            xExistingTD, UNO_QUERY_THROW ) );
+        break;
+    }
+}
+
+}