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