include/uno/mapping.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_UNO_MAPPING_HXX
  20 #define INCLUDED_UNO_MAPPING_HXX
  21
  22 #include <sal/config.h>
  23
  24 #include <cstddef>
  25
  26 #include <uno/lbnames.h>
  27 #include <rtl/alloc.h>
  28 #include <rtl/ustring.hxx>
  29 #include <osl/diagnose.h>
  30 #include <uno/mapping.h>
  31 #include <com/sun/star/uno/Type.hxx>
  32 #include <com/sun/star/uno/Reference.hxx>
  33 #include <cppu/unotype.hxx>
  34 #include <uno/environment.hxx>
  35
  36 typedef struct _typelib_TypeDescription typelib_TypeDescription;
  37 typedef struct _typelib_InterfaceTypeDescription typelib_InterfaceTypeDescription;
  38 typedef struct _uno_Interface uno_Interface;
  39
  40 namespace com
  41 {
  42 namespace sun
  43 {
  44 namespace star
  45 {
  46 namespace uno
  47 {
  48
  49 /** C++ wrapper for C uno_Mapping.
  50
  51     @see uno_Mapping
  52 */
  53 class Mapping
  54 {
  55     uno_Mapping * _pMapping;
  56
  57 public:
  58     // these are here to force memory de/allocation to sal lib.
  59     /// @cond INTERNAL
  60     inline static void * SAL_CALL operator new ( size_t nSize )
  61         { return ::rtl_allocateMemory( nSize ); }
  62     inline static void SAL_CALL operator delete ( void * pMem )
  63         { ::rtl_freeMemory( pMem ); }
  64     inline static void * SAL_CALL operator new ( size_t, void * pMem )
  65         { return pMem; }
  66     inline static void SAL_CALL operator delete ( void *, void * )
  67         {}
  68     /// @endcond
  69
  70     /** Holds a mapping from the specified source to the specified destination by environment
  71         type names.
  72
  73         @param rFrom        type name of source environment
  74         @param rTo          type name of destination environment
  75         @param rAddPurpose  additional purpose
  76     */
  77     inline Mapping(
  78         const ::rtl::OUString & rFrom, const ::rtl::OUString & rTo,
  79         const ::rtl::OUString & rAddPurpose = ::rtl::OUString() );
  80
  81     /** Holds a mapping from the specified source to the specified destination.
  82
  83         @param pFrom        source environment
  84         @param pTo          destination environment
  85         @param rAddPurpose  additional purpose
  86     */
  87     inline Mapping(
  88         uno_Environment * pFrom, uno_Environment * pTo,
  89         const ::rtl::OUString & rAddPurpose = ::rtl::OUString() );
  90
  91     /** Holds a mapping from the specified source to the specified destination
  92         environment.
  93
  94         @param rFrom         source environment
  95         @param rTo           destination environment
  96         @param rAddPurpose  additional purpose
  97     */
  98     inline Mapping(const Environment & rFrom, const Environment & rTo,
  99                    const ::rtl::OUString & rAddPurpose = ::rtl::OUString() );
 100
 101     /** Constructor.
 102
 103         @param pMapping another mapping
 104     */
 105     inline Mapping( uno_Mapping * pMapping = NULL );
 106
 107     /** Copy constructor.
 108
 109         @param rMapping another mapping
 110     */
 111     inline Mapping( const Mapping & rMapping );
 112
 113     /** Destructor.
 114     */
 115     inline ~Mapping();
 116
 117     /** Sets a given mapping.
 118
 119         @param pMapping another mapping
 120         @return this mapping
 121     */
 122     inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping );
 123     /** Sets a given mapping.
 124
 125         @param rMapping another mapping
 126         @return this mapping
 127     */
 128     inline Mapping & SAL_CALL operator = ( const Mapping & rMapping )
 129         { return operator = ( rMapping._pMapping ); }
 130
 131     /** Provides a pointer to the C mapping. The returned mapping is NOT acquired!
 132
 133         @return UNacquired C mapping
 134     */
 135     inline uno_Mapping * SAL_CALL get() const
 136         { return _pMapping; }
 137
 138     /** Tests if a mapping is set.
 139
 140         @return true if a mapping is set
 141     */
 142     inline bool SAL_CALL is() const
 143         { return (_pMapping != NULL); }
 144
 145     /** Releases a set mapping.
 146     */
 147     inline void SAL_CALL clear();
 148
 149     /** Maps an interface from one environment to another.
 150
 151         @param pInterface       source interface
 152         @param pTypeDescr       type description of interface
 153         @return                 mapped interface
 154     */
 155     inline void * SAL_CALL mapInterface( void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const;
 156     /** Maps an interface from one environment to another.
 157
 158         @param pInterface       source interface
 159         @param pTypeDescr       type description of interface
 160         @return                 mapped interface
 161     */
 162     inline void * SAL_CALL mapInterface( void * pInterface, typelib_TypeDescription * pTypeDescr ) const
 163         { return mapInterface( pInterface, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTypeDescr) ); }
 164
 165     /** Maps an interface from one environment to another.
 166
 167         @param pInterface       source interface
 168         @param rType            type of interface
 169         @return                 mapped interface
 170     */
 171     inline void * SAL_CALL mapInterface(
 172         void * pInterface, const css::uno::Type & rType ) const;
 173
 174     /** Maps an interface from one environment to another.
 175
 176         @param ppOut            inout mapped interface
 177         @param pInterface       source interface
 178         @param pTypeDescr       type description of interface
 179     */
 180     inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const
 181         { (*_pMapping->mapInterface)( _pMapping, ppOut, pInterface, pTypeDescr ); }
 182     /** Maps an interface from one environment to another.
 183
 184         @param ppOut            inout mapped interface
 185         @param pInterface       source interface
 186         @param pTypeDescr       type description of interface
 187     */
 188     inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_TypeDescription * pTypeDescr ) const
 189         { (*_pMapping->mapInterface)( _pMapping, ppOut, pInterface, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTypeDescr) ); }
 190
 191     /** Maps an interface from one environment to another.
 192
 193         @param ppOut            inout mapped interface
 194         @param pInterface       source interface
 195         @param rType            type of interface to be mapped
 196      */
 197     inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, const css::uno::Type & rType ) const;
 198 };
 199
 200 inline Mapping::Mapping(
 201     const ::rtl::OUString & rFrom, const ::rtl::OUString & rTo, const ::rtl::OUString & rAddPurpose )
 202     : _pMapping( NULL )
 203 {
 204     uno_getMappingByName( &_pMapping, rFrom.pData, rTo.pData, rAddPurpose.pData );
 205 }
 206
 207 inline Mapping::Mapping(
 208     uno_Environment * pFrom, uno_Environment * pTo, const ::rtl::OUString & rAddPurpose )
 209     : _pMapping( NULL )
 210 {
 211     uno_getMapping( &_pMapping, pFrom, pTo, rAddPurpose.pData );
 212 }
 213
 214 inline Mapping::Mapping(
 215     const Environment & rFrom, const Environment & rTo, const ::rtl::OUString & rAddPurpose )
 216         : _pMapping(NULL)
 217 {
 218     uno_getMapping( &_pMapping, rFrom.get(), rTo.get(), rAddPurpose.pData );
 219 }
 220
 221 inline Mapping::Mapping( uno_Mapping * pMapping )
 222     : _pMapping( pMapping )
 223 {
 224     if (_pMapping)
 225         (*_pMapping->acquire)( _pMapping );
 226 }
 227
 228 inline Mapping::Mapping( const Mapping & rMapping )
 229     : _pMapping( rMapping._pMapping )
 230 {
 231     if (_pMapping)
 232         (*_pMapping->acquire)( _pMapping );
 233 }
 234
 235 inline Mapping::~Mapping()
 236 {
 237     if (_pMapping)
 238         (*_pMapping->release)( _pMapping );
 239 }
 240
 241 inline void Mapping::clear()
 242 {
 243     if (_pMapping)
 244     {
 245         (*_pMapping->release)( _pMapping );
 246         _pMapping = NULL;
 247     }
 248 }
 249
 250 inline Mapping & Mapping::operator = ( uno_Mapping * pMapping )
 251 {
 252     if (pMapping)
 253         (*pMapping->acquire)( pMapping );
 254     if (_pMapping)
 255         (*_pMapping->release)( _pMapping );
 256     _pMapping = pMapping;
 257     return *this;
 258 }
 259
 260 inline void Mapping::mapInterface(
 261     void ** ppOut, void * pInterface, const css::uno::Type & rType ) const
 262 {
 263     typelib_TypeDescription * pTD = NULL;
 264     TYPELIB_DANGER_GET( &pTD, rType.getTypeLibType() );
 265     if (pTD)
 266     {
 267         (*_pMapping->mapInterface)( _pMapping, ppOut, pInterface, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) );
 268         TYPELIB_DANGER_RELEASE( pTD );
 269     }
 270 }
 271
 272 inline void * Mapping::mapInterface(
 273     void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const
 274 {
 275     void * pOut = NULL;
 276     (*_pMapping->mapInterface)( _pMapping, &pOut, pInterface, pTypeDescr );
 277     return pOut;
 278 }
 279
 280 inline void * Mapping::mapInterface(
 281     void * pInterface, const css::uno::Type & rType ) const
 282 {
 283     void * pOut = NULL;
 284     mapInterface( &pOut, pInterface, rType );
 285     return pOut;
 286 }
 287
 288 /** Deprecated. This function DOES NOT WORK with Purpose Environments
 289     (http://wiki.openoffice.org/wiki/Uno/Binary/Spec/Purpose Environments)
 290
 291     Maps an binary C UNO interface to be used in the currently used compiler environment.
 292
 293     @tparam C interface type
 294     @param ppRet inout returned interface pointer
 295     @param pUnoI binary C UNO interface
 296     @return true if successful, false otherwise
 297
 298     @deprecated
 299 */
 300 template< class C >
 301 inline bool mapToCpp( Reference< C > * ppRet, uno_Interface * pUnoI )
 302 {
 303     Mapping aMapping(
 304         ::rtl::OUString( UNO_LB_UNO ),
 305         ::rtl::OUString( CPPU_CURRENT_LANGUAGE_BINDING_NAME ) );
 306     OSL_ASSERT( aMapping.is() );
 307     aMapping.mapInterface(
 308             reinterpret_cast<void **>(ppRet), pUnoI, ::cppu::getTypeFavourUnsigned( ppRet ) );
 309     return (0 != *ppRet);
 310 }
 311 /** Deprecated. This function DOES NOT WORK with Purpose Environments
 312     (http://wiki.openoffice.org/wiki/Uno/Binary/Spec/Purpose Environments)
 313
 314     Maps an UNO interface of the currently used compiler environment to binary C UNO.
 315
 316     @tparam C interface type
 317     @param ppRet inout returned interface pointer
 318     @param x interface reference
 319     @return true if successful, false otherwise
 320
 321     @deprecated
 322 */
 323 template< class C >
 324 inline bool mapToUno( uno_Interface ** ppRet, const Reference< C > & x )
 325 {
 326     Mapping aMapping(
 327         ::rtl::OUString( CPPU_CURRENT_LANGUAGE_BINDING_NAME ),
 328         ::rtl::OUString( UNO_LB_UNO ) );
 329     OSL_ASSERT( aMapping.is() );
 330     aMapping.mapInterface(
 331             reinterpret_cast<void **>(ppRet), x.get(), ::cppu::getTypeFavourUnsigned( &x ) );
 332     return (NULL != *ppRet);
 333 }
 334
 335 }
 336 }
 337 }
 338 }
 339
 340 #endif
 341
 342 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */