include/uno/environment.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_ENVIRONMENT_HXX
  20 #define INCLUDED_UNO_ENVIRONMENT_HXX
  21
  22 #include <sal/config.h>
  23
  24 #include <cstddef>
  25
  26 #include <rtl/alloc.h>
  27 #include <rtl/ustring.hxx>
  28 #include <uno/environment.h>
  29
  30 #include <uno/lbnames.h>
  31
  32 /** */ //for docpp
  33 namespace com
  34 {
  35 /** */ //for docpp
  36 namespace sun
  37 {
  38 /** */ //for docpp
  39 namespace star
  40 {
  41 /** */ //for docpp
  42 namespace uno
  43 {
  44
  45 /** C++ wrapper for binary C uno_Environment.
  46
  47     @see uno_Environment
  48 */
  49 class Environment
  50 {
  51     /** binary C uno_Environment
  52     */
  53     uno_Environment * _pEnv;
  54
  55 public:
  56     /** Returns the current Environment.
  57
  58         @param typeName   the optional type of the Environment, falls back to "uno" in case being empty,
  59                           respectively to current C++ Environment.
  60         @since UDK 3.2.7
  61     */
  62     inline static Environment getCurrent(rtl::OUString const & typeName = rtl::OUString(CPPU_CURRENT_LANGUAGE_BINDING_NAME));
  63
  64     /// @cond INTERNAL
  65     // these are here to force memory de/allocation to sal lib.
  66     static void * SAL_CALL operator new ( size_t nSize )
  67         { return ::rtl_allocateMemory( nSize ); }
  68     static void SAL_CALL operator delete ( void * pMem )
  69         { ::rtl_freeMemory( pMem ); }
  70     static void * SAL_CALL operator new ( size_t, void * pMem )
  71         { return pMem; }
  72     static void SAL_CALL operator delete ( void *, void * )
  73         {}
  74     /// @endcond
  75
  76     /** Constructor: acquires given environment
  77
  78         @param pEnv environment
  79     */
  80     inline Environment( uno_Environment * pEnv = NULL );
  81
  82     /** Gets a specific environment. If the specified environment does not exist, then a default one
  83         is created and registered.
  84
  85         @param envDcp           descriptor of the environment
  86         @param pContext         context pointer
  87     */
  88     inline explicit Environment( rtl::OUString const & envDcp, void * pContext = NULL );
  89
  90
  91     /** Copy constructor: acquires given environment
  92
  93         @param rEnv another environment
  94     */
  95     inline Environment( const Environment & rEnv );
  96
  97 #if defined LIBO_INTERNAL_ONLY
  98     Environment(Environment && other): _pEnv(other._pEnv)
  99     { other._pEnv = nullptr; }
 100 #endif
 101
 102     /** Destructor: releases a set environment.
 103     */
 104     inline ~Environment();
 105
 106     /** Sets a given environment, i.e. acquires given one and releases a set one.
 107
 108         @param pEnv another environment
 109         @return this environment
 110     */
 111     inline Environment & SAL_CALL operator = ( uno_Environment * pEnv );
 112     /** Sets a given environment, i.e. acquires given one and releases a set one.
 113
 114         @param rEnv another environment
 115         @return this environment
 116     */
 117     Environment & SAL_CALL operator = ( const Environment & rEnv )
 118         { return operator = ( rEnv._pEnv ); }
 119
 120 #if defined LIBO_INTERNAL_ONLY
 121     Environment & operator =(Environment && other) {
 122         if (_pEnv != nullptr) {
 123             (*_pEnv->release)(_pEnv);
 124         }
 125         _pEnv = other._pEnv;
 126         other._pEnv = nullptr;
 127         return *this;
 128     }
 129 #endif
 130
 131     /** Provides UNacquired pointer to the set C environment.
 132
 133         @return UNacquired pointer to the C environment struct
 134     */
 135     uno_Environment * SAL_CALL get() const
 136         { return _pEnv; }
 137
 138     /** Gets type name of set environment.
 139
 140         @return type name of set environment
 141     */
 142     ::rtl::OUString SAL_CALL getTypeName() const
 143         { return _pEnv->pTypeName; }
 144
 145     /** Gets free context pointer of set environment.
 146
 147         @return free context pointer of set environment
 148     */
 149     void * SAL_CALL getContext() const
 150         { return _pEnv->pContext; }
 151
 152     /** Tests if a environment is set.
 153
 154         @return true, if a environment is set, false otherwise
 155     */
 156     bool SAL_CALL is() const
 157         { return (_pEnv != NULL); }
 158
 159     /** Releases a set environment.
 160     */
 161     inline void SAL_CALL clear();
 162
 163     /** Invoke the passed function in this environment.
 164
 165         @param pCallee  the function to call
 166         @param pParam   the parameter pointer to be passed to the function
 167         @since UDK 3.2.7
 168     */
 169     inline void SAL_CALL invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const;
 170
 171     /** Invoke the passed function in this environment.
 172
 173         @param pCallee  the function to call
 174         @param ...      the parameters to be passed to the function
 175         @since UDK 3.2.7
 176     */
 177     inline void SAL_CALL invoke(uno_EnvCallee * pCallee, ...) const;
 178
 179     /** Enter this environment explicitly.
 180
 181         @since UDK 3.2.7
 182     */
 183     inline void SAL_CALL enter() const;
 184
 185     /** Checks, if it is valid to currently call objects
 186         belonging to this environment.
 187
 188         @since UDK 3.2.7
 189     */
 190     inline int  SAL_CALL isValid(rtl::OUString * pReason) const;
 191 };
 192
 193 inline Environment::Environment( uno_Environment * pEnv )
 194     : _pEnv( pEnv )
 195 {
 196     if (_pEnv)
 197         (*_pEnv->acquire)( _pEnv );
 198 }
 199
 200 inline Environment::Environment( rtl::OUString const & rEnvDcp, void * pContext )
 201     : _pEnv(NULL)
 202 {
 203     uno_getEnvironment(&_pEnv, rEnvDcp.pData, pContext);
 204 }
 205
 206 inline Environment::Environment( const Environment & rEnv )
 207     : _pEnv( rEnv._pEnv )
 208 {
 209     if (_pEnv)
 210         (*_pEnv->acquire)( _pEnv );
 211 }
 212
 213 inline Environment::~Environment()
 214 {
 215     if (_pEnv)
 216         (*_pEnv->release)( _pEnv );
 217 }
 218
 219 inline void Environment::clear()
 220 {
 221     if (_pEnv)
 222     {
 223         (*_pEnv->release)( _pEnv );
 224         _pEnv = NULL;
 225     }
 226 }
 227
 228 inline Environment & Environment::operator = ( uno_Environment * pEnv )
 229 {
 230     if (pEnv != _pEnv)
 231     {
 232         if (pEnv)
 233             (*pEnv->acquire)( pEnv );
 234         if (_pEnv)
 235             (*_pEnv->release)( _pEnv );
 236         _pEnv = pEnv;
 237     }
 238     return *this;
 239 }
 240
 241 inline void SAL_CALL Environment::invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const
 242 {
 243     if (_pEnv)
 244         uno_Environment_invoke_v(_pEnv, pCallee, pParam);
 245 }
 246
 247 inline void SAL_CALL Environment::invoke(uno_EnvCallee * pCallee, ...) const
 248 {
 249     if (_pEnv)
 250     {
 251         va_list param;
 252
 253         va_start(param, pCallee);
 254         uno_Environment_invoke_v(_pEnv, pCallee, &param);
 255         va_end(param);
 256     }
 257
 258 }
 259
 260 inline void SAL_CALL Environment::enter() const
 261 {
 262     uno_Environment_enter(_pEnv);
 263 }
 264
 265 inline int  SAL_CALL Environment::isValid(rtl::OUString * pReason) const
 266 {
 267     return uno_Environment_isValid(_pEnv, &pReason->pData);
 268 }
 269
 270 inline Environment Environment::getCurrent(rtl::OUString const & typeName)
 271 {
 272     Environment environment;
 273
 274     uno_Environment * pEnv = NULL;
 275     uno_getCurrentEnvironment(&pEnv, typeName.pData);
 276     environment = pEnv;
 277     if (pEnv)
 278         pEnv->release(pEnv);
 279
 280     return environment;
 281 }
 282
 283 }
 284 }
 285 }
 286 }
 287
 288 #endif
 289
 290 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */