Providing a Single Factory Using a Helper Method

From Apache OpenOffice Wiki
< Documentation‎ | DevGuide
Revision as of 09:43, 13 May 2009 by OOoWikiBot (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search



C++ component libraries must export an external "C" function called component_getFactory() that supplies a factory object for the given implementation. Use ::cppu::component_getFactoryHelper() to create this function. The declarations for it are included through cppuhelper/implementationentry.hxx.

The component_getFactory() method appears at the end of the following listing. This method assumes that the component includes a static ::cppu::ImplementationEntry array s_component_entries[], which contains a number of function pointers. The listing shows how to write the component, so that the function pointers for all services of a multi-service component are correctly initialized.

  #include <cppuhelper/implbase3.hxx> // "3" implementing three interfaces
  #include <cppuhelper/factory.hxx>
  #include <cppuhelper/implementationentry.hxx>
 
  #include <com/sun/star/lang/XServiceInfo.hpp>
  #include <com/sun/star/lang/XInitialization.hpp>
  #include <com/sun/star/lang/IllegalArgumentException.hpp>
  #include <my_module/XSomething.hpp>
 
 
  using namespace ::rtl; // for OUString
  using namespace ::com::sun::star; // for sdk interfaces
  using namespace ::com::sun::star::uno; // for basic types
 
 
  namespace my_sc_impl
  {
 
  class MyService2Impl : public ::cppu::WeakImplHelper3<
        ::my_module::XSomething, lang::XServiceInfo, lang::XInitialization >
  {
      OUString m_arg;
  public:
      // focus on three given interfaces,
      // no need to implement XInterface, XTypeProvider, XWeak
 
      // XInitialization will be called upon createInstanceWithArguments[AndContext]()
      virtual void SAL_CALL initialize( Sequence< Any > const & args )
          throw (Exception);
      // XSomething
      virtual OUString SAL_CALL methodOne( OUString const & str )
          throw (RuntimeException);
      // XServiceInfo
      virtual OUString SAL_CALL getImplementationName()
          throw (RuntimeException);
      virtual sal_Bool SAL_CALL supportsService( OUString const & serviceName )
          throw (RuntimeException);
      virtual Sequence< OUString > SAL_CALL getSupportedServiceNames()
          throw (RuntimeException);
  };
 
  // Implementation of XSomething, XServiceInfo and XInitilization omitted here:
  ...
 
  // component operations from service1_impl.cxx
  extern Sequence< OUString > SAL_CALL getSupportedServiceNames_MyService1Impl();
  extern OUString SAL_CALL getImplementationName_MyService1Impl();
  extern Reference< XInterface > SAL_CALL create_MyService1Impl(
                                          Reference< XComponentContext > const & xContext )
                                              SAL_THROW( () );
  // component operations for MyService2Impl
  static Sequence< OUString > getSupportedServiceNames_MyService2Impl()
  {
      Sequence<OUString> names(1);
      names[0] = OUString(RTL_CONSTASCII_USTRINGPARAM("my_module.MyService2"));
      return names;
  }
 
  static OUString getImplementationName_MyService2Impl()
  {
      return OUString( RTL_CONSTASCII_USTRINGPARAM(
                           "my_module.my_sc_implementation.MyService2") );
  }
 
 
  Reference< XInterface > SAL_CALL create_MyService2Impl(
      Reference< XComponentContext > const & xContext )
      SAL_THROW( () )
  {
        return static_cast< lang::XTypeProvider * >( new MyService2Impl() );
  }
  /* shared lib exports implemented without helpers in service_impl1.cxx */
namespace my_sc_impl
{
static struct ::cppu::ImplementationEntry s_component_entries [] =  
  {
      {
          create_MyService1Impl, getImplementationName_MyService1Impl,
          getSupportedServiceNames_MyService1Impl, ::cppu::createSingleComponentFactory,
          0, 0
      },
      {
          create_MyService2Impl, getImplementationName_MyService2Impl,
          getSupportedServiceNames_MyService2Impl, ::cppu::createSingleComponentFactory,
          0, 0
      },
      { 0, 0, 0, 0, 0, 0 }
  };
  }
 
  extern "C"
  {
  void * SAL_CALL component_getFactory(
      sal_Char const * implName, lang::XMultiServiceFactory * xMgr,
      registry::XRegistryKey * xRegistry )
  {
      return ::cppu::component_getFactoryHelper(
          implName, xMgr, xRegistry, ::my_sc_impl::s_component_entries );
  }
 
  // getImplementationEnvironment and component_writeInfo are described later, we omit  them here
  ...
  }

The static variable s_component_entries defines a null-terminated array of entries concerning the service implementations of the shared library. A service implementation entry consists of function pointers for

  • object creation: create_MyServiceXImpl()
  • implementation name: getImplementationName_MyServiceXImpl()
  • supported service names: getSupportedServiceNames_MyServiceXImpl()
  • factory helper to be used: ::cppu::createComponentFactory()

The last two values are reserved for future use and therefore can be 0.

Content on this page is licensed under the Public Documentation License (PDL).
Personal tools
In other languages