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