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