svx/source/form/dataaccessdescriptor.cxx

   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 <svx/dataaccessdescriptor.hxx>
  21 #include <comphelper/propertysetinfo.hxx>
  22 #include <comphelper/genericpropertyset.hxx>
  23 #include <osl/diagnose.h>
  24 #include <com/sun/star/sdbc/XConnection.hpp>
  25 #include <com/sun/star/ucb/XContent.hpp>
  26 #include <com/sun/star/beans/PropertyAttribute.hpp>
  27 #include <tools/urlobj.hxx>
  28
  29
  30 namespace svx
  31 {
  32
  33
  34     using namespace ::com::sun::star::uno;
  35     using namespace ::com::sun::star::sdbc;
  36     using namespace ::com::sun::star::beans;
  37     using namespace ::com::sun::star::ucb;
  38     using namespace ::comphelper;
  39
  40
  41     //= ODADescriptorImpl
  42
  43     class ODADescriptorImpl
  44     {
  45     protected:
  46         bool                    m_bSetOutOfDate         : 1;
  47         bool                    m_bSequenceOutOfDate    : 1;
  48
  49     public:
  50         typedef ::std::map< DataAccessDescriptorProperty, Any >     DescriptorValues;
  51         DescriptorValues            m_aValues;
  52         Sequence< PropertyValue >   m_aAsSequence;
  53         Reference< XPropertySet >   m_xAsSet;
  54
  55         typedef ::std::map< OUString, PropertyMapEntry const * >    MapString2PropertyEntry;
  56
  57     public:
  58         ODADescriptorImpl();
  59         ODADescriptorImpl(const ODADescriptorImpl& _rSource);
  60
  61         void invalidateExternRepresentations();
  62
  63         void updateSequence();
  64
  65         /** builds the descriptor from a property value sequence
  66             @return <TRUE/>
  67                 if and only if the sequence contained valid properties only
  68         */
  69         bool buildFrom( const Sequence< PropertyValue >& _rValues );
  70
  71         /** builds the descriptor from a property set
  72             @return <TRUE/>
  73                 if and only if the set contained valid properties only
  74         */
  75         bool buildFrom( const Reference< XPropertySet >& _rValues );
  76
  77     protected:
  78         static PropertyValue                    buildPropertyValue( const DescriptorValues::const_iterator& _rPos );
  79         static const MapString2PropertyEntry&   getPropertyMap( );
  80         static PropertyMapEntry const *         getPropertyMapEntry( const DescriptorValues::const_iterator& _rPos );
  81     };
  82
  83
  84     ODADescriptorImpl::ODADescriptorImpl()
  85         :m_bSetOutOfDate(true)
  86         ,m_bSequenceOutOfDate(true)
  87     {
  88     }
  89
  90
  91     ODADescriptorImpl::ODADescriptorImpl(const ODADescriptorImpl& _rSource)
  92         :m_bSetOutOfDate( _rSource.m_bSetOutOfDate )
  93         ,m_bSequenceOutOfDate( _rSource.m_bSequenceOutOfDate )
  94         ,m_aValues( _rSource.m_aValues )
  95     {
  96         if (!m_bSetOutOfDate)
  97             m_xAsSet = _rSource.m_xAsSet;
  98         if (!m_bSequenceOutOfDate)
  99             m_aAsSequence = _rSource.m_aAsSequence;
 100     }
 101
 102
 103     bool ODADescriptorImpl::buildFrom( const Sequence< PropertyValue >& _rValues )
 104     {
 105         const MapString2PropertyEntry& rProperties = getPropertyMap();
 106
 107         bool bValidPropsOnly = true;
 108
 109         // loop through the sequence, and fill our m_aValues
 110         const PropertyValue* pValues = _rValues.getConstArray();
 111         const PropertyValue* pValuesEnd = pValues + _rValues.getLength();
 112         for (;pValues != pValuesEnd; ++pValues)
 113         {
 114             MapString2PropertyEntry::const_iterator aPropPos = rProperties.find( pValues->Name );
 115             if ( aPropPos != rProperties.end() )
 116             {
 117                 DataAccessDescriptorProperty eProperty = (DataAccessDescriptorProperty)aPropPos->second->mnHandle;
 118                 m_aValues[eProperty] = pValues->Value;
 119             }
 120             else
 121                 // unknown property
 122                 bValidPropsOnly = false;
 123         }
 124
 125         if (bValidPropsOnly)
 126         {
 127             m_aAsSequence = _rValues;
 128             m_bSequenceOutOfDate = false;
 129         }
 130         else
 131             m_bSequenceOutOfDate = true;
 132
 133         return bValidPropsOnly;
 134     }
 135
 136
 137     bool ODADescriptorImpl::buildFrom( const Reference< XPropertySet >& _rxValues )
 138     {
 139         Reference< XPropertySetInfo > xPropInfo;
 140         if (_rxValues.is())
 141             xPropInfo = _rxValues->getPropertySetInfo();
 142         if (!xPropInfo.is())
 143         {
 144             OSL_FAIL("ODADescriptorImpl::buildFrom: invalid property set!");
 145             return false;
 146         }
 147
 148         // build a PropertyValue sequence with the current values
 149         Sequence< Property > aProperties = xPropInfo->getProperties();
 150         const Property* pProperty = aProperties.getConstArray();
 151         const Property* pPropertyEnd = pProperty + aProperties.getLength();
 152
 153         Sequence< PropertyValue > aValues(aProperties.getLength());
 154         PropertyValue* pValues = aValues.getArray();
 155
 156         for (;pProperty != pPropertyEnd; ++pProperty, ++pValues)
 157         {
 158             pValues->Name = pProperty->Name;
 159             pValues->Value = _rxValues->getPropertyValue(pProperty->Name);
 160         }
 161
 162         bool bValidPropsOnly = buildFrom(aValues);
 163         if (bValidPropsOnly)
 164         {
 165             m_xAsSet = _rxValues;
 166             m_bSetOutOfDate = false;
 167         }
 168         else
 169             m_bSetOutOfDate = true;
 170
 171         return bValidPropsOnly;
 172     }
 173
 174
 175     void ODADescriptorImpl::invalidateExternRepresentations()
 176     {
 177         m_bSetOutOfDate = true;
 178         m_bSequenceOutOfDate = true;
 179     }
 180
 181
 182     const ODADescriptorImpl::MapString2PropertyEntry& ODADescriptorImpl::getPropertyMap( )
 183     {
 184         // the properties we know
 185         static MapString2PropertyEntry s_aProperties;
 186         if ( s_aProperties.empty() )
 187         {
 188             static PropertyMapEntry const s_aDesriptorProperties[] =
 189             {
 190                 { OUString("ActiveConnection"),   daConnection,           cppu::UnoType<XConnection>::get(),   PropertyAttribute::TRANSIENT, 0 },
 191                 { OUString("BookmarkSelection"),  daBookmarkSelection,    ::getBooleanCppuType( ),                                           PropertyAttribute::TRANSIENT, 0 },
 192                 { OUString("Column"),             daColumnObject,         cppu::UnoType<XPropertySet>::get(),  PropertyAttribute::TRANSIENT, 0 },
 193                 { OUString("ColumnName"),         daColumnName,           ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 194                 { OUString("Command"),            daCommand,              ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 195                 { OUString("CommandType"),        daCommandType,          ::cppu::UnoType<sal_Int32>::get(),                  PropertyAttribute::TRANSIENT, 0 },
 196                 { OUString("Component"),          daComponent,            cppu::UnoType<XContent>::get(),      PropertyAttribute::TRANSIENT, 0 },
 197                 { OUString("ConnectionResource"), daConnectionResource,   ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 198                 { OUString("Cursor"),             daCursor,               cppu::UnoType<XResultSet>::get(),     PropertyAttribute::TRANSIENT, 0 },
 199                 { OUString("DataSourceName"),     daDataSource,           ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 200                 { OUString("DatabaseLocation"),   daDatabaseLocation,     ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 201                 { OUString("EscapeProcessing"),   daEscapeProcessing,     ::getBooleanCppuType( ),                                           PropertyAttribute::TRANSIENT, 0 },
 202                 { OUString("Filter"),             daFilter,               ::cppu::UnoType<OUString>::get(),            PropertyAttribute::TRANSIENT, 0 },
 203                 { OUString("Selection"),          daSelection,            ::getCppuType( static_cast< Sequence< Any >* >(NULL) ),            PropertyAttribute::TRANSIENT, 0 },
 204                 { OUString(), 0, css::uno::Type(), 0, 0 }
 205             };
 206
 207             PropertyMapEntry const * pEntry = s_aDesriptorProperties;
 208             while ( !pEntry->maName.isEmpty() )
 209             {
 210                 s_aProperties[ pEntry->maName ] = pEntry;
 211                 ++pEntry;
 212             }
 213         }
 214
 215         return s_aProperties;
 216     }
 217
 218
 219     PropertyMapEntry const * ODADescriptorImpl::getPropertyMapEntry( const DescriptorValues::const_iterator& _rPos )
 220     {
 221         const MapString2PropertyEntry& rProperties = getPropertyMap();
 222
 223         sal_Int32 nNeededHandle = (sal_Int32)(_rPos->first);
 224
 225         for ( MapString2PropertyEntry::const_iterator loop = rProperties.begin();
 226               loop != rProperties.end();
 227               ++loop
 228             )
 229         {
 230             if ( nNeededHandle == loop->second->mnHandle )
 231                 return loop->second;
 232         }
 233         throw RuntimeException();
 234     }
 235
 236
 237     PropertyValue ODADescriptorImpl::buildPropertyValue( const DescriptorValues::const_iterator& _rPos )
 238     {
 239         // the map entry
 240         PropertyMapEntry const * pProperty = getPropertyMapEntry( _rPos );
 241
 242         // build the property value
 243         PropertyValue aReturn;
 244         aReturn.Name    = pProperty->maName;
 245         aReturn.Handle  = pProperty->mnHandle;
 246         aReturn.Value   = _rPos->second;
 247         aReturn.State   = PropertyState_DIRECT_VALUE;
 248
 249         // outta here
 250         return aReturn;
 251     }
 252
 253
 254     void ODADescriptorImpl::updateSequence()
 255     {
 256         if (!m_bSequenceOutOfDate)
 257             return;
 258
 259         m_aAsSequence.realloc(m_aValues.size());
 260         PropertyValue* pValue = m_aAsSequence.getArray();
 261
 262         // loop through all our values
 263         for (   DescriptorValues::const_iterator aLoop = m_aValues.begin();
 264                 aLoop != m_aValues.end();
 265                 ++aLoop, ++pValue
 266             )
 267         {
 268             *pValue = buildPropertyValue(aLoop);
 269         }
 270
 271         // don't need to rebuild next time
 272         m_bSequenceOutOfDate = false;
 273     }
 274
 275
 276     //= ODataAccessDescriptor
 277
 278
 279     ODataAccessDescriptor::ODataAccessDescriptor()
 280         :m_pImpl(new ODADescriptorImpl)
 281     {
 282     }
 283
 284
 285     ODataAccessDescriptor::ODataAccessDescriptor( const ODataAccessDescriptor& _rSource )
 286         :m_pImpl(new ODADescriptorImpl(*_rSource.m_pImpl))
 287     {
 288     }
 289
 290
 291     const ODataAccessDescriptor& ODataAccessDescriptor::operator=(const ODataAccessDescriptor& _rSource)
 292     {
 293         delete m_pImpl;
 294         m_pImpl = new ODADescriptorImpl(*_rSource.m_pImpl);
 295         return *this;
 296     }
 297
 298
 299     ODataAccessDescriptor::ODataAccessDescriptor( const Reference< XPropertySet >& _rValues )
 300         :m_pImpl(new ODADescriptorImpl)
 301     {
 302         m_pImpl->buildFrom(_rValues);
 303     }
 304
 305
 306     ODataAccessDescriptor::ODataAccessDescriptor( const Any& _rValues )
 307         :m_pImpl(new ODADescriptorImpl)
 308     {
 309         // check if we know the format in the Any
 310         Sequence< PropertyValue > aValues;
 311         Reference< XPropertySet > xValues;
 312         if ( _rValues >>= aValues )
 313             m_pImpl->buildFrom( aValues );
 314         else if ( _rValues >>= xValues )
 315             m_pImpl->buildFrom( xValues );
 316     }
 317
 318
 319     ODataAccessDescriptor::ODataAccessDescriptor( const Sequence< PropertyValue >& _rValues )
 320         :m_pImpl(new ODADescriptorImpl)
 321     {
 322         m_pImpl->buildFrom(_rValues);
 323     }
 324
 325
 326     ODataAccessDescriptor::~ODataAccessDescriptor()
 327     {
 328         delete m_pImpl;
 329     }
 330
 331
 332     void ODataAccessDescriptor::clear()
 333     {
 334         m_pImpl->m_aValues.clear();
 335     }
 336
 337
 338     void ODataAccessDescriptor::erase(DataAccessDescriptorProperty _eWhich)
 339     {
 340         OSL_ENSURE(has(_eWhich), "ODataAccessDescriptor::erase: invalid call!");
 341         if (has(_eWhich))
 342             m_pImpl->m_aValues.erase(_eWhich);
 343     }
 344
 345
 346     bool ODataAccessDescriptor::has(DataAccessDescriptorProperty _eWhich) const
 347     {
 348         return m_pImpl->m_aValues.find(_eWhich) != m_pImpl->m_aValues.end();
 349     }
 350
 351
 352     const Any& ODataAccessDescriptor::operator [] ( DataAccessDescriptorProperty _eWhich ) const
 353     {
 354         if (!has(_eWhich))
 355         {
 356             OSL_FAIL("ODataAccessDescriptor::operator[]: invalid acessor!");
 357             static const Any aDummy;
 358             return aDummy;
 359         }
 360
 361         return m_pImpl->m_aValues[_eWhich];
 362     }
 363
 364
 365     Any& ODataAccessDescriptor::operator[] ( DataAccessDescriptorProperty _eWhich )
 366     {
 367         m_pImpl->invalidateExternRepresentations();
 368         return m_pImpl->m_aValues[_eWhich];
 369     }
 370
 371
 372     void ODataAccessDescriptor::initializeFrom(const Sequence< PropertyValue >& _rValues, bool _bClear)
 373     {
 374         if (_bClear)
 375             clear();
 376         m_pImpl->buildFrom(_rValues);
 377     }
 378
 379
 380     Sequence< PropertyValue > ODataAccessDescriptor::createPropertyValueSequence()
 381     {
 382         m_pImpl->updateSequence();
 383         return m_pImpl->m_aAsSequence;
 384     }
 385
 386
 387     OUString ODataAccessDescriptor::getDataSource() const
 388     {
 389         OUString sDataSourceName;
 390         if ( has(daDataSource) )
 391             (*this)[daDataSource] >>= sDataSourceName;
 392         else if ( has(daDatabaseLocation) )
 393             (*this)[daDatabaseLocation] >>= sDataSourceName;
 394         return sDataSourceName;
 395     }
 396
 397     void ODataAccessDescriptor::setDataSource(const OUString& _sDataSourceNameOrLocation)
 398     {
 399         if ( !_sDataSourceNameOrLocation.isEmpty() )
 400         {
 401             INetURLObject aURL(_sDataSourceNameOrLocation);
 402             (*this)[ (( aURL.GetProtocol() == INET_PROT_FILE ) ? daDatabaseLocation : daDataSource)] <<= _sDataSourceNameOrLocation;
 403         }
 404         else
 405             (*this)[ daDataSource ] <<= OUString();
 406     }
 407
 408
 409 }   // namespace svx
 410
 411
 412
 413 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */