/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#ifndef EQ_HXX
#define EQ_HXX

#include <math.h>
#include <rtl/memory.h>

#include "prim.hxx"
#include "destr.hxx"


namespace cppu
{

//##################################################################################################
//#### equality ####################################################################################
//##################################################################################################

//--------------------------------------------------------------------------------------------------
inline sal_Bool _equalObject(
	void * pI1, void * pI2,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () )
{
	if (pI1 == pI2)
		return sal_True;
	if ((0 == pI1) || (0 == pI2))
		return sal_False;
    sal_Bool bRet = sal_False;

    typelib_TypeDescriptionReference * type_XInterface =
        * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
	if (0 == queryInterface)
        queryInterface = binuno_queryInterface;
    pI1 = (*queryInterface)( pI1, type_XInterface );
    if (0 != pI1)
    {
        pI2 = (*queryInterface)( pI2, type_XInterface );
        if (0 != pI2)
        {
            bRet = (pI1 == pI2);
            _release( pI2, release );
        }
        _release( pI1, release );
    }
    return bRet;
}

//==================================================================================================
sal_Bool equalStruct(
	void * pDest, void *pSource,
	typelib_CompoundTypeDescription * pTypeDescr,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () );
//--------------------------------------------------------------------------------------------------
inline sal_Bool _equalStruct(
	void * pDest, void *pSource,
	typelib_CompoundTypeDescription * pTypeDescr,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () )
{
	if (pTypeDescr->pBaseTypeDescription &&
		!equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release ))
	{
		return sal_False;
	}

	typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
	sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
	sal_Int32 nDescr = pTypeDescr->nMembers;

	while (nDescr--)
	{
		sal_Int32 nOffset = pMemberOffsets[nDescr];
		if (! ::uno_type_equalData( (char *)pDest + nOffset,
                                    ppTypeRefs[nDescr],
                                    (char *)pSource + nOffset,
                                    ppTypeRefs[nDescr],
                                    queryInterface, release ))
		{
			return sal_False;
		}
	}
	return sal_True;
}
//==================================================================================================
sal_Bool equalSequence(
	uno_Sequence * pDest, uno_Sequence * pSource,
	typelib_TypeDescriptionReference * pElementType,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () );
//--------------------------------------------------------------------------------------------------
inline sal_Bool _equalSequence(
	uno_Sequence * pDest, uno_Sequence * pSource,
	typelib_TypeDescriptionReference * pElementType,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () )
{
	if (pDest == pSource)
		return sal_True;
	sal_Int32 nElements = pDest->nElements;
	if (nElements != pSource->nElements)
		return sal_False;
	if (! nElements)
		return sal_True;

	void * pDestElements = pDest->elements;
	void * pSourceElements = pSource->elements;

	switch (pElementType->eTypeClass)
	{
	case typelib_TypeClass_CHAR:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Unicode) * nElements ));
	case typelib_TypeClass_BOOLEAN:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if ((((sal_Bool *)pDestElements)[nPos] != sal_False) !=
				(((sal_Bool *)pSourceElements)[nPos] != sal_False))
			{
				return sal_False;
			}
		}
		return sal_True;
	}
	case typelib_TypeClass_BYTE:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int8) * nElements ));
	case typelib_TypeClass_SHORT:
	case typelib_TypeClass_UNSIGNED_SHORT:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int16) * nElements ));
	case typelib_TypeClass_LONG:
	case typelib_TypeClass_UNSIGNED_LONG:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
	case typelib_TypeClass_HYPER:
	case typelib_TypeClass_UNSIGNED_HYPER:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int64) * nElements ));
	case typelib_TypeClass_FLOAT:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (((float *)pDestElements)[nPos] != ((float *)pSourceElements)[nPos])
				return sal_False;
		}
		return sal_True;
	}
	case typelib_TypeClass_DOUBLE:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (((double *)pDestElements)[nPos] != ((double *)pSourceElements)[nPos])
				return sal_False;
		}
		return sal_True;
	}
	case typelib_TypeClass_STRING:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (! ((::rtl::OUString *)pDestElements +nPos)->equals( ((const ::rtl::OUString *)pSourceElements)[nPos] ))
				return sal_False;
		}
		return sal_True;
	}
	case typelib_TypeClass_TYPE:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (! _type_equals( ((typelib_TypeDescriptionReference **)pDestElements)[nPos],
                                ((typelib_TypeDescriptionReference **)pSourceElements)[nPos] ))
			{
				return sal_False;
			}
		}
		return sal_True;
	}
	case typelib_TypeClass_ANY:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			uno_Any * pDest2 = (uno_Any *)pDestElements + nPos;
			uno_Any * pSource2 = (uno_Any *)pSourceElements + nPos;
			if (! ::uno_type_equalData( pDest2->pData, pDest2->pType,
										pSource2->pData, pSource2->pType,
										queryInterface, release ))
			{
				return sal_False;
			}
		}
		return sal_True;
	}
	case typelib_TypeClass_ENUM:
		return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
	case typelib_TypeClass_STRUCT:
	case typelib_TypeClass_EXCEPTION:
	{
		typelib_TypeDescription * pElementTypeDescr = 0;
		TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
		sal_Int32 nElementSize = pElementTypeDescr->nSize;
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (! _equalStruct( (char *)pDestElements + (nPos * nElementSize),
                                (char *)pSourceElements + (nPos * nElementSize),
                                (typelib_CompoundTypeDescription *)pElementTypeDescr,
                                queryInterface, release ))
			{
				TYPELIB_DANGER_RELEASE( pElementTypeDescr );
				return sal_False;
			}
		}
		TYPELIB_DANGER_RELEASE( pElementTypeDescr );
		return sal_True;
	}
	case typelib_TypeClass_UNION:
	{
		typelib_TypeDescription * pElementTypeDescr = 0;
		TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
		sal_Int32 nElementSize = pElementTypeDescr->nSize;
		sal_Int32 nValueOffset = ((typelib_UnionTypeDescription *)pElementTypeDescr)->nValueOffset;
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			char * pDest2 = (char *)pDestElements + (nPos * nElementSize);
			char * pSource2 = (char *)pSourceElements + (nPos * nElementSize);
			typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
                pDest2, pElementTypeDescr );
			sal_Bool bRet = ::uno_type_equalData(
                pDest2 + nValueOffset, pSetType,
                pSource2 + nValueOffset, pSetType,
                queryInterface, release );
			::typelib_typedescriptionreference_release( pSetType );
			if (! bRet)
			{
				TYPELIB_DANGER_RELEASE( pElementTypeDescr );
				return sal_False;
			}
		}
		TYPELIB_DANGER_RELEASE( pElementTypeDescr );
		return sal_True;
	}
	case typelib_TypeClass_SEQUENCE: // sequence of sequence
	{
		typelib_TypeDescription * pElementTypeDescr = 0;
		TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
		typelib_TypeDescriptionReference * pSeqElementType =
			((typelib_IndirectTypeDescription *)pElementTypeDescr)->pType;
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (! equalSequence( ((uno_Sequence **)pDestElements)[nPos],
								 ((uno_Sequence **)pSourceElements)[nPos],
								 pSeqElementType, queryInterface, release ))
			{
				TYPELIB_DANGER_RELEASE( pElementTypeDescr );
				return sal_False;
			}
		}
		TYPELIB_DANGER_RELEASE( pElementTypeDescr );
		return sal_True;
	}
	case typelib_TypeClass_INTERFACE:
	{
		for ( sal_Int32 nPos = nElements; nPos--; )
		{
			if (! _equalObject( ((void **)pDestElements)[nPos], ((void **)pSourceElements)[nPos],
                                queryInterface, release ))
			{
				return sal_False;
			}
		}
		return sal_True;
	}
    default:
        OSL_ASSERT(false);
        return sal_False;
	}
}
//--------------------------------------------------------------------------------------------------
inline sal_Bool _equalData(
	void * pDest,
	typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr,
	void * pSource,
	typelib_TypeDescriptionReference * pSourceType, typelib_TypeDescription * pSourceTypeDescr,
	uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
	SAL_THROW( () )
{
	typelib_TypeClass eSourceTypeClass, eDestTypeClass;
	while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass))
	{
		pDestTypeDescr = 0;
		pDestType = ((uno_Any *)pDest)->pType;
		pDest = ((uno_Any *)pDest)->pData;
	}
	while (typelib_TypeClass_ANY == (eSourceTypeClass = pSourceType->eTypeClass))
	{
		pSourceTypeDescr = 0;
		pSourceType = ((uno_Any *)pSource)->pType;
		pSource = ((uno_Any *)pSource)->pData;
	}

	switch (eDestTypeClass)
	{
	case typelib_TypeClass_VOID:
		return eSourceTypeClass == typelib_TypeClass_VOID;
	case typelib_TypeClass_CHAR:
		return eSourceTypeClass == typelib_TypeClass_CHAR
			&& *(sal_Unicode *)pDest == *(sal_Unicode *)pSource;
	case typelib_TypeClass_BOOLEAN:
		return eSourceTypeClass == typelib_TypeClass_BOOLEAN
			&& ((*(sal_Bool *)pDest != sal_False)
                == (*(sal_Bool *)pSource != sal_False));
	case typelib_TypeClass_BYTE:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(sal_Int8 *)pDest == *(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return ((sal_Int16)*(sal_Int8 *)pDest == *(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return ((sal_Int32)*(sal_Int8 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return ((sal_Int32)*(sal_Int8 *)pDest == *(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return ((sal_Int64)*(sal_Int8 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return ((sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return (*(sal_Int8 *)pDest >= 0 &&
					(sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource); // same size
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_Int8 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_Int8 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_SHORT:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(sal_Int16 *)pDest == (sal_Int16)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(sal_Int16 *)pDest == *(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return ((sal_Int32)*(sal_Int16 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return ((sal_Int32)*(sal_Int16 *)pDest == *(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return ((sal_Int64)*(sal_Int16 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return ((sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return (*(sal_Int16 *)pDest >= 0 &&
					(sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource); // same size
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_Int16 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_Int16 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_UNSIGNED_SHORT:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(sal_uInt16 *)pDest == *(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return ((sal_Int32)*(sal_uInt16 *)pDest == *(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return ((sal_uInt32)*(sal_uInt16 *)pDest == *(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return ((sal_Int64)*(sal_uInt16 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return ((sal_uInt64)*(sal_uInt16 *)pDest == *(sal_uInt64 *)pSource);
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_uInt16 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_uInt16 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_LONG:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return (*(sal_Int32 *)pDest == *(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return ((sal_Int64)*(sal_Int32 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return ((sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return (*(sal_Int32 *)pDest >= 0 &&
					(sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource); // same size
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_Int32 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_Int32 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_UNSIGNED_LONG:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(sal_uInt32 *)pDest == (sal_uInt32)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return (*(sal_uInt32 *)pDest == *(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return ((sal_Int64)*(sal_uInt32 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return ((sal_uInt64)*(sal_uInt32 *)pDest == *(sal_uInt64 *)pSource);
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_uInt32 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_uInt32 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_HYPER:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return (*(sal_Int64 *)pDest == *(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return (*(sal_Int64 *)pDest >= 0 &&
					*(sal_Int64 *)pDest == *(sal_Int64 *)pSource); // same size
		case typelib_TypeClass_FLOAT:
			return ((float)*(sal_Int64 *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(sal_Int64 *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_UNSIGNED_HYPER:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(sal_Int8 *)pSource >= 0 &&
					*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(sal_Int16 *)pSource >= 0 &&
					*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return (*(sal_Int32 *)pSource >= 0 &&
					*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return (*(sal_Int64 *)pSource >= 0 &&
					*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			return (*(sal_uInt64 *)pDest == *(sal_uInt64 *)pSource);
		case typelib_TypeClass_FLOAT:
			if (::floor( *(float *)pSource ) != *(float *)pSource || *(float *)pSource < 0)
				return sal_False;
			return (*(sal_uInt64 *)pDest == (sal_uInt64)*(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			if (::floor( *(double *)pSource ) != *(double *)pSource || *(double *)pSource < 0)
				return sal_False;
			return (*(sal_uInt64 *)pDest == (sal_uInt64)*(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_FLOAT:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(float *)pDest == (float)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(float *)pDest == (float)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(float *)pDest == (float)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return (*(float *)pDest == (float)*(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return (*(float *)pDest == (float)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return (*(float *)pDest == (float)*(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			if (::floor( *(float *)pDest ) != *(float *)pDest || *(float *)pDest < 0)
				return sal_False;
			return ((sal_uInt64)*(float *)pDest == *(sal_uInt64 *)pSource);
		case typelib_TypeClass_FLOAT:
			return (*(float *)pDest == *(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return ((double)*(float *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_DOUBLE:
		switch (eSourceTypeClass)
		{
		case typelib_TypeClass_BYTE:
			return (*(double *)pDest == (double)*(sal_Int8 *)pSource);
		case typelib_TypeClass_SHORT:
			return (*(double *)pDest == (double)*(sal_Int16 *)pSource);
		case typelib_TypeClass_UNSIGNED_SHORT:
			return (*(double *)pDest == (double)*(sal_uInt16 *)pSource);
		case typelib_TypeClass_LONG:
			return (*(double *)pDest == (double)*(sal_Int32 *)pSource);
		case typelib_TypeClass_UNSIGNED_LONG:
			return (*(double *)pDest == (double)*(sal_uInt32 *)pSource);
		case typelib_TypeClass_HYPER:
			return (*(double *)pDest == (double)*(sal_Int64 *)pSource);
		case typelib_TypeClass_UNSIGNED_HYPER:
			if (::floor( *(double *)pDest ) != *(double *)pDest || *(double *)pDest < 0)
				return sal_False;
			return ((sal_uInt64)*(double *)pDest == *(sal_uInt64 *)pSource);
		case typelib_TypeClass_FLOAT:
			return (*(double *)pDest == (double)*(float *)pSource);
		case typelib_TypeClass_DOUBLE:
			return (*(double *)pDest == *(double *)pSource);
        default:
            return sal_False;
		}
	case typelib_TypeClass_STRING:
        return eSourceTypeClass == typelib_TypeClass_STRING
            && ((::rtl::OUString *)pDest)->equals(
                *(::rtl::OUString const *)pSource );
	case typelib_TypeClass_TYPE:
        return eSourceTypeClass == typelib_TypeClass_TYPE
            && _type_equals(
                *(typelib_TypeDescriptionReference **)pDest,
                *(typelib_TypeDescriptionReference **)pSource );
	case typelib_TypeClass_ENUM:
		return (_type_equals( pDestType, pSourceType ) &&
				*(sal_Int32 *)pDest == *(sal_Int32 *)pSource);
	case typelib_TypeClass_STRUCT:
	case typelib_TypeClass_EXCEPTION:
		if (! _type_equals( pDestType, pSourceType ))
			return sal_False;
		if (pDestTypeDescr)
		{
			return _equalStruct(
				pDest, pSource,
				(typelib_CompoundTypeDescription *)pDestTypeDescr,
				queryInterface, release );
		}
		else
		{
			TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
			sal_Bool bRet = _equalStruct(
				pDest, pSource,
				(typelib_CompoundTypeDescription *)pDestTypeDescr,
				queryInterface, release );
			TYPELIB_DANGER_RELEASE( pDestTypeDescr );
			return bRet;
		}
	case typelib_TypeClass_UNION:
		if (_type_equals( pDestType, pSourceType ) &&
			*(sal_Int64 *)pDest == *(sal_Int64 *)pSource) // same discriminant
		{
			sal_Bool bRet;
			if (pDestTypeDescr)
			{
				typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
                    pDest, pDestTypeDescr );
				bRet = ::uno_type_equalData(
					(char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
                    pSetType,
					(char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
                    pSetType,
					queryInterface, release );
				typelib_typedescriptionreference_release( pSetType );
			}
			else
			{
				TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
				typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
                    pDest, pDestTypeDescr );
				bRet = ::uno_type_equalData(
					(char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
                    pSetType,
					(char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
                    pSetType,
					queryInterface, release );
				typelib_typedescriptionreference_release( pSetType );
				TYPELIB_DANGER_RELEASE( pDestTypeDescr );
			}
			return bRet;
		}
		return sal_False;
	case typelib_TypeClass_SEQUENCE:
		if (_type_equals( pDestType, pSourceType ))
		{
			if (pDestTypeDescr)
			{
				return _equalSequence(
					*(uno_Sequence **)pDest, *(uno_Sequence **)pSource,
					((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType,
					queryInterface, release );
			}
			else
			{
				TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
				sal_Bool bRet = _equalSequence(
					*(uno_Sequence **)pDest, *(uno_Sequence **)pSource,
					((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType,
					queryInterface, release );
				TYPELIB_DANGER_RELEASE( pDestTypeDescr );
				return bRet;
			}
		}
		return sal_False;
	case typelib_TypeClass_INTERFACE:
		if (typelib_TypeClass_INTERFACE == eSourceTypeClass)
			return _equalObject( *(void **)pDest, *(void **)pSource, queryInterface, release );
        break;
    default:
        OSL_ASSERT(false);
        break;
	}
	return sal_False;
}

}

#endif