connectivity/source/drivers/hsqldb/HStorageMap.cxx

   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 #include "hsqldb/HStorageMap.hxx"
  21 #include <comphelper/types.hxx>
  22 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
  23 #include <com/sun/star/embed/XTransactedObject.hpp>
  24 #include <com/sun/star/embed/ElementModes.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <osl/diagnose.h>
  27 #include <osl/thread.h>
  28 #include <uno/mapping.hxx>
  29 #include <algorithm>
  30
  31 namespace connectivity
  32 {
  33
  34     namespace hsqldb
  35     {
  36
  37         using namespace ::com::sun::star::uno;
  38         using namespace ::com::sun::star::lang;
  39         using namespace ::com::sun::star::embed;
  40         using namespace ::com::sun::star::io;
  41
  42         StreamHelper::StreamHelper(const Reference< XStream>& _xStream)
  43             : m_xStream(_xStream)
  44         {
  45         }
  46
  47         StreamHelper::~StreamHelper()
  48         {
  49             try
  50             {
  51                 m_xStream.clear();
  52                 m_xSeek.clear();
  53                 if ( m_xInputStream.is() )
  54                 {
  55                     m_xInputStream->closeInput();
  56                     m_xInputStream.clear();
  57                 }
  58                 // this is done implicity by the closing of the input stream
  59                 else if ( m_xOutputStream.is() )
  60                 {
  61                     m_xOutputStream->closeOutput();
  62                     try
  63                     {
  64                         ::comphelper::disposeComponent(m_xOutputStream);
  65                     }
  66                     catch(const DisposedException&)
  67                     {
  68                     }
  69                     catch(const Exception&)
  70                     {
  71                         OSL_FAIL("Could not dispose OutputStream");
  72                     }
  73                     m_xOutputStream.clear();
  74                 }
  75             }
  76             catch(const Exception&)
  77             {
  78                 OSL_FAIL("Exception caught!");
  79             }
  80         }
  81
  82         Reference< XInputStream> const & StreamHelper::getInputStream()
  83         {
  84             if ( !m_xInputStream.is() )
  85                 m_xInputStream = m_xStream->getInputStream();
  86             return m_xInputStream;
  87         }
  88
  89         Reference< XOutputStream> const & StreamHelper::getOutputStream()
  90         {
  91             if ( !m_xOutputStream.is() )
  92                 m_xOutputStream = m_xStream->getOutputStream();
  93             return m_xOutputStream;
  94         }
  95
  96         Reference< XSeekable> const & StreamHelper::getSeek()
  97         {
  98             if ( !m_xSeek.is() )
  99                 m_xSeek.set(m_xStream,UNO_QUERY);
 100             return m_xSeek;
 101         }
 102
 103         css::uno::Reference<css::embed::XStorage> StorageData::mapStorage()
 104             const
 105         {
 106             css::uno::Environment env(css::uno::Environment::getCurrent());
 107             if (!(env.is() && storageEnvironment.is())) {
 108                 throw css::uno::RuntimeException("cannot get environments");
 109             }
 110             if (env.get() == storageEnvironment.get()) {
 111                 return storage;
 112             } else {
 113                 css::uno::Mapping map(storageEnvironment, env);
 114                 if (!map.is()) {
 115                     throw css::uno::RuntimeException("cannot get mapping");
 116                 }
 117                 css::uno::Reference<css::embed::XStorage> mapped;
 118                 map.mapInterface(
 119                     reinterpret_cast<void **>(&mapped), storage.get(),
 120                     cppu::UnoType<css::embed::XStorage>::get());
 121                 return mapped;
 122             }
 123         }
 124
 125         TStorages& lcl_getStorageMap()
 126         {
 127             static TStorages s_aMap;
 128             return s_aMap;
 129         }
 130
 131         OUString lcl_getNextCount()
 132         {
 133             static sal_Int32 s_nCount = 0;
 134             return OUString::number(s_nCount++);
 135         }
 136
 137         OUString StorageContainer::removeURLPrefix(const OUString& _sURL,const OUString& _sFileURL)
 138         {
 139             return _sURL.copy(_sFileURL.getLength()+1);
 140         }
 141
 142         OUString StorageContainer::removeOldURLPrefix(const OUString& _sURL)
 143         {
 144             OUString sRet = _sURL;
 145 #if defined(_WIN32)
 146             sal_Int32 nIndex = sRet.lastIndexOf('\\');
 147 #else
 148             sal_Int32 nIndex = sRet.lastIndexOf('/');
 149 #endif
 150             if ( nIndex != -1 )
 151             {
 152                 sRet = _sURL.copy(nIndex+1);
 153             }
 154             return sRet;
 155
 156         }
 157         /*****************************************************************************/
 158         /* convert jstring to rtl_uString */
 159
 160         OUString StorageContainer::jstring2ustring(JNIEnv * env, jstring jstr)
 161         {
 162             if (env->ExceptionCheck())
 163             {
 164                 env->ExceptionClear();
 165                 OSL_FAIL("ExceptionClear");
 166             }
 167             OUString aStr;
 168             if ( jstr )
 169             {
 170                 jboolean bCopy(true);
 171                 const jchar* pChar = env->GetStringChars(jstr,&bCopy);
 172                 jsize len = env->GetStringLength(jstr);
 173                 aStr = OUString(
 174                     reinterpret_cast<sal_Unicode const *>(pChar), len);
 175
 176                 if(bCopy)
 177                     env->ReleaseStringChars(jstr,pChar);
 178             }
 179
 180             if (env->ExceptionCheck())
 181             {
 182                 env->ExceptionClear();
 183                 OSL_FAIL("ExceptionClear");
 184             }
 185             return aStr;
 186         }
 187
 188
 189         OUString StorageContainer::registerStorage(const Reference< XStorage>& _xStorage,const OUString& _sURL)
 190         {
 191             OSL_ENSURE(_xStorage.is(),"Storage is NULL!");
 192             TStorages& rMap = lcl_getStorageMap();
 193             // check if the storage is already in our map
 194             TStorages::const_iterator aFind = ::std::find_if(rMap.begin(),rMap.end(),
 195                 [&_xStorage] (const TStorages::value_type& storage) {
 196                     return storage.second.mapStorage() == _xStorage;
 197                 });
 198
 199             if ( aFind == rMap.end() )
 200             {
 201                 aFind = rMap.insert(TStorages::value_type(lcl_getNextCount(), {_xStorage, css::uno::Environment::getCurrent(), _sURL, TStreamMap()})).first;
 202             }
 203
 204             return aFind->first;
 205         }
 206
 207         TStorages::mapped_type StorageContainer::getRegisteredStorage(const OUString& _sKey)
 208         {
 209             TStorages::mapped_type aRet;
 210             TStorages& rMap = lcl_getStorageMap();
 211             TStorages::const_iterator aFind = rMap.find(_sKey);
 212             OSL_ENSURE(aFind != rMap.end(),"Storage could not be found in list!");
 213             if ( aFind != rMap.end() )
 214                 aRet = aFind->second;
 215
 216             return aRet;
 217         }
 218
 219         OUString StorageContainer::getRegisteredKey(const Reference< XStorage>& _xStorage)
 220         {
 221             OUString sKey;
 222             OSL_ENSURE(_xStorage.is(),"Storage is NULL!");
 223             TStorages& rMap = lcl_getStorageMap();
 224             // check if the storage is already in our map
 225             TStorages::const_iterator aFind = ::std::find_if(rMap.begin(),rMap.end(),
 226                 [&_xStorage] (const TStorages::value_type& storage) {
 227                     return storage.second.mapStorage() == _xStorage;
 228                 });
 229
 230             if ( aFind != rMap.end() )
 231                 sKey = aFind->first;
 232             return sKey;
 233         }
 234
 235         void StorageContainer::revokeStorage(const OUString& _sKey,const Reference<XTransactionListener>& _xListener)
 236         {
 237             TStorages& rMap = lcl_getStorageMap();
 238             TStorages::iterator aFind = rMap.find(_sKey);
 239             if ( aFind != rMap.end() )
 240             {
 241                 try
 242                 {
 243                     if ( _xListener.is() )
 244                     {
 245                         Reference<XTransactionBroadcaster> xBroad(aFind->second.mapStorage(),UNO_QUERY);
 246                         if ( xBroad.is() )
 247                             xBroad->removeTransactionListener(_xListener);
 248                         Reference<XTransactedObject> xTrans(aFind->second.mapStorage(),UNO_QUERY);
 249                         if ( xTrans.is() )
 250                             xTrans->commit();
 251                     }
 252                 }
 253                 catch(const Exception&)
 254                 {
 255                 }
 256                 rMap.erase(aFind);
 257             }
 258         }
 259
 260         TStreamMap::mapped_type StorageContainer::registerStream(JNIEnv * env,jstring name, jstring key,sal_Int32 _nMode)
 261         {
 262             TStreamMap::mapped_type pHelper;
 263             TStorages& rMap = lcl_getStorageMap();
 264             OUString sKey = jstring2ustring(env,key);
 265             TStorages::iterator aFind = rMap.find(sKey);
 266             OSL_ENSURE(aFind != rMap.end(),"Storage could not be found in list!");
 267             if ( aFind != rMap.end() )
 268             {
 269                 TStorages::mapped_type aStoragePair = StorageContainer::getRegisteredStorage(sKey);
 270                 auto storage = aStoragePair.mapStorage();
 271                 OSL_ENSURE(storage.is(),"No Storage available!");
 272                 if ( storage.is() )
 273                 {
 274                     OUString sOrgName = StorageContainer::jstring2ustring(env,name);
 275                     OUString sName = removeURLPrefix(sOrgName,aStoragePair.url);
 276                     TStreamMap::iterator aStreamFind = aFind->second.streams.find(sName);
 277                     OSL_ENSURE( aStreamFind == aFind->second.streams.end(),"A Stream was already registered for this object!");
 278                     if ( aStreamFind != aFind->second.streams.end() )
 279                     {
 280                         pHelper = aStreamFind->second;
 281                     }
 282                     else
 283                     {
 284                         try
 285                         {
 286                             try
 287                             {
 288                                 pHelper.reset(new StreamHelper(storage->openStreamElement(sName,_nMode)));
 289                             }
 290                             catch(const Exception&)
 291                             {
 292                                 OUString sStrippedName = removeOldURLPrefix(sOrgName);
 293
 294                                 if ( ((_nMode & ElementModes::WRITE) != ElementModes::WRITE ) )
 295                                 {
 296                                     bool bIsStream = true;
 297                                     try
 298                                     {
 299                                        bIsStream = storage->isStreamElement(sStrippedName);
 300                                     }
 301                                     catch(const Exception&)
 302                                     {
 303                                         bIsStream = false;
 304                                     }
 305                                     if ( !bIsStream )
 306                                         return pHelper; // readonly file without data stream
 307                                 }
 308                                 pHelper.reset( new StreamHelper(storage->openStreamElement( sStrippedName, _nMode ) ) );
 309                             }
 310                             aFind->second.streams.insert(TStreamMap::value_type(sName,pHelper));
 311                         }
 312                         catch(const Exception& e)
 313                         {
 314 #if OSL_DEBUG_LEVEL > 0
 315                             OString sMessage( "[HSQLDB-SDBC] caught an exception while opening a stream\n" );
 316                             sMessage += "Name: ";
 317                             sMessage += OString( sName.getStr(), sName.getLength(), osl_getThreadTextEncoding() );
 318                             sMessage += "\nMode: 0x";
 319                             if ( _nMode < 16 )
 320                                 sMessage += "0";
 321                             sMessage += OString::number( _nMode, 16 ).toAsciiUpperCase();
 322                             OSL_FAIL( sMessage.getStr() );
 323 #endif
 324                             StorageContainer::throwJavaException(e,env);
 325                         }
 326                     }
 327                 }
 328             }
 329             return pHelper;
 330         }
 331
 332         void StorageContainer::revokeStream( JNIEnv * env,jstring name, jstring key)
 333         {
 334             TStorages& rMap = lcl_getStorageMap();
 335             TStorages::iterator aFind = rMap.find(jstring2ustring(env,key));
 336             OSL_ENSURE(aFind != rMap.end(),"Storage could not be found in list!");
 337             if ( aFind != rMap.end() )
 338                 aFind->second.streams.erase(removeURLPrefix(jstring2ustring(env,name),aFind->second.url));
 339         }
 340
 341         TStreamMap::mapped_type StorageContainer::getRegisteredStream( JNIEnv * env,jstring name, jstring key)
 342         {
 343             TStreamMap::mapped_type  pRet;
 344             TStorages& rMap = lcl_getStorageMap();
 345             TStorages::const_iterator aFind = rMap.find(jstring2ustring(env,key));
 346             OSL_ENSURE(aFind != rMap.end(),"Storage could not be found in list!");
 347             if ( aFind != rMap.end() )
 348             {
 349                 TStreamMap::const_iterator aStreamFind = aFind->second.streams.find(removeURLPrefix(jstring2ustring(env,name),aFind->second.url));
 350                 if ( aStreamFind != aFind->second.streams.end() )
 351                     pRet = aStreamFind->second;
 352             }
 353
 354             return pRet;
 355         }
 356
 357         void StorageContainer::throwJavaException(const Exception& _aException,JNIEnv * env)
 358         {
 359             if (env->ExceptionCheck())
 360                 env->ExceptionClear();
 361             OString cstr( OUStringToOString(_aException.Message, RTL_TEXTENCODING_JAVA_UTF8 ) );
 362             OSL_TRACE( __FILE__": forwarding Exception: %s", cstr.getStr() );
 363             env->ThrowNew(env->FindClass("java/io/IOException"), cstr.getStr());
 364         }
 365
 366     }   // namespace hsqldb
 367
 368
 369 }
 370 // namespace connectivity
 371
 372
 373 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */