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