| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <rtl/alloc.h> |
| #ifndef __REGISTRY_REFLWRIT_HXX__ |
| #include <registry/reflwrit.hxx> |
| #endif |
| #include <cppuhelper/servicefactory.hxx> |
| #include <com/sun/star/container/XHierarchicalNameAccess.hpp> |
| #include <com/sun/star/reflection/XInterfaceTypeDescription.hpp> |
| #include <com/sun/star/reflection/XConstantsTypeDescription.hpp> |
| #include <com/sun/star/reflection/XConstantTypeDescription.hpp> |
| #include <com/sun/star/reflection/XModuleTypeDescription.hpp> |
| #include <com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp> |
| #include <com/sun/star/reflection/XInterfaceAttributeTypeDescription.hpp> |
| #include <com/sun/star/reflection/XMethodParameter.hpp> |
| #include <com/sun/star/reflection/XCompoundTypeDescription.hpp> |
| #include <com/sun/star/reflection/XIndirectTypeDescription.hpp> |
| #include <com/sun/star/reflection/XEnumTypeDescription.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/uno/XComponentContext.hpp> |
| #include <codemaker/global.hxx> |
| |
| using namespace com::sun::star; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::reflection; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::container; |
| using namespace cppu; |
| //using namespace osl; |
| using namespace rtl; |
| |
| static Reference< XHierarchicalNameAccess > xNameAccess; |
| |
| void writeConstantData( RegistryTypeWriter& rWriter, sal_uInt16 fieldIndex, |
| const Reference< XConstantTypeDescription >& xConstant) |
| |
| { |
| RTConstValue constValue; |
| OUString uConstTypeName; |
| OUString uConstName = xConstant->getName(); |
| Any aConstantAny = xConstant->getConstantValue(); |
| |
| switch ( aConstantAny.getValueTypeClass() ) |
| { |
| case TypeClass_BOOLEAN: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("boolean") ); |
| constValue.m_type = RT_TYPE_BOOL; |
| aConstantAny >>= constValue.m_value.aBool; |
| } |
| break; |
| case TypeClass_BYTE: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("byte") ); |
| constValue.m_type = RT_TYPE_BYTE; |
| aConstantAny >>= constValue.m_value.aByte; |
| } |
| break; |
| case TypeClass_SHORT: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("short") ); |
| constValue.m_type = RT_TYPE_INT16; |
| aConstantAny >>= constValue.m_value.aShort; |
| } |
| break; |
| case TypeClass_UNSIGNED_SHORT: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("unsigned short") ); |
| constValue.m_type = RT_TYPE_UINT16; |
| aConstantAny >>= constValue.m_value.aUShort; |
| } |
| break; |
| case TypeClass_LONG: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("long") ); |
| constValue.m_type = RT_TYPE_INT32; |
| aConstantAny >>= constValue.m_value.aLong; |
| } |
| break; |
| case TypeClass_UNSIGNED_LONG: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("unsigned long") ); |
| constValue.m_type = RT_TYPE_UINT32; |
| aConstantAny >>= constValue.m_value.aULong; |
| } |
| break; |
| case TypeClass_FLOAT: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("float") ); |
| constValue.m_type = RT_TYPE_FLOAT; |
| aConstantAny >>= constValue.m_value.aFloat; |
| } |
| break; |
| case TypeClass_DOUBLE: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("double") ); |
| constValue.m_type = RT_TYPE_DOUBLE; |
| aConstantAny >>= constValue.m_value.aDouble; |
| } |
| break; |
| case TypeClass_STRING: |
| { |
| uConstTypeName = OUString( RTL_CONSTASCII_USTRINGPARAM("string") ); |
| constValue.m_type = RT_TYPE_STRING; |
| constValue.m_value.aString = ((OUString*)aConstantAny.getValue())->getStr(); |
| } |
| break; |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| |
| rWriter.setFieldData(fieldIndex, uConstName, uConstTypeName, OUString(), |
| OUString(), RT_ACCESS_CONST, constValue); |
| } |
| |
| sal_uInt32 getInheritedMemberCount( Reference< XTypeDescription >& xType ) |
| { |
| sal_uInt32 memberCount = 0; |
| if ( xType->getTypeClass() == TypeClass_INTERFACE ) |
| { |
| Reference< XInterfaceTypeDescription > xIFace(xType, UNO_QUERY); |
| |
| if ( !xIFace.is() ) |
| return memberCount; |
| |
| Reference< XTypeDescription > xSuperType = xIFace->getBaseType(); |
| |
| if ( xSuperType.is() ) |
| memberCount = getInheritedMemberCount( xSuperType ); |
| |
| memberCount += xIFace->getMembers().getLength(); |
| } |
| // } else |
| // if ( xType->getTypeClass() == TypeClass_Struct || xType->getTypeClass() == TypeClass_Exception ) |
| // { |
| // Reference< XCompoundTypeDescription > xComp(xType, UNO_QUERY); |
| // |
| // if ( xComp.is() ) |
| // return membercount; |
| // |
| // Reference< XTypeDescription > xSuperType = xComp->getBaseType(); |
| // |
| // if ( xSuperType.is() ) |
| // memberCount = getInheritedMemberCount( xSuperType ); |
| // |
| // memberCount += xComp->getMemberNames().getLength(); |
| // } |
| |
| return memberCount; |
| } |
| |
| void writeMethodData( RegistryTypeWriter& rWriter, sal_uInt32 calculatedMemberOffset, |
| const Reference< XInterfaceMemberTypeDescription >& xMember, |
| const Reference< XInterfaceMethodTypeDescription >& xMethod ) |
| { |
| RTMethodMode methodMode = RT_MODE_TWOWAY; |
| if ( xMethod->isOneway() ) |
| { |
| methodMode = RT_MODE_ONEWAY; |
| } |
| |
| Sequence< Reference< XMethodParameter > > parameters( xMethod->getParameters() ); |
| Sequence< Reference< XTypeDescription > > exceptions( xMethod->getExceptions() ); |
| sal_uInt16 methodIndex = (sal_uInt16)(xMember->getPosition() - calculatedMemberOffset); |
| sal_uInt16 paramCount = (sal_uInt16)parameters.getLength(); |
| sal_uInt16 exceptionCount = (sal_uInt16)exceptions.getLength(); |
| |
| rWriter.setMethodData(methodIndex, xMember->getMemberName(), |
| xMethod->getReturnType()->getName().replace('.', '/'), |
| methodMode, paramCount, exceptionCount, OUString()); |
| |
| RTParamMode paramMode = RT_PARAM_IN; |
| sal_uInt16 i; |
| |
| for ( i=0; i < paramCount; i++) |
| { |
| Reference< XMethodParameter > xParam = parameters[i]; |
| if ( xParam->isIn() && xParam->isOut()) |
| { |
| paramMode = RT_PARAM_INOUT; |
| } else |
| if ( xParam->isIn() ) |
| { |
| paramMode = RT_PARAM_IN; |
| } else |
| if ( xParam->isOut() ) |
| { |
| paramMode = RT_PARAM_OUT; |
| } |
| |
| rWriter.setParamData(methodIndex, (sal_uInt16)xParam->getPosition(), xParam->getType()->getName().replace('.', '/'), |
| xParam->getName(), paramMode); |
| } |
| |
| for (i=0; i < exceptionCount; i++) |
| { |
| rWriter.setExcData(methodIndex, i, exceptions[i]->getName().replace('.', '/')); |
| } |
| } |
| |
| extern "C" |
| { |
| |
| sal_Bool SAL_CALL initTypeMapper( const sal_Char* pRegName ) |
| { |
| try |
| { |
| if (!pRegName) |
| return sal_False; |
| |
| Reference< XMultiServiceFactory > xSMgr( createRegistryServiceFactory( convertToFileUrl(pRegName) ) ); |
| |
| if ( !xSMgr.is() ) |
| return sal_False; |
| |
| Reference< XHierarchicalNameAccess > xNAccess; |
| |
| Reference< beans::XPropertySet > xProps( xSMgr, UNO_QUERY ); |
| if (xProps.is()) |
| { |
| try |
| { |
| Reference< XComponentContext > xContext; |
| if (xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= xContext) |
| { |
| xContext->getValueByName( |
| OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theTypeDescriptionManager") ) ) >>= xNAccess; |
| } |
| } |
| catch (beans::UnknownPropertyException &) |
| { |
| } |
| } |
| |
| if ( !xNAccess.is() ) |
| return sal_False; |
| |
| xNameAccess = xNAccess; |
| } |
| catch( Exception& ) |
| { |
| return sal_False; |
| } |
| |
| return sal_True; |
| } |
| |
| sal_uInt32 SAL_CALL getTypeBlop(const sal_Char* pTypeName, sal_uInt8** pBlop) |
| { |
| sal_uInt32 length = 0; |
| |
| if ( !pTypeName ) |
| return length; |
| |
| OUString uTypeName( OUString::createFromAscii(pTypeName).replace('/', '.') ); |
| try |
| { |
| Any aTypeAny( xNameAccess->getByHierarchicalName( uTypeName ) ); |
| |
| if ( !aTypeAny.hasValue() ) |
| return length; |
| |
| Reference< XTypeDescription > xType; |
| aTypeAny >>= xType; |
| |
| if ( !xType.is() ) |
| return length; |
| |
| switch (xType->getTypeClass()) |
| { |
| case TypeClass_CONSTANTS: |
| { |
| Reference< XConstantsTypeDescription > xCFace(xType, UNO_QUERY); |
| |
| if ( !xCFace.is() ) |
| return length; |
| |
| Sequence< Reference< XConstantTypeDescription > > constTypes( xCFace->getConstants()); |
| sal_uInt16 constCount = (sal_uInt16)constTypes.getLength(); |
| |
| RegistryTypeWriter writer(RT_TYPE_MODULE, uTypeName.replace('.', '/'), |
| OUString(), constCount, 0, 0); |
| |
| for (sal_uInt16 i=0; i < constCount; i++) |
| writeConstantData(writer, i, constTypes[i]); |
| |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| case TypeClass_MODULE: |
| { |
| Reference< XModuleTypeDescription > xMFace(xType, UNO_QUERY); |
| |
| if ( !xMFace.is() ) |
| return length; |
| |
| Sequence< Reference< XTypeDescription > > memberTypes( xMFace->getMembers()); |
| |
| sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength(); |
| sal_uInt16 constCount = 0; |
| sal_Int16 i; |
| |
| for ( i=0; i < memberCount; i++) |
| { |
| if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() ) |
| constCount++; |
| } |
| |
| RegistryTypeWriter writer(RT_TYPE_MODULE, uTypeName.replace('.', '/'), |
| OUString(), constCount, 0, 0); |
| |
| if ( 0 < constCount ) |
| { |
| Reference< XConstantTypeDescription > xConst; |
| sal_uInt16 fieldIndex = 0; |
| for (i=0; i < memberCount; i++) |
| { |
| if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() ) |
| { |
| xConst = Reference< XConstantTypeDescription >(memberTypes[i], UNO_QUERY); |
| |
| writeConstantData(writer, ++fieldIndex, xConst); |
| } |
| } |
| } |
| |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| case TypeClass_INTERFACE: |
| { |
| Reference< XInterfaceTypeDescription > xIFace(xType, UNO_QUERY); |
| |
| if ( !xIFace.is() ) |
| return length; |
| |
| Reference< XInterfaceAttributeTypeDescription > xAttr; |
| Reference< XInterfaceMethodTypeDescription > xMethod; |
| Sequence< Reference< XInterfaceMemberTypeDescription > > memberTypes( xIFace->getMembers()); |
| sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength(); |
| sal_uInt16 attrCount = 0; |
| sal_uInt16 inheritedMemberCount = 0; |
| sal_Int32 i; |
| |
| for ( i=0; i < memberCount; i++) |
| { |
| xAttr = Reference< XInterfaceAttributeTypeDescription >(memberTypes[i], UNO_QUERY); |
| if ( xAttr.is() ) |
| { |
| attrCount++; |
| } |
| } |
| |
| OUString uSuperType; |
| Reference< XTypeDescription > xSuperType = xIFace->getBaseType(); |
| if ( xSuperType.is() ) |
| { |
| uSuperType = xSuperType->getName().replace('.','/'); |
| inheritedMemberCount = (sal_uInt16)getInheritedMemberCount( xSuperType ); |
| } |
| |
| RegistryTypeWriter writer(RT_TYPE_INTERFACE, uTypeName.replace('.', '/'), |
| uSuperType, attrCount, memberCount-attrCount, 0); |
| |
| Uik uik = xIFace->getUik(); |
| RTUik rtUik = { uik.m_Data1, uik.m_Data2, uik.m_Data3, uik.m_Data4, uik.m_Data5 }; |
| writer.setUik( rtUik ); |
| |
| RTFieldAccess attrAccess = RT_ACCESS_READWRITE; |
| // reset attrCount, used for method index calculation |
| attrCount = 0; |
| |
| for (i=0; i < memberCount; i++) |
| { |
| xAttr = Reference< XInterfaceAttributeTypeDescription >(memberTypes[i], UNO_QUERY); |
| if ( xAttr.is() ) |
| { |
| ++attrCount; |
| if (xAttr->isReadOnly()) |
| { |
| attrAccess = RT_ACCESS_READONLY; |
| } else |
| { |
| attrAccess = RT_ACCESS_READWRITE; |
| } |
| writer.setFieldData(sal::static_int_cast< sal_uInt16 >(memberTypes[i]->getPosition() - inheritedMemberCount), |
| memberTypes[i]->getMemberName(), |
| xAttr->getType()->getName().replace('.', '/'), |
| OUString(), OUString(), attrAccess); |
| continue; |
| } |
| |
| xMethod = Reference< XInterfaceMethodTypeDescription >(memberTypes[i], UNO_QUERY); |
| if ( xMethod.is() ) |
| { |
| writeMethodData( writer, attrCount+inheritedMemberCount, memberTypes[i], xMethod ); |
| } |
| } |
| |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| case TypeClass_STRUCT: |
| case TypeClass_EXCEPTION: |
| { |
| RTTypeClass rtTypeClass = RT_TYPE_STRUCT; |
| if (xType->getTypeClass() == TypeClass_EXCEPTION) |
| { |
| rtTypeClass = RT_TYPE_EXCEPTION; |
| } |
| #include <com/sun/star/reflection/XConstantsTypeDescription.hpp> |
| |
| Reference< XCompoundTypeDescription > xComp(xType, UNO_QUERY); |
| |
| if ( !xComp.is() ) |
| return length; |
| |
| Sequence< OUString > memberNames( xComp->getMemberNames()); |
| Sequence< Reference< XTypeDescription > > memberTypes( xComp->getMemberTypes()); |
| sal_uInt16 memberCount = (sal_uInt16)memberNames.getLength(); |
| |
| OUString uSuperType; |
| Reference< XTypeDescription > xSuperType = xComp->getBaseType(); |
| if ( xSuperType.is() ) |
| { |
| uSuperType = xSuperType->getName().replace('.','/'); |
| } |
| |
| RegistryTypeWriter writer(rtTypeClass, uTypeName.replace('.', '/'), |
| uSuperType, memberCount, 0, 0); |
| |
| for (sal_Int16 i=0; i < memberCount; i++) |
| { |
| writer.setFieldData(i , memberNames[i], memberTypes[i]->getName().replace('.', '/'), |
| OUString(), OUString(), RT_ACCESS_READWRITE); |
| } |
| |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| case TypeClass_ENUM: |
| { |
| Reference< XEnumTypeDescription > xEnum(xType, UNO_QUERY); |
| |
| if ( !xEnum.is() ) |
| return length; |
| |
| Sequence< OUString > enumNames( xEnum->getEnumNames()); |
| Sequence< sal_Int32 > enumValues( xEnum->getEnumValues()); |
| sal_uInt16 enumCount = (sal_uInt16)enumNames.getLength(); |
| |
| RegistryTypeWriter writer(RT_TYPE_ENUM, uTypeName.replace('.', '/'), |
| OUString(), enumCount, 0, 0); |
| |
| RTConstValue constValue; |
| for (sal_Int16 i=0; i < enumCount; i++) |
| { |
| constValue.m_type = RT_TYPE_INT32; |
| constValue.m_value.aLong = enumValues[i]; |
| |
| writer.setFieldData(i, enumNames[i], OUString(), OUString(), OUString(), |
| RT_ACCESS_CONST, constValue); |
| } |
| |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| case TypeClass_TYPEDEF: |
| { |
| Reference< XIndirectTypeDescription > xTD(xType, UNO_QUERY); |
| |
| if ( !xTD.is() ) |
| return length; |
| |
| RegistryTypeWriter writer(RT_TYPE_TYPEDEF, uTypeName.replace('.', '/'), |
| xTD->getReferencedType()->getName().replace('.', '/'), |
| 0, 0, 0); |
| length = writer.getBlopSize(); |
| *pBlop = (sal_uInt8*)rtl_allocateMemory( length ); |
| rtl_copyMemory(*pBlop, writer.getBlop(), length); |
| } |
| break; |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| return length; |
| } |
| |
| } // extern "C" |
| |
| |
| |
