include/cppuhelper/implbase2.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
  20 /*
  21  * This file is part of LibreOffice published API.
  22  */
  23 #ifndef INCLUDED_CPPUHELPER_IMPLBASE2_HXX
  24 #define INCLUDED_CPPUHELPER_IMPLBASE2_HXX
  25
  26 #include "cppuhelper/implbase_ex.hxx"
  27 #include "rtl/instance.hxx"
  28 #include "cppuhelper/weak.hxx"
  29 #include "cppuhelper/weakagg.hxx"
  30 #include "com/sun/star/lang/XTypeProvider.hpp"
  31
  32 namespace cppu
  33 {
  34     /// @cond INTERNAL
  35
  36     struct class_data2
  37     {
  38         sal_Int16 m_nTypes;
  39         sal_Bool m_storedTypeRefs;
  40         sal_Bool m_storedId;
  41         sal_Int8 m_id[ 16 ];
  42         type_entry m_typeEntries[ 2 + 1 ];
  43     };
  44
  45     template< typename Ifc1, typename Ifc2, typename Impl > struct SAL_WARN_UNUSED ImplClassData2
  46     {
  47         class_data* operator ()()
  48         {
  49             static class_data2 s_cd =
  50             {
  51                 2 +1, false, false,
  52                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  53                 {
  54                     CPPUHELPER_DETAIL_TYPEENTRY(Ifc1),
  55                     CPPUHELPER_DETAIL_TYPEENTRY(Ifc2),
  56                     CPPUHELPER_DETAIL_TYPEENTRY(css::lang::XTypeProvider)
  57                 }
  58             };
  59             return reinterpret_cast< class_data * >(&s_cd);
  60         }
  61     };
  62
  63     /// @endcond
  64
  65     /** Implementation helper implementing interface css::lang::XTypeProvider
  66         and queryInterface(), but no reference counting.
  67
  68         @derive
  69         Inherit from this class giving your interface(s) to be implemented as template argument(s).
  70         Your base class defines method implementations, acquire(), release() and delegates incoming
  71         queryInterface() calls to this base class.
  72     */
  73     template< class Ifc1, class Ifc2 >
  74     class SAL_NO_VTABLE SAL_DLLPUBLIC_TEMPLATE ImplHelper2
  75         : public css::lang::XTypeProvider
  76         , public Ifc1, public Ifc2
  77     {
  78         struct cd : public rtl::StaticAggregate< class_data, ImplClassData2 < Ifc1, Ifc2, ImplHelper2<Ifc1, Ifc2> > > {};
  79     public:
  80 #if defined LIBO_INTERNAL_ONLY
  81         ImplHelper2() = default;
  82         ImplHelper2(ImplHelper2 const &) = default;
  83         ImplHelper2(ImplHelper2 &&) = default;
  84         ImplHelper2 & operator =(ImplHelper2 const &) = default;
  85         ImplHelper2 & operator =(ImplHelper2 &&) = default;
  86 #endif
  87
  88         virtual css::uno::Any SAL_CALL queryInterface( css::uno::Type const & rType ) SAL_OVERRIDE
  89             { return ImplHelper_query( rType, cd::get(), this ); }
  90         virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() SAL_OVERRIDE
  91             { return ImplHelper_getTypes( cd::get() ); }
  92         virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() SAL_OVERRIDE
  93             { return ImplHelper_getImplementationId( cd::get() ); }
  94
  95 #if !defined _MSC_VER // public -> protected changes mangled names there
  96     protected:
  97 #endif
  98         ~ImplHelper2() SAL_NOEXCEPT {}
  99     };
 100     /** Implementation helper implementing interfaces css::lang::XTypeProvider and
 101         css::uno::XInterface which supports weak mechanism to be held weakly
 102         (supporting css::uno::XWeak through ::cppu::OWeakObject).
 103
 104         @derive
 105         Inherit from this class giving your interface(s) to be implemented as template argument(s).
 106         Your sub class defines method implementations for these interface(s).
 107     */
 108     template< class Ifc1, class Ifc2 >
 109     class SAL_NO_VTABLE SAL_DLLPUBLIC_TEMPLATE SAL_DLLPUBLIC_EXPORT WeakImplHelper2
 110         : public OWeakObject
 111         , public css::lang::XTypeProvider
 112         , public Ifc1, public Ifc2
 113     {
 114         struct cd : public rtl::StaticAggregate< class_data, ImplClassData2 < Ifc1, Ifc2, WeakImplHelper2<Ifc1, Ifc2> > > {};
 115     public:
 116         virtual css::uno::Any SAL_CALL queryInterface( css::uno::Type const & rType ) SAL_OVERRIDE
 117             { return WeakImplHelper_query( rType, cd::get(), this, static_cast<OWeakObject *>(this) ); }
 118         virtual void SAL_CALL acquire() SAL_NOEXCEPT SAL_OVERRIDE
 119             { OWeakObject::acquire(); }
 120         virtual void SAL_CALL release() SAL_NOEXCEPT SAL_OVERRIDE
 121             { OWeakObject::release(); }
 122         virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() SAL_OVERRIDE
 123             { return WeakImplHelper_getTypes( cd::get() ); }
 124         virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() SAL_OVERRIDE
 125             { return ImplHelper_getImplementationId( cd::get() ); }
 126     };
 127     /** Implementation helper implementing interfaces css::lang::XTypeProvider and
 128         css::uno::XInterface which supports weak mechanism to be held weakly
 129         (supporting css::uno::XWeak through ::cppu::OWeakAggObject).
 130         In addition, it supports also aggregation meaning object of this class can be aggregated
 131         (css::uno::XAggregation through ::cppu::OWeakAggObject).
 132         If a delegator is set (this object is aggregated), then incoming queryInterface()
 133         calls are delegated to the delegator object. If the delegator does not support the
 134         demanded interface, it calls queryAggregation() on its aggregated objects.
 135
 136         @derive
 137         Inherit from this class giving your interface(s) to be implemented as template argument(s).
 138         Your sub class defines method implementations for these interface(s).
 139     */
 140     template< class Ifc1, class Ifc2 >
 141     class SAL_NO_VTABLE SAL_DLLPUBLIC_TEMPLATE WeakAggImplHelper2
 142         : public OWeakAggObject
 143         , public css::lang::XTypeProvider
 144         , public Ifc1, public Ifc2
 145     {
 146         struct cd : public rtl::StaticAggregate< class_data, ImplClassData2 < Ifc1, Ifc2, WeakAggImplHelper2<Ifc1, Ifc2> > > {};
 147     public:
 148         virtual css::uno::Any SAL_CALL queryInterface( css::uno::Type const & rType ) SAL_OVERRIDE
 149             { return OWeakAggObject::queryInterface( rType ); }
 150         virtual css::uno::Any SAL_CALL queryAggregation( css::uno::Type const & rType ) SAL_OVERRIDE
 151             { return WeakAggImplHelper_queryAgg( rType, cd::get(), this, static_cast<OWeakAggObject *>(this) ); }
 152         virtual void SAL_CALL acquire() SAL_NOEXCEPT SAL_OVERRIDE
 153             { OWeakAggObject::acquire(); }
 154         virtual void SAL_CALL release() SAL_NOEXCEPT SAL_OVERRIDE
 155             { OWeakAggObject::release(); }
 156         virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() SAL_OVERRIDE
 157             { return WeakAggImplHelper_getTypes( cd::get() ); }
 158         virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() SAL_OVERRIDE
 159             { return ImplHelper_getImplementationId( cd::get() ); }
 160     };
 161     /** Implementation helper implementing interfaces css::lang::XTypeProvider and
 162         css::uno::XInterface inheriting from a BaseClass.
 163         All acquire() and release() calls are delegated to the BaseClass. Upon queryInterface(),
 164         if a demanded interface is not supported by this class directly, the request is
 165         delegated to the BaseClass.
 166
 167         @attention
 168         The BaseClass has to be complete in a sense, that css::uno::XInterface
 169         and css::lang::XTypeProvider are implemented properly.  The
 170         BaseClass must have at least one ctor that can be called with six or
 171         fewer arguments, of which none is of non-const reference type.
 172
 173         @derive
 174         Inherit from this class giving your additional interface(s) to be implemented as
 175         template argument(s). Your sub class defines method implementations for these interface(s).
 176     */
 177     template< class BaseClass, class Ifc1, class Ifc2 >
 178     class SAL_NO_VTABLE SAL_DLLPUBLIC_TEMPLATE ImplInheritanceHelper2
 179         : public BaseClass
 180         , public Ifc1, public Ifc2
 181     {
 182         struct cd : public rtl::StaticAggregate< class_data, ImplClassData2 < Ifc1, Ifc2, ImplInheritanceHelper2<BaseClass, Ifc1, Ifc2> > > {};
 183     protected:
 184         template< typename T1 >
 185         explicit ImplInheritanceHelper2(T1 const & arg1): BaseClass(arg1) {}
 186         template< typename T1, typename T2 >
 187         ImplInheritanceHelper2(T1 const & arg1, T2 const & arg2):
 188             BaseClass(arg1, arg2) {}
 189         template< typename T1, typename T2, typename T3 >
 190         ImplInheritanceHelper2(
 191             T1 const & arg1, T2 const & arg2, T3 const & arg3):
 192             BaseClass(arg1, arg2, arg3) {}
 193         template< typename T1, typename T2, typename T3, typename T4 >
 194         ImplInheritanceHelper2(
 195             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4):
 196             BaseClass(arg1, arg2, arg3, arg4) {}
 197         template<
 198             typename T1, typename T2, typename T3, typename T4, typename T5 >
 199         ImplInheritanceHelper2(
 200             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4,
 201             T5 const & arg5):
 202             BaseClass(arg1, arg2, arg3, arg4, arg5) {}
 203         template<
 204             typename T1, typename T2, typename T3, typename T4, typename T5,
 205             typename T6 >
 206         ImplInheritanceHelper2(
 207             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4,
 208             T5 const & arg5, T6 const & arg6):
 209             BaseClass(arg1, arg2, arg3, arg4, arg5, arg6) {}
 210     public:
 211         ImplInheritanceHelper2() {}
 212         virtual css::uno::Any SAL_CALL queryInterface( css::uno::Type const & rType ) SAL_OVERRIDE
 213             {
 214                 css::uno::Any aRet( ImplHelper_queryNoXInterface( rType, cd::get(), this ) );
 215                 if (aRet.hasValue())
 216                     return aRet;
 217                 return BaseClass::queryInterface( rType );
 218             }
 219         virtual void SAL_CALL acquire() SAL_NOEXCEPT SAL_OVERRIDE
 220             { BaseClass::acquire(); }
 221         virtual void SAL_CALL release() SAL_NOEXCEPT SAL_OVERRIDE
 222             { BaseClass::release(); }
 223         virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() SAL_OVERRIDE
 224             { return ImplInhHelper_getTypes( cd::get(), BaseClass::getTypes() ); }
 225         virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() SAL_OVERRIDE
 226             { return ImplHelper_getImplementationId( cd::get() ); }
 227     };
 228     /** Implementation helper implementing interfaces css::lang::XTypeProvider and
 229         css::uno::XInterface inheriting from a BaseClass.
 230         All acquire(),  release() and queryInterface() calls are delegated to the BaseClass.
 231         Upon queryAggregation(), if a demanded interface is not supported by this class directly,
 232         the request is delegated to the BaseClass.
 233
 234         @attention
 235         The BaseClass has to be complete in a sense, that css::uno::XInterface,
 236         css::uno::XAggregation and css::lang::XTypeProvider
 237         are implemented properly.  The BaseClass must have at least one ctor
 238         that can be called with six or fewer arguments, of which none is of
 239         non-const reference type.
 240
 241         @derive
 242         Inherit from this class giving your additional interface(s) to be implemented as
 243         template argument(s). Your sub class defines method implementations for these interface(s).
 244     */
 245     template< class BaseClass, class Ifc1, class Ifc2 >
 246     class SAL_NO_VTABLE SAL_DLLPUBLIC_TEMPLATE AggImplInheritanceHelper2
 247         : public BaseClass
 248         , public Ifc1, public Ifc2
 249     {
 250         struct cd : public rtl::StaticAggregate< class_data, ImplClassData2 < Ifc1, Ifc2, AggImplInheritanceHelper2<BaseClass, Ifc1, Ifc2> > > {};
 251     protected:
 252         template< typename T1 >
 253         explicit AggImplInheritanceHelper2(T1 const & arg1): BaseClass(arg1) {}
 254         template< typename T1, typename T2 >
 255         AggImplInheritanceHelper2(T1 const & arg1, T2 const & arg2):
 256             BaseClass(arg1, arg2) {}
 257         template< typename T1, typename T2, typename T3 >
 258         AggImplInheritanceHelper2(
 259             T1 const & arg1, T2 const & arg2, T3 const & arg3):
 260             BaseClass(arg1, arg2, arg3) {}
 261         template< typename T1, typename T2, typename T3, typename T4 >
 262         AggImplInheritanceHelper2(
 263             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4):
 264             BaseClass(arg1, arg2, arg3, arg4) {}
 265         template<
 266             typename T1, typename T2, typename T3, typename T4, typename T5 >
 267         AggImplInheritanceHelper2(
 268             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4,
 269             T5 const & arg5):
 270             BaseClass(arg1, arg2, arg3, arg4, arg5) {}
 271         template<
 272             typename T1, typename T2, typename T3, typename T4, typename T5,
 273             typename T6 >
 274         AggImplInheritanceHelper2(
 275             T1 const & arg1, T2 const & arg2, T3 const & arg3, T4 const & arg4,
 276             T5 const & arg5, T6 const & arg6):
 277             BaseClass(arg1, arg2, arg3, arg4, arg5, arg6) {}
 278     public:
 279         AggImplInheritanceHelper2() {}
 280         virtual css::uno::Any SAL_CALL queryInterface( css::uno::Type const & rType ) SAL_OVERRIDE
 281             { return BaseClass::queryInterface( rType ); }
 282         virtual css::uno::Any SAL_CALL queryAggregation( css::uno::Type const & rType ) SAL_OVERRIDE
 283             {
 284                 css::uno::Any aRet( ImplHelper_queryNoXInterface( rType, cd::get(), this ) );
 285                 if (aRet.hasValue())
 286                     return aRet;
 287                 return BaseClass::queryAggregation( rType );
 288             }
 289         virtual void SAL_CALL acquire() SAL_NOEXCEPT SAL_OVERRIDE
 290             { BaseClass::acquire(); }
 291         virtual void SAL_CALL release() SAL_NOEXCEPT SAL_OVERRIDE
 292             { BaseClass::release(); }
 293         virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() SAL_OVERRIDE
 294             { return ImplInhHelper_getTypes( cd::get(), BaseClass::getTypes() ); }
 295         virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() SAL_OVERRIDE
 296             { return ImplHelper_getImplementationId( cd::get() ); }
 297     };
 298 }
 299
 300 #endif
 301
 302 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */