sot/source/unoolestorage/xolesimplestorage.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 "xolesimplestorage.hxx"
  21
  22 #include <com/sun/star/embed/OLESimpleStorage.hpp>
  23 #include <com/sun/star/lang/DisposedException.hpp>
  24 #include <com/sun/star/lang/NoSupportException.hpp>
  25 #include <com/sun/star/io/IOException.hpp>
  26 #include <com/sun/star/io/XStream.hpp>
  27 #include <com/sun/star/io/XInputStream.hpp>
  28 #include <com/sun/star/io/XSeekable.hpp>
  29 #include <com/sun/star/io/XTruncate.hpp>
  30 #include <com/sun/star/io/TempFile.hpp>
  31
  32 #include <comphelper/storagehelper.hxx>
  33 #include <unotools/ucbstreamhelper.hxx>
  34 #include <cppuhelper/exc_hlp.hxx>
  35 #include <cppuhelper/supportsservice.hxx>
  36 #include <sot/stg.hxx>
  37 #include <sot/storinfo.hxx>
  38 #include <utility>
  39
  40 using namespace ::com::sun::star;
  41
  42 const sal_Int32 nBytesCount = 32000;
  43
  44
  45 OLESimpleStorage::OLESimpleStorage(
  46         css::uno::Reference<css::uno::XComponentContext> xContext,
  47         css::uno::Sequence<css::uno::Any> const &aArguments)
  48 : m_bDisposed( false )
  49 , m_xContext(std::move( xContext ))
  50 , m_bNoTemporaryCopy( false )
  51 {
  52     sal_Int32 nArgNum = aArguments.getLength();
  53     if ( nArgNum < 1 || nArgNum > 2 )
  54         throw lang::IllegalArgumentException(); // TODO:
  55
  56     uno::Reference< io::XStream > xStream;
  57     uno::Reference< io::XInputStream > xInputStream;
  58     if ( !( aArguments[0] >>= xStream ) && !( aArguments[0] >>= xInputStream ) )
  59         throw lang::IllegalArgumentException(); // TODO:
  60
  61     if ( nArgNum == 2 )
  62     {
  63         if ( !( aArguments[1] >>= m_bNoTemporaryCopy ) )
  64             throw lang::IllegalArgumentException(); // TODO:
  65     }
  66
  67     if ( m_bNoTemporaryCopy )
  68     {
  69         // TODO: ???
  70         // If the temporary stream is not created, the original stream must be wrapped
  71         // since SvStream wrapper closes the stream is owns
  72         if ( xInputStream.is() )
  73         {
  74             // the stream must be seekable for direct access
  75             uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY_THROW );
  76             m_pStream = ::utl::UcbStreamHelper::CreateStream( xInputStream, false );
  77         }
  78         else if ( xStream.is() )
  79         {
  80             // the stream must be seekable for direct access
  81             uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );
  82             m_pStream = ::utl::UcbStreamHelper::CreateStream( xStream, false );
  83         }
  84         else
  85             throw lang::IllegalArgumentException(); // TODO:
  86     }
  87     else
  88     {
  89         uno::Reference < io::XStream > xTempFile( io::TempFile::create(m_xContext),
  90                 uno::UNO_QUERY_THROW );
  91         uno::Reference < io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );
  92         uno::Reference< io::XOutputStream > xTempOut = xTempFile->getOutputStream();
  93         if ( !xTempOut.is() )
  94             throw uno::RuntimeException();
  95
  96         if ( xInputStream.is() )
  97         {
  98             try
  99             {
 100                 uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY );
 101                 if (xSeek)
 102                     xSeek->seek( 0 );
 103             }
 104             catch( uno::Exception& )
 105             {}
 106
 107             ::comphelper::OStorageHelper::CopyInputToOutput( xInputStream, xTempOut );
 108             xTempOut->closeOutput();
 109             xTempSeek->seek( 0 );
 110             uno::Reference< io::XInputStream > xTempInput = xTempFile->getInputStream();
 111             m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempInput, false );
 112         }
 113         else if ( xStream.is() )
 114         {
 115             // not sure that the storage flashes the stream on commit
 116             m_xStream = xStream;
 117             m_xTempStream = xTempFile;
 118
 119             uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );
 120             xSeek->seek( 0 );
 121             uno::Reference< io::XInputStream > xInpStream = xStream->getInputStream();
 122             if ( !xInpStream.is() || !xStream->getOutputStream().is() )
 123                 throw uno::RuntimeException();
 124
 125             ::comphelper::OStorageHelper::CopyInputToOutput( xInpStream, xTempOut );
 126             xTempOut->flush();
 127             xTempSeek->seek( 0 );
 128
 129             m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, false );
 130         }
 131         else
 132             throw lang::IllegalArgumentException(); // TODO:
 133     }
 134
 135     if ( !m_pStream || m_pStream->GetError() )
 136         throw io::IOException(); // TODO
 137
 138     m_pStorage.reset(new Storage( *m_pStream, false ));
 139 }
 140
 141 OLESimpleStorage::~OLESimpleStorage()
 142 {
 143     try {
 144         osl_atomic_increment(&m_refCount);
 145         dispose();
 146     } catch( uno::Exception& )
 147     {}
 148 }
 149
 150 void OLESimpleStorage::UpdateOriginal_Impl()
 151 {
 152     if ( m_bNoTemporaryCopy )
 153         return;
 154
 155     uno::Reference< io::XSeekable > xSeek( m_xStream, uno::UNO_QUERY_THROW );
 156     xSeek->seek( 0 );
 157
 158     uno::Reference< io::XSeekable > xTempSeek( m_xTempStream, uno::UNO_QUERY_THROW );
 159     sal_Int64 nPos = xTempSeek->getPosition();
 160     xTempSeek->seek( 0 );
 161
 162     uno::Reference< io::XInputStream > xTempInp = m_xTempStream->getInputStream();
 163     uno::Reference< io::XOutputStream > xOutputStream = m_xStream->getOutputStream();
 164     if ( !xTempInp.is() || !xOutputStream.is() )
 165         throw uno::RuntimeException();
 166
 167     uno::Reference< io::XTruncate > xTrunc( xOutputStream, uno::UNO_QUERY_THROW );
 168     xTrunc->truncate();
 169
 170     ::comphelper::OStorageHelper::CopyInputToOutput( xTempInp, xOutputStream );
 171     xOutputStream->flush();
 172     xTempSeek->seek( nPos );
 173 }
 174
 175
 176 void OLESimpleStorage::InsertInputStreamToStorage_Impl( BaseStorage* pStorage, const OUString & aName, const uno::Reference< io::XInputStream >& xInputStream )
 177 {
 178     if ( !pStorage || aName.isEmpty() || !xInputStream.is() )
 179         throw uno::RuntimeException();
 180
 181     if ( pStorage->IsContained( aName ) )
 182         throw container::ElementExistException(); // TODO:
 183
 184     std::unique_ptr<BaseStorageStream> pNewStream(pStorage->OpenStream( aName ));
 185     if ( !pNewStream || pNewStream->GetError() || pStorage->GetError() )
 186     {
 187         pNewStream.reset();
 188         pStorage->ResetError();
 189         throw io::IOException(); // TODO
 190     }
 191
 192     try
 193     {
 194         uno::Sequence< sal_Int8 > aData( nBytesCount );
 195         sal_Int32 nRead = 0;
 196         do
 197         {
 198             nRead = xInputStream->readBytes( aData, nBytesCount );
 199
 200             sal_Int32 nWritten = pNewStream->Write( aData.getConstArray(), nRead );
 201             if ( nWritten < nRead )
 202                 throw io::IOException();
 203         } while( nRead == nBytesCount );
 204     }
 205     catch( uno::Exception& )
 206     {
 207         pNewStream.reset();
 208         pStorage->Remove( aName );
 209
 210         throw;
 211     }
 212 }
 213
 214
 215 void OLESimpleStorage::InsertNameAccessToStorage_Impl( BaseStorage* pStorage, const OUString & aName, const uno::Reference< container::XNameAccess >& xNameAccess )
 216 {
 217     if ( !pStorage || aName.isEmpty() || !xNameAccess.is() )
 218         throw uno::RuntimeException();
 219
 220     if ( pStorage->IsContained( aName ) )
 221         throw container::ElementExistException(); // TODO:
 222
 223     std::unique_ptr<BaseStorage> pNewStorage(pStorage->OpenStorage( aName ));
 224     if ( !pNewStorage || pNewStorage->GetError() || pStorage->GetError() )
 225     {
 226         pNewStorage.reset();
 227         pStorage->ResetError();
 228         throw io::IOException(); // TODO
 229     }
 230
 231     try
 232     {
 233         const uno::Sequence< OUString > aElements = xNameAccess->getElementNames();
 234         for ( const auto& rElement : aElements )
 235         {
 236             uno::Reference< io::XInputStream > xInputStream;
 237             uno::Reference< container::XNameAccess > xSubNameAccess;
 238             uno::Any aAny = xNameAccess->getByName( rElement );
 239             if ( aAny >>= xInputStream )
 240                 InsertInputStreamToStorage_Impl( pNewStorage.get(), rElement, xInputStream );
 241             else if ( aAny >>= xSubNameAccess )
 242                 InsertNameAccessToStorage_Impl( pNewStorage.get(), rElement, xSubNameAccess );
 243         }
 244     }
 245     catch( uno::Exception& )
 246     {
 247         pNewStorage.reset();
 248         pStorage->Remove( aName );
 249
 250         throw;
 251     }
 252 }
 253
 254
 255 //  XNameContainer
 256
 257
 258 void SAL_CALL OLESimpleStorage::insertByName( const OUString& aName, const uno::Any& aElement )
 259 {
 260     std::unique_lock aGuard( m_aMutex );
 261
 262     if ( m_bDisposed )
 263         throw lang::DisposedException();
 264
 265     if ( !m_pStorage )
 266         throw uno::RuntimeException();
 267
 268     uno::Reference< io::XStream > xStream;
 269     uno::Reference< io::XInputStream > xInputStream;
 270     uno::Reference< container::XNameAccess > xNameAccess;
 271
 272     try
 273     {
 274         if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 275             throw io::IOException(); // TODO
 276
 277         if ( aElement >>= xStream )
 278             xInputStream = xStream->getInputStream();
 279         else if ( !( aElement >>= xInputStream ) && !( aElement >>= xNameAccess ) )
 280             throw lang::IllegalArgumentException(); // TODO:
 281
 282         if ( xInputStream.is() )
 283             InsertInputStreamToStorage_Impl( m_pStorage.get(), aName, xInputStream );
 284         else if ( xNameAccess.is() )
 285             InsertNameAccessToStorage_Impl( m_pStorage.get(), aName, xNameAccess );
 286         else
 287             throw uno::RuntimeException();
 288     }
 289     catch( uno::RuntimeException& )
 290     {
 291         throw;
 292     }
 293     catch( container::ElementExistException& )
 294     {
 295         throw;
 296     }
 297     catch( const uno::Exception& )
 298     {
 299         css::uno::Any anyEx = cppu::getCaughtException();
 300         throw lang::WrappedTargetException(u"Insert has failed!"_ustr,
 301                                             uno::Reference< uno::XInterface >(),
 302                                             anyEx );
 303     }
 304 }
 305
 306
 307 void SAL_CALL OLESimpleStorage::removeByName( const OUString& aName )
 308 {
 309     std::unique_lock aGuard( m_aMutex );
 310
 311     if ( m_bDisposed )
 312         throw lang::DisposedException();
 313
 314     if ( !m_pStorage )
 315         throw uno::RuntimeException();
 316
 317     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 318         throw lang::WrappedTargetException(); // io::IOException(); // TODO
 319
 320     if ( !m_pStorage->IsContained( aName ) )
 321         throw container::NoSuchElementException(); // TODO:
 322
 323     m_pStorage->Remove( aName );
 324
 325     if ( m_pStorage->GetError() )
 326     {
 327         m_pStorage->ResetError();
 328         throw lang::WrappedTargetException(); // io::IOException(); // TODO
 329     }
 330 }
 331
 332
 333 void SAL_CALL OLESimpleStorage::replaceByName( const OUString& aName, const uno::Any& aElement )
 334 {
 335     std::unique_lock aGuard( m_aMutex );
 336
 337     if ( m_bDisposed )
 338         throw lang::DisposedException();
 339
 340     removeByName( aName );
 341
 342     try
 343     {
 344         insertByName( aName, aElement );
 345     }
 346     catch( container::ElementExistException& )
 347     {
 348         uno::Any aCaught( ::cppu::getCaughtException() );
 349
 350         throw lang::WrappedTargetException(u"Can't copy raw stream"_ustr,
 351                                             uno::Reference< uno::XInterface >(),
 352                                             aCaught );
 353     }
 354 }
 355
 356
 357 uno::Any SAL_CALL OLESimpleStorage::getByName( const OUString& aName )
 358 {
 359     std::unique_lock aGuard( m_aMutex );
 360
 361     if ( m_bDisposed )
 362         throw lang::DisposedException();
 363
 364     if ( !m_pStorage )
 365         throw uno::RuntimeException();
 366
 367     if ( !m_pStorage->IsContained( aName ) )
 368         throw container::NoSuchElementException(); // TODO:
 369
 370     uno::Any aResult;
 371
 372     uno::Reference< io::XStream > xTempFile = io::TempFile::create(m_xContext);
 373     uno::Reference< io::XSeekable > xSeekable( xTempFile, uno::UNO_QUERY_THROW );
 374     uno::Reference< io::XOutputStream > xOutputStream = xTempFile->getOutputStream();
 375     uno::Reference< io::XInputStream > xInputStream = xTempFile->getInputStream();
 376     if ( !xOutputStream.is() || !xInputStream.is() )
 377         throw uno::RuntimeException();
 378
 379     if ( m_pStorage->IsStorage( aName ) )
 380     {
 381         std::unique_ptr<BaseStorage> pStrg(m_pStorage->OpenStorage( aName ));
 382         m_pStorage->ResetError();
 383         if ( !pStrg )
 384             throw lang::WrappedTargetException(); // io::IOException(); // TODO
 385
 386         std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, false ); // do not close the original stream
 387         if ( !pStream )
 388             throw uno::RuntimeException();
 389
 390         std::unique_ptr<BaseStorage> pNewStor(new Storage( *pStream, false ));
 391         bool bSuccess = ( pStrg->CopyTo( *pNewStor ) && pNewStor->Commit() &&
 392                           !pNewStor->GetError() && !pStrg->GetError() );
 393
 394         pNewStor.reset();
 395         pStrg.reset();
 396         pStream.reset();
 397
 398         if ( !bSuccess )
 399             throw uno::RuntimeException();
 400
 401         uno::Reference< container::XNameContainer > xResultNameContainer(
 402             css::embed::OLESimpleStorage::createFromInputStream(m_xContext, xInputStream, true),
 403             uno::UNO_QUERY_THROW );
 404
 405         aResult <<= xResultNameContainer;
 406     }
 407     else
 408     {
 409         std::unique_ptr<BaseStorageStream> pStream(m_pStorage->OpenStream( aName, StreamMode::READ | StreamMode::SHARE_DENYALL | StreamMode::NOCREATE ));
 410         try
 411         {
 412             if ( !pStream || pStream->GetError() || m_pStorage->GetError() )
 413             {
 414                 m_pStorage->ResetError();
 415                 throw io::IOException(); // TODO
 416             }
 417
 418             uno::Sequence< sal_Int8 > aData( nBytesCount );
 419             sal_Int32 nSize = nBytesCount;
 420             sal_Int32 nRead = 0;
 421             while( 0 != ( nRead = pStream->Read( aData.getArray(), nSize ) ) )
 422             {
 423                 if ( nRead < nSize )
 424                 {
 425                     nSize = nRead;
 426                     aData.realloc( nSize );
 427                 }
 428
 429                 xOutputStream->writeBytes( aData );
 430             }
 431
 432             if ( pStream->GetError() )
 433                 throw io::IOException(); // TODO
 434
 435             xOutputStream->closeOutput();
 436             xSeekable->seek( 0 );
 437         }
 438         catch (const uno::RuntimeException&)
 439         {
 440             throw;
 441         }
 442         catch (const uno::Exception& ex)
 443         {
 444             css::uno::Any anyEx = cppu::getCaughtException();
 445             throw css::lang::WrappedTargetException( ex.Message,
 446                     nullptr, anyEx );
 447         }
 448
 449         pStream.reset();
 450
 451         aResult <<= xInputStream;
 452     }
 453
 454     return aResult;
 455 }
 456
 457
 458 uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getElementNames()
 459 {
 460     std::unique_lock aGuard( m_aMutex );
 461
 462     if ( m_bDisposed )
 463         throw lang::DisposedException();
 464
 465     if ( !m_pStorage )
 466         throw uno::RuntimeException();
 467
 468     SvStorageInfoList aList;
 469     m_pStorage->FillInfoList( &aList );
 470
 471     if ( m_pStorage->GetError() )
 472     {
 473         m_pStorage->ResetError();
 474         throw uno::RuntimeException(); // TODO:
 475     }
 476
 477     uno::Sequence< OUString > aSeq( aList.size() );
 478     auto aSeqRange = asNonConstRange(aSeq);
 479     for ( size_t nInd = 0; nInd < aList.size(); nInd++ )
 480         aSeqRange[nInd] = aList[nInd].GetName();
 481
 482     return aSeq;
 483 }
 484
 485
 486 sal_Bool SAL_CALL OLESimpleStorage::hasByName( const OUString& aName )
 487 {
 488     std::unique_lock aGuard( m_aMutex );
 489
 490     if ( m_bDisposed )
 491         throw lang::DisposedException();
 492
 493     if ( !m_pStorage )
 494         throw uno::RuntimeException();
 495
 496     bool bResult = m_pStorage->IsContained( aName );
 497
 498     if ( m_pStorage->GetError() )
 499     {
 500         m_pStorage->ResetError();
 501         throw uno::RuntimeException(); // TODO:
 502     }
 503
 504     return bResult;
 505 }
 506
 507
 508 uno::Type SAL_CALL OLESimpleStorage::getElementType()
 509 {
 510     std::unique_lock aGuard( m_aMutex );
 511
 512     if ( m_bDisposed )
 513         throw lang::DisposedException();
 514
 515     return cppu::UnoType<io::XInputStream>::get();
 516 }
 517
 518
 519 sal_Bool SAL_CALL OLESimpleStorage::hasElements()
 520 {
 521     std::unique_lock aGuard( m_aMutex );
 522
 523     if ( m_bDisposed )
 524         throw lang::DisposedException();
 525
 526     if ( !m_pStorage )
 527         throw uno::RuntimeException();
 528
 529     SvStorageInfoList aList;
 530     m_pStorage->FillInfoList( &aList );
 531
 532     if ( m_pStorage->GetError() )
 533     {
 534         m_pStorage->ResetError();
 535         throw uno::RuntimeException(); // TODO:
 536     }
 537
 538     return !aList.empty();
 539 }
 540
 541
 542 //  XComponent
 543
 544
 545 void SAL_CALL OLESimpleStorage::dispose()
 546 {
 547     std::unique_lock aGuard( m_aMutex );
 548
 549     if ( m_bDisposed )
 550         return;
 551
 552     if ( m_aListenersContainer.getLength(aGuard) )
 553     {
 554         lang::EventObject aSource( getXWeak() );
 555         m_aListenersContainer.disposeAndClear( aGuard, aSource );
 556     }
 557
 558     m_pStorage.reset();
 559     m_pStream.reset();
 560
 561     m_xStream.clear();
 562     m_xTempStream.clear();
 563
 564     m_bDisposed = true;
 565 }
 566
 567
 568 void SAL_CALL OLESimpleStorage::addEventListener(
 569             const uno::Reference< lang::XEventListener >& xListener )
 570 {
 571     std::unique_lock aGuard( m_aMutex );
 572
 573     if ( m_bDisposed )
 574         throw lang::DisposedException();
 575
 576     m_aListenersContainer.addInterface( aGuard, xListener );
 577 }
 578
 579
 580 void SAL_CALL OLESimpleStorage::removeEventListener(
 581             const uno::Reference< lang::XEventListener >& xListener )
 582 {
 583     std::unique_lock aGuard( m_aMutex );
 584
 585     if ( m_bDisposed )
 586         throw lang::DisposedException();
 587
 588     m_aListenersContainer.removeInterface( aGuard, xListener );
 589 }
 590
 591
 592 //  XTransactedObject
 593
 594
 595 void SAL_CALL OLESimpleStorage::commit()
 596 {
 597     std::unique_lock aGuard( m_aMutex );
 598
 599     if ( m_bDisposed )
 600         throw lang::DisposedException();
 601
 602     if ( !m_pStorage )
 603         throw uno::RuntimeException();
 604
 605     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 606         throw io::IOException(); // TODO
 607
 608     if ( !m_pStorage->Commit() || m_pStorage->GetError() )
 609     {
 610         m_pStorage->ResetError();
 611         throw io::IOException(); // TODO
 612     }
 613
 614     UpdateOriginal_Impl();
 615 }
 616
 617
 618 void SAL_CALL OLESimpleStorage::revert()
 619 {
 620     std::unique_lock aGuard( m_aMutex );
 621
 622     if ( m_bDisposed )
 623         throw lang::DisposedException();
 624
 625     if ( !m_pStorage )
 626         throw uno::RuntimeException();
 627
 628     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 629         throw io::IOException(); // TODO
 630
 631     if ( !m_pStorage->Revert() || m_pStorage->GetError() )
 632     {
 633         m_pStorage->ResetError();
 634         throw io::IOException(); // TODO
 635     }
 636
 637     UpdateOriginal_Impl();
 638 }
 639
 640
 641 //  XClassifiedObject
 642
 643
 644 uno::Sequence< sal_Int8 > SAL_CALL OLESimpleStorage::getClassID()
 645 {
 646     std::unique_lock aGuard( m_aMutex );
 647
 648     if ( m_bDisposed )
 649         throw lang::DisposedException();
 650
 651     if ( !m_pStorage )
 652         throw uno::RuntimeException();
 653
 654     return m_pStorage->GetClassName().GetByteSequence();
 655 }
 656
 657 OUString SAL_CALL OLESimpleStorage::getClassName()
 658 {
 659     return OUString();
 660 }
 661
 662 void SAL_CALL OLESimpleStorage::setClassInfo( const uno::Sequence< sal_Int8 >& /*aClassID*/,
 663                             const OUString& /*sClassName*/ )
 664 {
 665     throw lang::NoSupportException();
 666 }
 667
 668 //  XServiceInfo
 669 OUString SAL_CALL OLESimpleStorage::getImplementationName()
 670 {
 671     return u"com.sun.star.comp.embed.OLESimpleStorage"_ustr;
 672 }
 673
 674 sal_Bool SAL_CALL OLESimpleStorage::supportsService( const OUString& ServiceName )
 675 {
 676     return cppu::supportsService(this, ServiceName);
 677 }
 678
 679 uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getSupportedServiceNames()
 680 {
 681     return { u"com.sun.star.embed.OLESimpleStorage"_ustr };
 682 }
 683
 684 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 685 com_sun_star_comp_embed_OLESimpleStorage(
 686     css::uno::XComponentContext *context,
 687     css::uno::Sequence<css::uno::Any> const &arguments)
 688 {
 689     return cppu::acquire(new OLESimpleStorage(context, arguments));
 690 }
 691
 692 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */