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