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 "definitioncontainer.hxx"
21 : #include "dbastrings.hrc"
22 : #include "apitools.hxx"
23 : #include "core_resource.hxx"
24 : #include "core_resource.hrc"
25 :
26 : #include <tools/debug.hxx>
27 : #include <tools/diagnose_ex.h>
28 : #include <osl/diagnose.h>
29 : #include <comphelper/sequence.hxx>
30 : #include <comphelper/enumhelper.hxx>
31 : #include <comphelper/extract.hxx>
32 : #include <cppuhelper/exc_hlp.hxx>
33 : #include <com/sun/star/lang/XComponent.hpp>
34 : #include <com/sun/star/ucb/CommandInfo.hpp>
35 : #include <com/sun/star/beans/XPropertySet.hpp>
36 : #include <com/sun/star/sdb/ErrorCondition.hpp>
37 : #include <comphelper/types.hxx>
38 : #include <ucbhelper/contentidentifier.hxx>
39 : #include <o3tl/compat_functional.hxx>
40 :
41 : using namespace ::com::sun::star::uno;
42 : using namespace ::com::sun::star::lang;
43 : using namespace ::com::sun::star::util;
44 : using namespace ::com::sun::star::beans;
45 : using namespace ::com::sun::star::container;
46 : using namespace ::com::sun::star::sdbcx;
47 : using namespace ::com::sun::star::sdb;
48 : using namespace ::osl;
49 : using namespace ::comphelper;
50 : using namespace ::cppu;
51 : using namespace ::com::sun::star::ucb;
52 :
53 : namespace dbaccess
54 : {
55 :
56 : // ODefinitionContainer_Impl
57 74 : void ODefinitionContainer_Impl::erase( TContentPtr _pDefinition )
58 : {
59 74 : NamedDefinitions::iterator aPos = find( _pDefinition );
60 74 : if ( aPos != end() )
61 0 : m_aDefinitions.erase( aPos );
62 74 : }
63 :
64 74 : ODefinitionContainer_Impl::const_iterator ODefinitionContainer_Impl::find( TContentPtr _pDefinition ) const
65 : {
66 : return ::std::find_if(
67 : m_aDefinitions.begin(),
68 : m_aDefinitions.end(),
69 : ::o3tl::compose1(
70 : ::std::bind2nd( ::std::equal_to< TContentPtr >(), _pDefinition ),
71 : ::o3tl::select2nd< NamedDefinitions::value_type >()
72 : )
73 74 : );
74 : }
75 :
76 74 : ODefinitionContainer_Impl::iterator ODefinitionContainer_Impl::find( TContentPtr _pDefinition )
77 : {
78 : return ::std::find_if(
79 : m_aDefinitions.begin(),
80 : m_aDefinitions.end(),
81 : ::o3tl::compose1(
82 : ::std::bind2nd( ::std::equal_to< TContentPtr >(), _pDefinition ),
83 : ::o3tl::select2nd< NamedDefinitions::value_type >()
84 : )
85 74 : );
86 : }
87 :
88 : // ODefinitionContainer
89 :
90 819 : ODefinitionContainer::ODefinitionContainer( const Reference< XComponentContext >& _xORB
91 : , const Reference< XInterface >& _xParentContainer
92 : , const TContentPtr& _pImpl
93 : , bool _bCheckSlash
94 : )
95 : :OContentHelper(_xORB,_xParentContainer,_pImpl)
96 : ,m_aApproveListeners(m_aMutex)
97 : ,m_aContainerListeners(m_aMutex)
98 : ,m_bInPropertyChange(false)
99 819 : ,m_bCheckSlash(_bCheckSlash)
100 : {
101 819 : m_pImpl->m_aProps.bIsDocument = false;
102 819 : m_pImpl->m_aProps.bIsFolder = true;
103 :
104 819 : const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
105 819 : ODefinitionContainer_Impl::const_iterator aEnd = rDefinitions.end();
106 862 : for ( ODefinitionContainer_Impl::const_iterator aDefinition = rDefinitions.begin();
107 : aDefinition != aEnd;
108 : ++aDefinition
109 : )
110 : m_aDocuments.push_back(
111 : m_aDocumentMap.insert(
112 43 : Documents::value_type( aDefinition->first, Documents::mapped_type() ) ).first );
113 :
114 819 : }
115 :
116 816 : void SAL_CALL ODefinitionContainer::disposing()
117 : {
118 816 : OContentHelper::disposing();
119 :
120 816 : MutexGuard aGuard(m_aMutex);
121 :
122 : // say goodbye to our listeners
123 1632 : EventObject aEvt(*this);
124 816 : m_aApproveListeners.disposeAndClear(aEvt);
125 816 : m_aContainerListeners.disposeAndClear(aEvt);
126 :
127 : // dispose our elements
128 816 : Documents::iterator aIter = m_aDocumentMap.begin();
129 816 : Documents::iterator aEnd = m_aDocumentMap.end();
130 :
131 959 : for (; aIter != aEnd; ++aIter)
132 : {
133 143 : Reference<XContent> xProp = aIter->second;
134 143 : if ( xProp.is() )
135 : {
136 11 : removeObjectListener(xProp);
137 11 : ::comphelper::disposeComponent(xProp);
138 : }
139 143 : }
140 :
141 : // remove our elements
142 816 : m_aDocuments.clear();
143 : // !!! do this before clearing the map which the vector elements refer to !!!
144 1632 : m_aDocumentMap.clear();
145 816 : }
146 :
147 816 : ODefinitionContainer::~ODefinitionContainer()
148 : {
149 816 : }
150 :
151 37892 : IMPLEMENT_FORWARD_XINTERFACE2( ODefinitionContainer,OContentHelper,ODefinitionContainer_Base)
152 2 : IMPLEMENT_GETTYPES2(ODefinitionContainer,OContentHelper,ODefinitionContainer_Base);
153 :
154 0 : css::uno::Sequence<sal_Int8> ODefinitionContainer::getImplementationId()
155 : throw (css::uno::RuntimeException, std::exception)
156 : {
157 0 : return css::uno::Sequence<sal_Int8>();
158 : }
159 :
160 : // XServiceInfo
161 0 : OUString SAL_CALL ODefinitionContainer::getImplementationName( ) throw(RuntimeException, std::exception)
162 : {
163 0 : return OUString("com.sun.star.sdb.ODefinitionContainer");
164 : }
165 :
166 0 : Sequence< OUString > SAL_CALL ODefinitionContainer::getSupportedServiceNames( ) throw(RuntimeException, std::exception)
167 : {
168 0 : Sequence< OUString > aReturn(2);
169 0 : aReturn.getArray()[0] = "com.sun.star.sdb.DefinitionContainer";
170 0 : aReturn.getArray()[1] = "com.sun.star.ucb.Content";
171 0 : return aReturn;
172 : }
173 :
174 : // XNameContainer
175 74 : void SAL_CALL ODefinitionContainer::insertByName( const OUString& _rName, const Any& aElement ) throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException, std::exception)
176 : {
177 74 : ResettableMutexGuard aGuard(m_aMutex);
178 :
179 : // approve the new object
180 148 : Reference< XContent > xNewElement(aElement,UNO_QUERY);
181 74 : approveNewObject( _rName, xNewElement ); // will throw if necessary
182 :
183 74 : notifyByName( aGuard, _rName, xNewElement, NULL, E_INSERTED, ApproveListeners );
184 74 : implAppend( _rName, xNewElement );
185 148 : notifyByName( aGuard, _rName, xNewElement, NULL, E_INSERTED, ContainerListemers );
186 74 : }
187 :
188 0 : void SAL_CALL ODefinitionContainer::removeByName( const OUString& _rName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
189 : {
190 0 : ResettableMutexGuard aGuard(m_aMutex);
191 :
192 : // check the arguments
193 0 : if (_rName.isEmpty())
194 0 : throw IllegalArgumentException();
195 :
196 0 : if (!checkExistence(_rName))
197 0 : throw NoSuchElementException(_rName,*this);
198 :
199 : // the old element (for the notifications)
200 0 : Reference< XContent > xOldElement = implGetByName( _rName, impl_haveAnyListeners_nothrow() );
201 :
202 : // do the removal
203 0 : notifyByName( aGuard, _rName, NULL, xOldElement, E_REMOVED, ApproveListeners );
204 0 : implRemove( _rName );
205 0 : notifyByName( aGuard, _rName, NULL, xOldElement, E_REMOVED, ContainerListemers );
206 :
207 0 : removeObjectListener( xOldElement );
208 0 : disposeComponent(xOldElement);
209 0 : }
210 :
211 : // XNameReplace
212 0 : void SAL_CALL ODefinitionContainer::replaceByName( const OUString& _rName, const Any& aElement ) throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
213 : {
214 0 : ResettableMutexGuard aGuard(m_aMutex);
215 :
216 : try
217 : {
218 : // let derived classes approve the new object
219 0 : Reference< XContent > xNewElement(aElement,UNO_QUERY);
220 0 : approveNewObject( _rName, xNewElement ); // will throw if necessary
221 :
222 : // the old element (for the notifications)
223 0 : Reference< XContent > xOldElement = implGetByName( _rName, impl_haveAnyListeners_nothrow() );
224 :
225 0 : notifyByName( aGuard, _rName, xNewElement, xOldElement, E_REPLACED, ApproveListeners );
226 0 : implReplace( _rName, xNewElement );
227 0 : notifyByName( aGuard, _rName, xNewElement, xOldElement, E_REPLACED, ContainerListemers );
228 :
229 : // and dispose it
230 0 : disposeComponent(xOldElement);
231 : }
232 0 : catch (const RuntimeException&)
233 : {
234 0 : throw;
235 : }
236 0 : catch (const NoSuchElementException&)
237 : {
238 0 : throw;
239 : }
240 0 : catch (const WrappedTargetException&)
241 : {
242 0 : throw;
243 : }
244 0 : catch (const Exception& e)
245 : {
246 0 : css::uno::Any a(cppu::getCaughtException());
247 : throw css::lang::WrappedTargetException(
248 0 : "wrapped Exception " + e.Message,
249 0 : css::uno::Reference<css::uno::XInterface>(), a);
250 0 : }
251 0 : }
252 :
253 : namespace
254 : {
255 : typedef Reference< XVeto > ( SAL_CALL XContainerApproveListener::*ContainerApprovalMethod )( const ContainerEvent& );
256 :
257 : struct RaiseExceptionFromVeto
258 : {
259 : private:
260 : ContainerApprovalMethod m_pMethod;
261 : const ContainerEvent& m_rEvent;
262 :
263 : public:
264 25 : RaiseExceptionFromVeto( ContainerApprovalMethod _pMethod, const ContainerEvent& _rEvent )
265 : :m_pMethod( _pMethod )
266 25 : ,m_rEvent( _rEvent )
267 : {
268 25 : }
269 :
270 25 : void operator()( const Reference< XContainerApproveListener >& _Listener ) const
271 : {
272 25 : Reference< XVeto > xVeto = (_Listener.get()->*m_pMethod)( m_rEvent );
273 25 : if ( !xVeto.is() )
274 50 : return;
275 :
276 0 : Any eVetoDetails = xVeto->getDetails();
277 :
278 0 : IllegalArgumentException aIllegalArgumentError;
279 0 : if ( eVetoDetails >>= aIllegalArgumentError )
280 0 : throw aIllegalArgumentError;
281 :
282 0 : WrappedTargetException aWrappedError;
283 0 : if ( eVetoDetails >>= aWrappedError )
284 0 : throw aWrappedError;
285 :
286 0 : throw WrappedTargetException( xVeto->getReason(), _Listener.get(), eVetoDetails );
287 : }
288 : };
289 : }
290 :
291 148 : void ODefinitionContainer::notifyByName( ResettableMutexGuard& _rGuard, const OUString& _rName,
292 : const Reference< XContent >& _xNewElement, const Reference< XContent >& _xOldElement,
293 : ContainerOperation _eOperation, ListenerType _eType )
294 : {
295 148 : bool bApprove = ( _eType == ApproveListeners );
296 :
297 148 : ::cppu::OInterfaceContainerHelper& rContainer( bApprove ? m_aApproveListeners : m_aContainerListeners );
298 148 : if ( !rContainer.getLength() )
299 245 : return;
300 :
301 51 : ContainerEvent aEvent( *this, makeAny( _rName ), makeAny( _xNewElement ), makeAny( _xOldElement ) );
302 :
303 51 : _rGuard.clear();
304 51 : switch ( _eOperation )
305 : {
306 : case E_INSERTED:
307 51 : if ( bApprove )
308 : rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
309 25 : RaiseExceptionFromVeto( &XContainerApproveListener::approveInsertElement, aEvent ) );
310 : else
311 26 : rContainer.notifyEach( &XContainerListener::elementInserted, aEvent );
312 51 : break;
313 : case E_REPLACED:
314 0 : if ( bApprove )
315 : rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
316 0 : RaiseExceptionFromVeto( &XContainerApproveListener::approveReplaceElement, aEvent ) );
317 : else
318 0 : rContainer.notifyEach( &XContainerListener::elementReplaced, aEvent );
319 0 : break;
320 : case E_REMOVED:
321 0 : if ( bApprove )
322 : rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
323 0 : RaiseExceptionFromVeto( &XContainerApproveListener::approveRemoveElement, aEvent ) );
324 : else
325 0 : rContainer.notifyEach( &XContainerListener::elementRemoved, aEvent );
326 0 : break;
327 : }
328 :
329 51 : if ( bApprove )
330 25 : _rGuard.reset();
331 : }
332 :
333 81 : void SAL_CALL ODefinitionContainer::addContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException, std::exception)
334 : {
335 81 : if (_rxListener.is())
336 81 : m_aContainerListeners.addInterface(_rxListener);
337 81 : }
338 :
339 80 : void SAL_CALL ODefinitionContainer::removeContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException, std::exception)
340 : {
341 80 : if (_rxListener.is())
342 80 : m_aContainerListeners.removeInterface(_rxListener);
343 80 : }
344 :
345 47 : void SAL_CALL ODefinitionContainer::addContainerApproveListener( const Reference< XContainerApproveListener >& _Listener ) throw (RuntimeException, std::exception)
346 : {
347 47 : if ( _Listener.is() )
348 47 : m_aApproveListeners.addInterface( _Listener );
349 47 : }
350 :
351 46 : void SAL_CALL ODefinitionContainer::removeContainerApproveListener( const Reference< XContainerApproveListener >& _Listener ) throw (RuntimeException, std::exception)
352 : {
353 46 : if ( _Listener.is() )
354 46 : m_aApproveListeners.removeInterface( _Listener );
355 46 : }
356 :
357 : // XElementAccess
358 0 : Type SAL_CALL ODefinitionContainer::getElementType( ) throw (RuntimeException, std::exception)
359 : {
360 0 : return cppu::UnoType<XContent>::get();
361 : }
362 :
363 675 : sal_Bool SAL_CALL ODefinitionContainer::hasElements( ) throw (RuntimeException, std::exception)
364 : {
365 675 : MutexGuard aGuard(m_aMutex);
366 675 : return !m_aDocuments.empty();
367 : }
368 :
369 : // XEnumerationAccess
370 0 : Reference< XEnumeration > SAL_CALL ODefinitionContainer::createEnumeration( ) throw(RuntimeException, std::exception)
371 : {
372 0 : MutexGuard aGuard(m_aMutex);
373 0 : return new ::comphelper::OEnumerationByIndex(static_cast<XIndexAccess*>(this));
374 : }
375 :
376 : // XIndexAccess
377 0 : sal_Int32 SAL_CALL ODefinitionContainer::getCount( ) throw(RuntimeException, std::exception)
378 : {
379 0 : MutexGuard aGuard(m_aMutex);
380 0 : return m_aDocuments.size();
381 : }
382 :
383 0 : Any SAL_CALL ODefinitionContainer::getByIndex( sal_Int32 _nIndex ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception)
384 : {
385 0 : MutexGuard aGuard(m_aMutex);
386 :
387 0 : if ((_nIndex < 0) || (_nIndex >= (sal_Int32)m_aDocuments.size()))
388 0 : throw IndexOutOfBoundsException();
389 :
390 0 : Documents::iterator aPos = m_aDocuments[_nIndex];
391 0 : Reference<XContent> xProp = aPos->second;
392 0 : if (!xProp.is())
393 : { // that's the first access to the object
394 : // -> create it
395 0 : xProp = createObject(aPos->first);
396 0 : aPos->second = Documents::mapped_type();
397 : // and update the name-access map
398 : }
399 :
400 0 : return makeAny(xProp);
401 : }
402 :
403 74 : Any SAL_CALL ODefinitionContainer::getByName( const OUString& _rName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
404 : {
405 74 : MutexGuard aGuard(m_aMutex);
406 :
407 74 : return makeAny( implGetByName( _rName, true ) );
408 : }
409 :
410 74 : Reference< XContent > ODefinitionContainer::implGetByName(const OUString& _rName, bool _bReadIfNecessary) throw (NoSuchElementException)
411 : {
412 74 : Documents::iterator aMapPos = m_aDocumentMap.find(_rName);
413 74 : if (aMapPos == m_aDocumentMap.end())
414 0 : throw NoSuchElementException(_rName,*this);
415 :
416 74 : Reference< XContent > xProp = aMapPos->second;
417 :
418 74 : if (_bReadIfNecessary && !xProp.is())
419 : { // the object has never been accessed before, so we have to read it now
420 : // (that's the expensive part)
421 :
422 : // create the object and insert it into the map
423 36 : xProp = createObject(_rName);
424 36 : aMapPos->second = xProp;
425 36 : addObjectListener(xProp);
426 : }
427 :
428 74 : return xProp;
429 : }
430 :
431 76 : Sequence< OUString > SAL_CALL ODefinitionContainer::getElementNames( ) throw(RuntimeException, std::exception)
432 : {
433 76 : MutexGuard aGuard(m_aMutex);
434 :
435 76 : Sequence< OUString > aNames(m_aDocumentMap.size());
436 76 : OUString* pNames = aNames.getArray();
437 76 : Documents::iterator aEnd = m_aDocumentMap.end();
438 101 : for ( Documents::iterator aNameIter = m_aDocumentMap.begin();
439 : aNameIter != aEnd;
440 : ++pNames, ++aNameIter
441 : )
442 : {
443 25 : *pNames = aNameIter->first;
444 : }
445 :
446 76 : return aNames;
447 : }
448 :
449 606 : sal_Bool SAL_CALL ODefinitionContainer::hasByName( const OUString& _rName ) throw(RuntimeException, std::exception)
450 : {
451 606 : MutexGuard aGuard(m_aMutex);
452 :
453 606 : return checkExistence(_rName);
454 : }
455 :
456 24 : void SAL_CALL ODefinitionContainer::disposing( const EventObject& _rSource ) throw(RuntimeException, std::exception)
457 : {
458 24 : MutexGuard aGuard(m_aMutex);
459 48 : Reference< XContent > xSource(_rSource.Source, UNO_QUERY);
460 : // it's one of our documents ....
461 24 : Documents::iterator aIter = m_aDocumentMap.begin();
462 24 : Documents::iterator aEnd = m_aDocumentMap.end();
463 76 : for (;aIter != aEnd;++aIter )
464 : {
465 52 : if ( xSource == aIter->second.get() )
466 : {
467 0 : removeObjectListener(xSource);
468 : // and clear our document map/vector, so the object will be recreated on next access
469 0 : aIter->second = Documents::mapped_type();
470 : }
471 24 : }
472 24 : }
473 :
474 0 : void ODefinitionContainer::implRemove(const OUString& _rName)
475 : {
476 : // from the object maps
477 0 : Documents::iterator aFind = m_aDocumentMap.find(_rName);
478 0 : if ( aFind != m_aDocumentMap.end() )
479 : {
480 0 : m_aDocuments.erase( ::std::find(m_aDocuments.begin(),m_aDocuments.end(),aFind));
481 0 : m_aDocumentMap.erase(aFind);
482 :
483 0 : getDefinitions().erase( _rName );
484 :
485 0 : notifyDataSourceModified();
486 : }
487 0 : }
488 :
489 : namespace
490 : {
491 99 : bool lcl_ensureName( const Reference< XContent >& _rxContent, const OUString& _rName )
492 : {
493 99 : if ( !_rxContent.is() )
494 25 : return true;
495 :
496 : // obtain the current name. If it's the same as the new one,
497 : // don't do anything
498 : try
499 : {
500 74 : Reference< XPropertySet > xProps( _rxContent, UNO_QUERY );
501 74 : if ( xProps.is() )
502 : {
503 74 : OUString sCurrentName;
504 74 : OSL_VERIFY( xProps->getPropertyValue( PROPERTY_NAME ) >>= sCurrentName );
505 74 : if ( sCurrentName.equals( _rName ) )
506 49 : return true;
507 25 : }
508 : }
509 0 : catch( const Exception& )
510 : {
511 : OSL_FAIL( "lcl_ensureName: caught an exception while obtaining the current name!" );
512 : }
513 :
514 : // set the new name
515 25 : Reference< XRename > xRename( _rxContent, UNO_QUERY );
516 : OSL_ENSURE( xRename.is(), "lcl_ensureName: invalid content (not renameable)!" );
517 25 : if ( !xRename.is() )
518 0 : return false;
519 : try
520 : {
521 25 : xRename->rename( _rName );
522 25 : return true;
523 : }
524 0 : catch( const Exception& )
525 : {
526 : OSL_FAIL( "lcl_ensureName: caught an exception!" );
527 : }
528 25 : return false;
529 : }
530 : }
531 :
532 99 : void ODefinitionContainer::implAppend(const OUString& _rName, const Reference< XContent >& _rxNewObject)
533 : {
534 99 : MutexGuard aGuard(m_aMutex);
535 : try
536 : {
537 99 : Reference<XChild> xChild(_rxNewObject,UNO_QUERY);
538 99 : if ( xChild.is() )
539 74 : xChild->setParent(static_cast<OWeakObject*>(this));
540 :
541 99 : ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
542 99 : ODefinitionContainer_Impl::const_iterator aFind = rDefinitions.find( _rName );
543 99 : if ( aFind == rDefinitions.end() )
544 : {
545 : // ensure that the new object has the proper name.
546 : // Somebody could create an object with name "foo", and insert it as "bar"
547 : // into a container. In this case, we need to ensure that the object name
548 : // is also "bar"
549 : // #i44786#
550 99 : lcl_ensureName( _rxNewObject, _rName );
551 :
552 99 : ::rtl::Reference< OContentHelper > pContent = OContentHelper::getImplementation( _rxNewObject );
553 99 : if ( pContent.is() )
554 : {
555 74 : TContentPtr pImpl = pContent->getImpl();
556 74 : rDefinitions.erase( pImpl );
557 74 : pImpl->m_aProps.aTitle = _rName;
558 74 : rDefinitions.insert( _rName, pImpl );
559 99 : }
560 : }
561 :
562 99 : m_aDocuments.push_back(m_aDocumentMap.insert(Documents::value_type(_rName,_rxNewObject)).first);
563 99 : notifyDataSourceModified();
564 : // now update our structures
565 99 : if ( _rxNewObject.is() )
566 74 : addObjectListener(_rxNewObject);
567 : }
568 0 : catch(Exception&)
569 : {
570 : OSL_FAIL("ODefinitionContainer::implAppend: caught something !");
571 99 : }
572 99 : }
573 :
574 0 : void ODefinitionContainer::implReplace(const OUString& _rName, const Reference< XContent >& _rxNewObject)
575 : {
576 : OSL_ENSURE(checkExistence(_rName), "ODefinitionContainer::implReplace : invalid name !");
577 :
578 0 : Documents::iterator aFind = m_aDocumentMap.find(_rName);
579 0 : removeObjectListener(aFind->second);
580 0 : aFind->second = _rxNewObject;
581 0 : addObjectListener(aFind->second);
582 0 : }
583 :
584 74 : void ODefinitionContainer::approveNewObject(const OUString& _sName,const Reference< XContent >& _rxObject) const
585 : {
586 : // check the arguments
587 74 : if ( _sName.isEmpty() )
588 : throw IllegalArgumentException(
589 : DBA_RES( RID_STR_NAME_MUST_NOT_BE_EMPTY ),
590 : *this,
591 0 : 0 );
592 :
593 74 : if ( m_bCheckSlash && _sName.indexOf( '/' ) != -1 )
594 : throw IllegalArgumentException(
595 : m_aErrorHelper.getErrorMessage( ErrorCondition::DB_OBJECT_NAME_WITH_SLASHES ),
596 : *this,
597 0 : 0 );
598 :
599 74 : if ( !_rxObject.is() )
600 : throw IllegalArgumentException(
601 : DBA_RES( RID_STR_NO_NULL_OBJECTS_IN_CONTAINER ),
602 : *this,
603 0 : 0 );
604 :
605 74 : const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
606 74 : if ( rDefinitions.find( _sName ) != rDefinitions.end() )
607 : throw ElementExistException(
608 : DBA_RES( RID_STR_NAME_ALREADY_USED ),
609 0 : *this );
610 :
611 74 : ::rtl::Reference< OContentHelper > pContent( OContentHelper::getImplementation( _rxObject ) );
612 74 : if ( !pContent.is() )
613 : throw IllegalArgumentException(
614 : DBA_RES( RID_STR_OBJECT_CONTAINER_MISMATCH ),
615 : *this,
616 0 : 1 );
617 :
618 74 : if ( rDefinitions.find( pContent->getImpl() ) != rDefinitions.end() )
619 : throw ElementExistException(
620 : DBA_RES( RID_STR_OBJECT_ALREADY_CONTAINED ),
621 0 : *this );
622 74 : }
623 :
624 : // XPropertyChangeListener
625 0 : void SAL_CALL ODefinitionContainer::propertyChange( const PropertyChangeEvent& evt ) throw (RuntimeException, std::exception)
626 : {
627 0 : ClearableMutexGuard aGuard(m_aMutex);
628 0 : if( evt.PropertyName == PROPERTY_NAME || evt.PropertyName == "Title" )
629 : {
630 0 : m_bInPropertyChange = true;
631 : try
632 : {
633 0 : OUString sNewName,sOldName;
634 0 : evt.OldValue >>= sOldName;
635 0 : evt.NewValue >>= sNewName;
636 0 : Reference<XContent> xContent( evt.Source, UNO_QUERY );
637 0 : removeObjectListener( xContent );
638 0 : implRemove( sOldName );
639 0 : implAppend( sNewName, xContent );
640 : }
641 0 : catch(const Exception&)
642 : {
643 : DBG_UNHANDLED_EXCEPTION();
644 0 : throw RuntimeException();
645 : }
646 0 : m_bInPropertyChange = false;
647 0 : }
648 0 : }
649 :
650 : // XVetoableChangeListener
651 0 : void SAL_CALL ODefinitionContainer::vetoableChange( const PropertyChangeEvent& aEvent ) throw (PropertyVetoException, RuntimeException, std::exception)
652 : {
653 0 : MutexGuard aGuard(m_aMutex);
654 :
655 0 : if( aEvent.PropertyName == PROPERTY_NAME || aEvent.PropertyName == "Title" )
656 : {
657 0 : OUString sNewName;
658 0 : aEvent.NewValue >>= sNewName;
659 0 : if(hasByName(sNewName))
660 0 : throw PropertyVetoException();
661 0 : }
662 0 : }
663 :
664 110 : void ODefinitionContainer::addObjectListener(const Reference< XContent >& _xNewObject)
665 : {
666 : OSL_ENSURE(_xNewObject.is(),"ODefinitionContainer::addObjectListener: Object is null!");
667 110 : Reference<XPropertySet> xProp(_xNewObject,UNO_QUERY);
668 110 : if ( xProp.is() )
669 : {
670 110 : xProp->addPropertyChangeListener(PROPERTY_NAME, this);
671 110 : xProp->addVetoableChangeListener(PROPERTY_NAME, this);
672 110 : }
673 110 : }
674 :
675 11 : void ODefinitionContainer::removeObjectListener(const Reference< XContent >& _xNewObject)
676 : {
677 11 : Reference<XPropertySet> xProp(_xNewObject,UNO_QUERY);
678 11 : if ( xProp.is() )
679 : {
680 11 : xProp->removePropertyChangeListener(PROPERTY_NAME, this);
681 11 : xProp->removeVetoableChangeListener(PROPERTY_NAME, this);
682 11 : }
683 11 : }
684 :
685 335 : bool ODefinitionContainer::checkExistence(const OUString& _rName)
686 : {
687 335 : return m_aDocumentMap.find(_rName) != m_aDocumentMap.end();
688 : }
689 :
690 : }
691 :
692 : // namespace dbaccess
693 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
