xref: /trunk/main/comphelper/source/streaming/otransactedfilestream.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_comphelper.hxx"
30 #include <osl/diagnose.h>
31 #include <com/sun/star/beans/PropertyAttribute.hpp>
32 #include <com/sun/star/io/XAsyncOutputMonitor.hpp>
33 #include <com/sun/star/embed/UseBackupException.hpp>
34 
35 #include <comphelper/otransactedfilestream.hxx>
36 #include <comphelper/storagehelper.hxx>
37 #include <cppuhelper/implbase1.hxx>
38 
39 using namespace ::com::sun::star;
40 
41 namespace comphelper
42 {
43 
44 // ========================================================================
45 class OTransactionHelper : public ::cppu::WeakImplHelper1 < embed::XTransactedObject >
46 {
47     OTruncatedTransactedFileStream* m_pFileStream;
48     uno::Reference< io::XStream > m_xStreamHolder;
49 
50 public:
51     OTransactionHelper( OTruncatedTransactedFileStream* pStream )
52     : m_pFileStream( pStream )
53     {
54         m_xStreamHolder = static_cast< io::XStream* >( pStream );
55         if ( !m_xStreamHolder.is() )
56             throw uno::RuntimeException();
57     }
58 
59     virtual void SAL_CALL commit(  ) throw (io::IOException, lang::WrappedTargetException, uno::RuntimeException);
60     virtual void SAL_CALL revert(  ) throw (io::IOException, lang::WrappedTargetException, uno::RuntimeException);
61 };
62 
63 // ------------------------------------------------------------------------
64 void SAL_CALL OTransactionHelper::commit(  ) throw (io::IOException, lang::WrappedTargetException, uno::RuntimeException)
65 {
66     m_pFileStream->Commit_Impl();
67 }
68 
69 // ------------------------------------------------------------------------
70 void SAL_CALL OTransactionHelper::revert(  ) throw (io::IOException, lang::WrappedTargetException, uno::RuntimeException)
71 {
72     m_pFileStream->Revert_Impl();
73 }
74 
75 // ========================================================================
76 struct TTFileStreamData_Impl
77 {
78     uno::Reference< ucb::XSimpleFileAccess > m_xFileAccess;
79     sal_Bool m_bDelete;
80     ::rtl::OUString m_aURL;
81 
82     // the streams below are not visible from outside so there is no need to remember position
83 
84     // original stream related members
85     uno::Reference< io::XStream > m_xOrigStream;
86     uno::Reference< io::XTruncate > m_xOrigTruncate;
87     uno::Reference< io::XSeekable > m_xOrigSeekable;
88     uno::Reference< io::XInputStream > m_xOrigInStream;
89     uno::Reference< io::XOutputStream > m_xOrigOutStream;
90 
91     // temporary stream related members
92     uno::Reference< io::XStream > m_xTempStream;
93     uno::Reference< io::XTruncate > m_xTempTruncate;
94     uno::Reference< io::XSeekable > m_xTempSeekable;
95     uno::Reference< io::XInputStream > m_xTempInStream;
96     uno::Reference< io::XOutputStream > m_xTempOutStream;
97 
98     sal_Bool m_bInOpen;
99     sal_Bool m_bOutOpen;
100 
101     sal_Bool m_bTransacted;
102 
103 
104     TTFileStreamData_Impl(
105             const uno::Reference< ucb::XSimpleFileAccess >& xFileAccess,
106             sal_Bool bDelete,
107             const ::rtl::OUString& aURL,
108             const uno::Reference< io::XStream >& xOrigStream,
109             const uno::Reference< io::XTruncate >& xOrigTruncate,
110             const uno::Reference< io::XSeekable >& xOrigSeekable,
111             const uno::Reference< io::XInputStream >& xOrigInStream,
112             const uno::Reference< io::XOutputStream >& xOrigOutStream,
113             const uno::Reference< io::XStream >& xTempStream,
114             const uno::Reference< io::XTruncate >& xTempTruncate,
115             const uno::Reference< io::XSeekable >& xTempSeekable,
116             const uno::Reference< io::XInputStream >& xTempInStream,
117             const uno::Reference< io::XOutputStream >& xTempOutStream )
118     : m_xFileAccess( xFileAccess )
119     , m_bDelete( bDelete )
120     , m_aURL( aURL )
121     , m_xOrigStream( xOrigStream )
122     , m_xOrigTruncate( xOrigTruncate )
123     , m_xOrigSeekable( xOrigSeekable )
124     , m_xOrigInStream( xOrigInStream )
125     , m_xOrigOutStream( xOrigOutStream )
126     , m_xTempStream( xTempStream )
127     , m_xTempTruncate( xTempTruncate )
128     , m_xTempSeekable( xTempSeekable )
129     , m_xTempInStream( xTempInStream )
130     , m_xTempOutStream( xTempOutStream )
131     , m_bInOpen( sal_False )
132     , m_bOutOpen( sal_False )
133     , m_bTransacted( sal_True )
134     {}
135 
136     void NoTransaction()
137     {
138         m_bDelete = sal_False;
139         m_bTransacted = sal_False;
140         m_xTempStream = uno::Reference< io::XStream >();
141         m_xTempTruncate = uno::Reference< io::XTruncate >();
142         m_xTempSeekable = uno::Reference< io::XSeekable >();
143         m_xTempInStream = uno::Reference< io::XInputStream >();
144         m_xTempOutStream = uno::Reference< io::XOutputStream >();
145     }
146 
147     void FreeOriginal()
148     {
149         m_bDelete = sal_False;
150         m_bTransacted = sal_False;
151 
152         m_xOrigStream = m_xTempStream;
153         m_xTempStream = uno::Reference< io::XStream >();
154 
155         m_xOrigTruncate = m_xTempTruncate;
156         m_xTempTruncate = uno::Reference< io::XTruncate >();
157 
158         m_xOrigSeekable = m_xTempSeekable;
159         m_xTempSeekable = uno::Reference< io::XSeekable >();
160 
161         m_xOrigInStream = m_xTempInStream;
162         m_xTempInStream = uno::Reference< io::XInputStream >();
163 
164         m_xOrigOutStream = m_xTempOutStream;
165         m_xTempOutStream = uno::Reference< io::XOutputStream >();
166     }
167 };
168 
169 // ========================================================================
170 // ------------------------------------------------------------------------
171 OTruncatedTransactedFileStream::OTruncatedTransactedFileStream(
172         const ::rtl::OUString& aURL,
173         const uno::Reference< lang::XMultiServiceFactory >& xFactory )
174 : m_pStreamData( NULL )
175 {
176     uno::Reference< ucb::XSimpleFileAccess > xSimpleFileAccess(
177         xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
178         uno::UNO_QUERY_THROW );
179 
180     CommonInit_Impl( aURL, xSimpleFileAccess, xFactory, sal_False );
181 }
182 
183 // ------------------------------------------------------------------------
184 OTruncatedTransactedFileStream::OTruncatedTransactedFileStream(
185         const ::rtl::OUString& aURL,
186         const uno::Reference< ucb::XSimpleFileAccess >& xFileAccess,
187         const uno::Reference< lang::XMultiServiceFactory >& xFactory )
188 : m_pStreamData( NULL )
189 {
190     CommonInit_Impl( aURL, xFileAccess, xFactory, sal_False );
191 }
192 
193 // ------------------------------------------------------------------------
194 OTruncatedTransactedFileStream::OTruncatedTransactedFileStream(
195         const ::rtl::OUString& aURL,
196         const uno::Reference< ucb::XSimpleFileAccess >& xFileAccess,
197         const uno::Reference< lang::XMultiServiceFactory >& xFactory,
198         sal_Bool bDeleteIfNotCommited )
199 : m_pStreamData( NULL )
200 {
201     CommonInit_Impl( aURL, xFileAccess, xFactory, sal_True );
202     if ( m_pStreamData )
203         m_pStreamData->m_bDelete = bDeleteIfNotCommited;
204 }
205 
206 // ------------------------------------------------------------------------
207 OTruncatedTransactedFileStream::~OTruncatedTransactedFileStream()
208 {
209     CloseAll_Impl();
210 }
211 
212 // ------------------------------------------------------------------------
213 void OTruncatedTransactedFileStream::CloseAll_Impl()
214 {
215     ::osl::MutexGuard aGuard( m_aMutex );
216 
217     if ( m_pStreamData )
218     {
219         sal_Bool bDelete = m_pStreamData->m_bDelete;
220         ::rtl::OUString aURL = m_pStreamData->m_aURL;
221         uno::Reference< ucb::XSimpleFileAccess > xFileAccess = m_pStreamData->m_xFileAccess;
222 
223         delete m_pStreamData;
224         m_pStreamData = NULL;
225 
226         if ( bDelete && xFileAccess.is() && aURL.getLength() )
227         {
228             // delete the file
229             try
230             {
231                 xFileAccess->kill( aURL );
232             } catch( uno::Exception& )
233             {
234                 OSL_ENSURE( sal_False, "Could not remove the file!" );
235             }
236         }
237     }
238 }
239 
240 // ------------------------------------------------------------------------
241 void OTruncatedTransactedFileStream::CommonInit_Impl(
242         const ::rtl::OUString& aURL,
243         const uno::Reference< ucb::XSimpleFileAccess >& xFileAccess,
244         const uno::Reference< lang::XMultiServiceFactory >& xFactory,
245         sal_Bool bDeleteOptionIsProvided )
246 {
247     sal_Bool bDelete = sal_False;
248     if ( !bDeleteOptionIsProvided )
249         bDelete = !xFileAccess->exists( aURL );
250 
251     uno::Reference< io::XStream > xOrigStream = xFileAccess->openFileReadWrite( aURL );
252     uno::Reference< io::XTruncate > xOrigTruncate( xOrigStream, uno::UNO_QUERY_THROW );
253     uno::Reference< io::XSeekable > xOrigSeekable( xOrigStream, uno::UNO_QUERY_THROW );
254     uno::Reference< io::XInputStream > xOrigInStream = xOrigStream->getInputStream();
255     uno::Reference< io::XOutputStream > xOrigOutStream = xOrigStream->getOutputStream();
256     if ( !xOrigInStream.is() || !xOrigOutStream.is() )
257         throw uno::RuntimeException();
258 
259     // temporary stream related members
260     uno::Reference< io::XStream > xTempStream( xFactory->createInstance(
261         ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
262         uno::UNO_QUERY_THROW );
263     uno::Reference< io::XTruncate > xTempTruncate( xTempStream, uno::UNO_QUERY_THROW );
264     uno::Reference< io::XSeekable > xTempSeekable( xTempStream, uno::UNO_QUERY_THROW );
265     uno::Reference< io::XInputStream > xTempInStream = xTempStream->getInputStream();
266     uno::Reference< io::XOutputStream > xTempOutStream = xTempStream->getOutputStream();
267     if ( !xTempInStream.is() || !xTempOutStream.is() )
268         throw uno::RuntimeException();
269 
270     m_pStreamData = new TTFileStreamData_Impl( xFileAccess, bDelete, aURL,
271                                             xOrigStream, xOrigTruncate, xOrigSeekable, xOrigInStream, xOrigOutStream,
272                                             xTempStream, xTempTruncate, xTempSeekable, xTempInStream, xTempOutStream );
273 }
274 
275 // ------------------------------------------------------------------------
276 void OTruncatedTransactedFileStream::Commit_Impl()
277 {
278     ::osl::MutexGuard aGuard( m_aMutex );
279 
280     if ( !m_pStreamData )
281         throw io::NotConnectedException();
282 
283     if ( m_pStreamData->m_bTransacted )
284     {
285         sal_Int64 nPos = m_pStreamData->m_xTempSeekable->getPosition();
286         m_pStreamData->m_xTempSeekable->seek( 0 );
287 
288         // after the following step fails the information might be lost, throw an exception with URL of temporary file
289         try
290         {
291             m_pStreamData->m_xOrigTruncate->truncate();
292             OStorageHelper::CopyInputToOutput( m_pStreamData->m_xTempInStream, m_pStreamData->m_xOrigOutStream );
293             m_pStreamData->m_xOrigOutStream->flush();
294 
295             // in case the stream is based on a file it will implement the following interface
296             // the call should be used to be sure that the contents are written to the file system
297             uno::Reference< io::XAsyncOutputMonitor > asyncOutputMonitor( m_pStreamData->m_xOrigOutStream, uno::UNO_QUERY );
298             if ( asyncOutputMonitor.is() )
299                 asyncOutputMonitor->waitForCompletion();
300         }
301         catch( uno::Exception& )
302         {
303             ::rtl::OUString aTempURL;
304             try {
305                 uno::Reference< beans::XPropertySet > xTempFile( m_pStreamData->m_xTempStream, uno::UNO_QUERY_THROW );
306                 uno::Any aUrl = xTempFile->getPropertyValue( ::rtl::OUString::createFromAscii( "Uri" ) );
307                 aUrl >>= aTempURL;
308                 xTempFile->setPropertyValue( ::rtl::OUString::createFromAscii( "RemoveFile" ),
309                                             uno::makeAny( sal_False ) );
310 
311                 m_pStreamData->m_xTempSeekable->seek( nPos );
312             }
313             catch( uno::Exception& )
314             {
315                 OSL_ENSURE( sal_False, "These calls are pretty simple, they should not fail!\n" );
316             }
317 
318             m_pStreamData->FreeOriginal();
319 
320             ::rtl::OUString aErrTxt( RTL_CONSTASCII_USTRINGPARAM ( "Writing file failed!" ) );
321             embed::UseBackupException aException( aErrTxt, uno::Reference< uno::XInterface >(), aTempURL );
322             throw lang::WrappedTargetException( aErrTxt,
323                                                 static_cast < OWeakObject * > ( this ),
324                                                 uno::makeAny ( aException ) );
325         }
326 
327         m_pStreamData->m_xOrigSeekable->seek( nPos );
328         m_pStreamData->NoTransaction();
329     }
330     else
331         throw io::NotConnectedException();
332 }
333 
334 // ------------------------------------------------------------------------
335 void OTruncatedTransactedFileStream::Revert_Impl()
336 {
337     ::osl::MutexGuard aGuard( m_aMutex );
338 
339     if ( !m_pStreamData )
340         throw io::NotConnectedException();
341 
342     if ( m_pStreamData->m_bTransacted )
343         m_pStreamData->m_xTempTruncate->truncate();
344     else
345         throw io::NotConnectedException();
346 }
347 
348 // com::sun::star::io::XStream
349 // ------------------------------------------------------------------------
350 uno::Reference< io::XInputStream > SAL_CALL OTruncatedTransactedFileStream::getInputStream(  )
351     throw (uno::RuntimeException)
352 {
353     ::osl::MutexGuard aGuard( m_aMutex );
354 
355     if ( m_pStreamData )
356         m_pStreamData->m_bInOpen = sal_True;
357     return static_cast< io::XInputStream* >( this );
358 }
359 
360 
361 // ------------------------------------------------------------------------
362 uno::Reference< io::XOutputStream > SAL_CALL OTruncatedTransactedFileStream::getOutputStream(  )
363     throw (uno::RuntimeException)
364 {
365     ::osl::MutexGuard aGuard( m_aMutex );
366 
367     if ( m_pStreamData )
368         m_pStreamData->m_bOutOpen = sal_True;
369     return static_cast< io::XOutputStream* >( this );
370 }
371 
372 
373 
374 // com::sun::star::io::XInputStream
375 // ------------------------------------------------------------------------
376 ::sal_Int32 SAL_CALL OTruncatedTransactedFileStream::readBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nBytesToRead )
377     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
378 {
379     ::osl::MutexGuard aGuard( m_aMutex );
380 
381     if ( !m_pStreamData )
382         throw io::NotConnectedException();
383 
384     if ( m_pStreamData->m_bTransacted )
385     {
386         // temporary stream data should be provided
387         if ( !m_pStreamData->m_xTempInStream.is() )
388             throw uno::RuntimeException();
389 
390         return m_pStreamData->m_xTempInStream->readBytes( aData, nBytesToRead );
391     }
392     else
393     {
394         // the original stream data should be provided
395         if ( !m_pStreamData->m_xOrigInStream.is() )
396             throw uno::RuntimeException();
397 
398         return m_pStreamData->m_xOrigInStream->readBytes( aData, nBytesToRead );
399     }
400 }
401 
402 
403 // ------------------------------------------------------------------------
404 ::sal_Int32 SAL_CALL OTruncatedTransactedFileStream::readSomeBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nMaxBytesToRead )
405     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
406 {
407     ::osl::MutexGuard aGuard( m_aMutex );
408 
409     if ( !m_pStreamData )
410         throw io::NotConnectedException();
411 
412     if ( m_pStreamData->m_bTransacted )
413     {
414         // temporary stream data should be provided
415         if ( !m_pStreamData->m_xTempInStream.is() )
416             throw uno::RuntimeException();
417 
418         return m_pStreamData->m_xTempInStream->readSomeBytes( aData, nMaxBytesToRead );
419     }
420     else
421     {
422         // the original stream data should be provided
423         if ( !m_pStreamData->m_xOrigInStream.is() )
424             throw uno::RuntimeException();
425 
426         return m_pStreamData->m_xOrigInStream->readSomeBytes( aData, nMaxBytesToRead );
427     }
428 }
429 
430 // ------------------------------------------------------------------------
431 void SAL_CALL OTruncatedTransactedFileStream::skipBytes( ::sal_Int32 nBytesToSkip )
432     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
433 {
434     ::osl::MutexGuard aGuard( m_aMutex );
435 
436     if ( !m_pStreamData )
437         throw io::NotConnectedException();
438 
439     if ( m_pStreamData->m_bTransacted )
440     {
441         // temporary stream data should be provided
442         if ( !m_pStreamData->m_xTempInStream.is() )
443             throw uno::RuntimeException();
444 
445         m_pStreamData->m_xTempInStream->skipBytes( nBytesToSkip );
446     }
447     else
448     {
449         // the original stream data should be provided
450         if ( !m_pStreamData->m_xOrigInStream.is() )
451             throw uno::RuntimeException();
452 
453         m_pStreamData->m_xOrigInStream->skipBytes( nBytesToSkip );
454     }
455 }
456 
457 
458 // ------------------------------------------------------------------------
459 ::sal_Int32 SAL_CALL OTruncatedTransactedFileStream::available(  )
460     throw (io::NotConnectedException, io::IOException, uno::RuntimeException)
461 {
462     ::osl::MutexGuard aGuard( m_aMutex );
463 
464     if ( !m_pStreamData )
465         throw io::NotConnectedException();
466 
467     if ( m_pStreamData->m_bTransacted )
468     {
469         // temporary stream data should be provided
470         if ( !m_pStreamData->m_xTempInStream.is() )
471             throw uno::RuntimeException();
472 
473         return m_pStreamData->m_xTempInStream->available();
474     }
475     else
476     {
477         // the original stream data should be provided
478         if ( !m_pStreamData->m_xOrigInStream.is() )
479             throw uno::RuntimeException();
480 
481         return m_pStreamData->m_xOrigInStream->available();
482     }
483 }
484 
485 
486 // ------------------------------------------------------------------------
487 void SAL_CALL OTruncatedTransactedFileStream::closeInput()
488     throw (io::NotConnectedException, io::IOException, uno::RuntimeException)
489 {
490     ::osl::MutexGuard aGuard( m_aMutex );
491 
492     if ( !m_pStreamData )
493         throw io::NotConnectedException();
494 
495     m_pStreamData->m_bInOpen = sal_False;
496     if ( !m_pStreamData->m_bOutOpen )
497         CloseAll_Impl();
498 }
499 
500 
501 
502 // com::sun::star::io::XOutputStream
503 // ------------------------------------------------------------------------
504 void SAL_CALL OTruncatedTransactedFileStream::writeBytes( const uno::Sequence< ::sal_Int8 >& aData )
505     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
506 {
507     ::osl::MutexGuard aGuard( m_aMutex );
508 
509     if ( !m_pStreamData )
510         throw io::NotConnectedException();
511 
512     if ( m_pStreamData->m_bTransacted )
513     {
514         // temporary stream data should be provided
515         if ( !m_pStreamData->m_xTempOutStream.is() )
516             throw uno::RuntimeException();
517 
518         m_pStreamData->m_xTempOutStream->writeBytes( aData );
519     }
520     else
521     {
522         // the original stream data should be provided
523         if ( !m_pStreamData->m_xOrigOutStream.is() )
524             throw uno::RuntimeException();
525 
526         m_pStreamData->m_xOrigOutStream->writeBytes( aData );
527     }
528 }
529 
530 
531 // ------------------------------------------------------------------------
532 void SAL_CALL OTruncatedTransactedFileStream::flush(  )
533     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
534 {
535     ::osl::MutexGuard aGuard( m_aMutex );
536 
537     if ( !m_pStreamData )
538     {
539         OSL_ENSURE( sal_False, "flush() call on closed stream!\n" );
540         return;
541         // in future throw exception, for now some code might call flush() on closed stream
542         // since file ucp implementation allows it
543         // throw io::NotConnectedException();
544     }
545 
546     if ( m_pStreamData->m_bTransacted )
547     {
548         // temporary stream data should be provided
549         if ( !m_pStreamData->m_xTempOutStream.is() )
550             throw uno::RuntimeException();
551 
552         m_pStreamData->m_xTempOutStream->flush();
553     }
554     else
555     {
556         // the original stream data should be provided
557         if ( !m_pStreamData->m_xOrigOutStream.is() )
558             throw uno::RuntimeException();
559 
560         m_pStreamData->m_xOrigOutStream->flush();
561     }
562 }
563 
564 
565 // ------------------------------------------------------------------------
566 void SAL_CALL OTruncatedTransactedFileStream::closeOutput(  )
567     throw (io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
568 {
569     ::osl::MutexGuard aGuard( m_aMutex );
570 
571     if ( !m_pStreamData )
572         throw io::NotConnectedException();
573 
574     m_pStreamData->m_bOutOpen = sal_False;
575     if ( !m_pStreamData->m_bInOpen )
576         CloseAll_Impl();
577 }
578 
579 
580 
581 // com::sun::star::io::XTruncate
582 // ------------------------------------------------------------------------
583 void SAL_CALL OTruncatedTransactedFileStream::truncate(  )
584     throw (io::IOException, uno::RuntimeException)
585 {
586     ::osl::MutexGuard aGuard( m_aMutex );
587 
588     if ( !m_pStreamData )
589         throw io::NotConnectedException();
590 
591     if ( m_pStreamData->m_bTransacted )
592     {
593         // temporary stream data should be provided
594         if ( !m_pStreamData->m_xTempTruncate.is() )
595             throw uno::RuntimeException();
596 
597         m_pStreamData->m_xTempTruncate->truncate();
598     }
599     else
600     {
601         // the original stream data should be provided
602         if ( !m_pStreamData->m_xOrigTruncate.is() )
603             throw uno::RuntimeException();
604 
605         m_pStreamData->m_xOrigTruncate->truncate();
606     }
607 }
608 
609 
610 
611 // com::sun::star::io::XSeekable
612 // ------------------------------------------------------------------------
613 void SAL_CALL OTruncatedTransactedFileStream::seek( ::sal_Int64 location )
614     throw (lang::IllegalArgumentException, io::IOException, uno::RuntimeException)
615 {
616     ::osl::MutexGuard aGuard( m_aMutex );
617 
618     if ( !m_pStreamData )
619         throw io::NotConnectedException();
620 
621     if ( m_pStreamData->m_bTransacted )
622     {
623         // temporary stream data should be provided
624         if ( !m_pStreamData->m_xTempSeekable.is() )
625             throw uno::RuntimeException();
626 
627         m_pStreamData->m_xTempSeekable->seek( location );
628     }
629     else
630     {
631         // the original stream data should be provided
632         if ( !m_pStreamData->m_xOrigSeekable.is() )
633             throw uno::RuntimeException();
634 
635         m_pStreamData->m_xOrigSeekable->seek( location );
636     }
637 }
638 
639 
640 // ------------------------------------------------------------------------
641 ::sal_Int64 SAL_CALL OTruncatedTransactedFileStream::getPosition(  )
642     throw (io::IOException, uno::RuntimeException)
643 {
644     ::osl::MutexGuard aGuard( m_aMutex );
645 
646     if ( !m_pStreamData )
647         throw io::NotConnectedException();
648 
649     if ( m_pStreamData->m_bTransacted )
650     {
651         // temporary stream data should be provided
652         if ( !m_pStreamData->m_xTempSeekable.is() )
653             throw uno::RuntimeException();
654 
655         return m_pStreamData->m_xTempSeekable->getPosition();
656     }
657     else
658     {
659         // the original stream data should be provided
660         if ( !m_pStreamData->m_xOrigSeekable.is() )
661             throw uno::RuntimeException();
662 
663         return m_pStreamData->m_xOrigSeekable->getPosition();
664     }
665 }
666 
667 
668 // ------------------------------------------------------------------------
669 ::sal_Int64 SAL_CALL OTruncatedTransactedFileStream::getLength(  )
670     throw (io::IOException, uno::RuntimeException)
671 {
672     ::osl::MutexGuard aGuard( m_aMutex );
673 
674     if ( !m_pStreamData )
675         throw io::NotConnectedException();
676 
677     if ( m_pStreamData->m_bTransacted )
678     {
679         // temporary stream data should be provided
680         if ( !m_pStreamData->m_xTempSeekable.is() )
681             throw uno::RuntimeException();
682 
683         return m_pStreamData->m_xTempSeekable->getLength();
684     }
685     else
686     {
687         // the original stream data should be provided
688         if ( !m_pStreamData->m_xOrigSeekable.is() )
689             throw uno::RuntimeException();
690 
691         return m_pStreamData->m_xOrigSeekable->getLength();
692     }
693 }
694 
695 // com::sun::star::beans::XPropertySetInfo
696 // ------------------------------------------------------------------------
697 uno::Sequence< beans::Property > SAL_CALL OTruncatedTransactedFileStream::getProperties()
698     throw (uno::RuntimeException)
699 {
700     ::osl::MutexGuard aGuard( m_aMutex );
701 
702     uno::Sequence< beans::Property > aProps( 1 );
703     aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
704     aProps[0].Type = getCppuType( static_cast< uno::Reference< beans::XPropertySet >* >( NULL ) );
705     aProps[0].Attributes = beans::PropertyAttribute::TRANSIENT | beans::PropertyAttribute::READONLY;
706 
707     return aProps;
708 }
709 
710 
711 // ------------------------------------------------------------------------
712 beans::Property SAL_CALL OTruncatedTransactedFileStream::getPropertyByName( const ::rtl::OUString& aName )
713     throw (beans::UnknownPropertyException, uno::RuntimeException)
714 {
715     ::osl::MutexGuard aGuard( m_aMutex );
716 
717     ::rtl::OUString aTransactionPropName( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
718 
719     if ( !aName.equals( aTransactionPropName ) )
720         throw beans::UnknownPropertyException();
721 
722     beans::Property aProp;
723     aProp.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
724     aProp.Type = getCppuType( static_cast< uno::Reference< beans::XPropertySet >* >( NULL ) );
725     aProp.Attributes = beans::PropertyAttribute::TRANSIENT | beans::PropertyAttribute::READONLY;
726 
727     return aProp;
728 }
729 
730 
731 // ------------------------------------------------------------------------
732 ::sal_Bool SAL_CALL OTruncatedTransactedFileStream::hasPropertyByName( const ::rtl::OUString& Name )
733     throw (uno::RuntimeException)
734 {
735     ::osl::MutexGuard aGuard( m_aMutex );
736 
737     ::rtl::OUString aTransactionPropName( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
738     return ( Name.equals( aTransactionPropName ) );
739 }
740 
741 
742 
743 // com::sun::star::beans::XPropertySet
744 // ------------------------------------------------------------------------
745 uno::Reference< beans::XPropertySetInfo > SAL_CALL OTruncatedTransactedFileStream::getPropertySetInfo()
746     throw (uno::RuntimeException)
747 {
748     ::osl::MutexGuard aGuard( m_aMutex );
749 
750     return static_cast< beans::XPropertySetInfo* >( this );
751 }
752 
753 
754 // ------------------------------------------------------------------------
755 void SAL_CALL OTruncatedTransactedFileStream::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& )
756     throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
757 {
758     ::osl::MutexGuard aGuard( m_aMutex );
759 
760     ::rtl::OUString aTransactionPropName( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
761     if ( aPropertyName.equals( aTransactionPropName ) )
762         throw beans::PropertyVetoException();
763 
764     throw beans::UnknownPropertyException();
765 }
766 
767 
768 // ------------------------------------------------------------------------
769 uno::Any SAL_CALL OTruncatedTransactedFileStream::getPropertyValue( const ::rtl::OUString& PropertyName )
770     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
771 {
772     ::osl::MutexGuard aGuard( m_aMutex );
773 
774     if ( !m_pStreamData )
775         throw io::NotConnectedException();
776 
777     ::rtl::OUString aTransactionPropName( RTL_CONSTASCII_USTRINGPARAM( "TransactionSupport" ) );
778     if ( PropertyName.equals( aTransactionPropName ) )
779     {
780         uno::Reference< embed::XTransactedObject > xObj;
781         if ( m_pStreamData->m_bTransacted )
782             xObj = static_cast< embed::XTransactedObject* >( new OTransactionHelper( this ) );
783 
784         return uno::makeAny( xObj );
785     }
786 
787     throw beans::UnknownPropertyException();
788 }
789 
790 
791 // ------------------------------------------------------------------------
792 void SAL_CALL OTruncatedTransactedFileStream::addPropertyChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XPropertyChangeListener >& )
793     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
794 {
795     // not implemented
796 }
797 
798 
799 // ------------------------------------------------------------------------
800 void SAL_CALL OTruncatedTransactedFileStream::removePropertyChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XPropertyChangeListener >& )
801     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
802 {
803     // not implemented
804 }
805 
806 
807 // ------------------------------------------------------------------------
808 void SAL_CALL OTruncatedTransactedFileStream::addVetoableChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XVetoableChangeListener >& )
809     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
810 {
811     // not implemented
812 }
813 
814 
815 // ------------------------------------------------------------------------
816 void SAL_CALL OTruncatedTransactedFileStream::removeVetoableChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XVetoableChangeListener >& )
817     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
818 {
819     // not implemented
820 }
821 
822 
823 } // namespace comphelper
824 
825