xmloff/source/core/unoatrcn.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unoatrcn.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33 #include <tools/debug.hxx>
  34 #include <com/sun/star/xml/AttributeData.hpp>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <rtl/uuid.h>
  37 #include <rtl/memory.h>
  38
  39 #include <xmloff/xmlcnimp.hxx>
  40
  41 #include "unoatrcn.hxx"
  42
  43 using ::rtl::OUString;
  44 using ::rtl::OUStringBuffer;
  45
  46 using namespace ::com::sun::star;
  47
  48 // --------------------------------------------------------------------
  49 // Interface implementation
  50 // --------------------------------------------------------------------
  51
  52 #define IMPL    ((AttrContainerImpl*)mpData)
  53
  54 uno::Reference< uno::XInterface >  SvUnoAttributeContainer_CreateInstance()
  55 {
  56     return *(new SvUnoAttributeContainer);
  57 }
  58
  59 SvUnoAttributeContainer::SvUnoAttributeContainer( SvXMLAttrContainerData* pContainer)
  60 : mpContainer( pContainer )
  61 {
  62     if( mpContainer == NULL )
  63         mpContainer = new SvXMLAttrContainerData;
  64 }
  65
  66 SvUnoAttributeContainer::~SvUnoAttributeContainer()
  67 {
  68     delete mpContainer;
  69 }
  70
  71 // container::XElementAccess
  72 uno::Type SAL_CALL SvUnoAttributeContainer::getElementType(void)
  73     throw( uno::RuntimeException )
  74 {
  75     return ::getCppuType((const xml::AttributeData*)0);
  76 }
  77
  78 sal_Bool SAL_CALL SvUnoAttributeContainer::hasElements(void)
  79     throw( uno::RuntimeException )
  80 {
  81     return mpContainer->GetAttrCount() != 0;
  82 }
  83
  84 sal_uInt16 SvUnoAttributeContainer::getIndexByName(const OUString& aName ) const
  85 {
  86     const sal_uInt16 nAttrCount = mpContainer->GetAttrCount();
  87
  88     sal_Int32 nPos = aName.indexOf( sal_Unicode(':') );
  89     if( nPos == -1L )
  90     {
  91         for( sal_uInt16 nAttr = 0; nAttr < nAttrCount; nAttr++ )
  92         {
  93             if( mpContainer->GetAttrLName(nAttr) == aName &&
  94                 mpContainer->GetAttrPrefix(nAttr).getLength() == 0L )
  95                 return nAttr;
  96         }
  97     }
  98     else
  99     {
 100         const OUString aPrefix( aName.copy( 0L, nPos ) );
 101         const OUString aLName( aName.copy( nPos+1L ) );
 102
 103         for( sal_uInt16 nAttr = 0; nAttr < nAttrCount; nAttr++ )
 104         {
 105             if( mpContainer->GetAttrLName(nAttr) == aLName &&
 106                 mpContainer->GetAttrPrefix(nAttr) == aPrefix )
 107                 return nAttr;
 108         }
 109     }
 110
 111     return USHRT_MAX;
 112 }
 113
 114 const ::com::sun::star::uno::Sequence< sal_Int8 > & SvUnoAttributeContainer::getUnoTunnelId() throw()
 115 {
 116     static ::com::sun::star::uno::Sequence< sal_Int8 > * pSeq = 0;
 117     if( !pSeq )
 118     {
 119         ::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() );
 120         if( !pSeq )
 121         {
 122             static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq( 16 );
 123             rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
 124             pSeq = &aSeq;
 125         }
 126     }
 127     return *pSeq;
 128 }
 129
 130 SvUnoAttributeContainer* SvUnoAttributeContainer::getImplementation( uno::Reference< uno::XInterface > xInt ) throw()
 131 {
 132     ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUT( xInt, ::com::sun::star::uno::UNO_QUERY );
 133     if( xUT.is() )
 134     {
 135         return
 136             reinterpret_cast<SvUnoAttributeContainer*>(
 137                 sal::static_int_cast<sal_IntPtr>(
 138                     xUT->getSomething( SvUnoAttributeContainer::getUnoTunnelId())));
 139     }
 140     else
 141         return NULL;
 142 }
 143
 144 sal_Int64 SAL_CALL SvUnoAttributeContainer::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw(::com::sun::star::uno::RuntimeException)
 145 {
 146     if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
 147                                                          rId.getConstArray(), 16 ) )
 148     {
 149         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
 150     }
 151     return 0;
 152 }
 153
 154 // container::XNameAccess
 155 uno::Any SAL_CALL SvUnoAttributeContainer::getByName(const OUString& aName)
 156     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
 157 {
 158     sal_uInt16 nAttr = getIndexByName(aName );
 159
 160     if( nAttr == USHRT_MAX )
 161         throw container::NoSuchElementException();
 162
 163     xml::AttributeData aData;
 164     aData.Namespace = mpContainer->GetAttrNamespace(nAttr);
 165     aData.Type = OUString::createFromAscii("CDATA");
 166     aData.Value = mpContainer->GetAttrValue(nAttr);
 167
 168     uno::Any aAny;
 169     aAny <<= aData;
 170     return aAny;
 171 }
 172
 173 uno::Sequence< OUString > SAL_CALL SvUnoAttributeContainer::getElementNames(void) throw( uno::RuntimeException )
 174 {
 175     const sal_uInt16 nAttrCount = mpContainer->GetAttrCount();
 176
 177     uno::Sequence< OUString > aElementNames( (sal_Int32)nAttrCount );
 178     OUString *pNames = aElementNames.getArray();
 179
 180     for( sal_uInt16 nAttr = 0; nAttr < nAttrCount; nAttr++ )
 181     {
 182         OUStringBuffer sBuffer( mpContainer->GetAttrPrefix(nAttr) );
 183         if( sBuffer.getLength() != 0L )
 184             sBuffer.append( (sal_Unicode)':' );
 185         sBuffer.append( mpContainer->GetAttrLName(nAttr) );
 186         *pNames++ = sBuffer.makeStringAndClear();
 187     }
 188
 189     return aElementNames;
 190 }
 191
 192 sal_Bool SAL_CALL SvUnoAttributeContainer::hasByName(const OUString& aName) throw( uno::RuntimeException )
 193 {
 194     return getIndexByName(aName ) != USHRT_MAX;
 195 }
 196
 197 // container::XNameReplace
 198 void SAL_CALL SvUnoAttributeContainer::replaceByName(const OUString& aName, const uno::Any& aElement)
 199     throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
 200 {
 201     if( aElement.hasValue() && aElement.getValueType() == ::getCppuType((const xml::AttributeData*)0) )
 202     {
 203         sal_uInt16 nAttr = getIndexByName(aName );
 204         if( nAttr == USHRT_MAX )
 205             throw container::NoSuchElementException();
 206
 207         xml::AttributeData* pData = (xml::AttributeData*)aElement.getValue();
 208
 209         sal_Int32 nPos = aName.indexOf( sal_Unicode(':') );
 210         if( nPos != -1L )
 211         {
 212             const OUString aPrefix( aName.copy( 0L, nPos ));
 213             const OUString aLName( aName.copy( nPos+1L ));
 214
 215             if( pData->Namespace.getLength() == 0L )
 216             {
 217                 if( mpContainer->SetAt( nAttr, aPrefix, aLName, pData->Value ) )
 218                     return;
 219             }
 220             else
 221             {
 222                 if( mpContainer->SetAt( nAttr, aPrefix, pData->Namespace, aLName, pData->Value ) )
 223                     return;
 224             }
 225         }
 226         else
 227         {
 228             if( pData->Namespace.getLength() == 0L )
 229             {
 230                 if( mpContainer->SetAt( nAttr, aName, pData->Value ) )
 231                     return;
 232             }
 233         }
 234     }
 235
 236     throw lang::IllegalArgumentException();
 237 }
 238
 239 // container::XNameContainer
 240 void SAL_CALL SvUnoAttributeContainer::insertByName(const OUString& aName, const uno::Any& aElement)
 241 throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException )
 242 {
 243     if( !aElement.hasValue() || aElement.getValueType() != ::getCppuType((const xml::AttributeData*)0) )
 244         throw lang::IllegalArgumentException();
 245
 246     sal_uInt16 nAttr = getIndexByName(aName );
 247     if( nAttr != USHRT_MAX )
 248         throw container::ElementExistException();
 249
 250     xml::AttributeData* pData = (xml::AttributeData*)aElement.getValue();
 251
 252     sal_Int32 nPos = aName.indexOf( sal_Unicode(':') );
 253     if( nPos != -1L )
 254     {
 255         const OUString aPrefix( aName.copy( 0L, nPos ));
 256         const OUString aLName( aName.copy( nPos+1L ));
 257
 258         if( pData->Namespace.getLength() == 0L )
 259         {
 260             if( mpContainer->AddAttr( aPrefix, aLName, pData->Value ) )
 261                 return;
 262         }
 263         else
 264         {
 265             if( mpContainer->AddAttr( aPrefix, pData->Namespace, aLName, pData->Value ) )
 266                 return;
 267         }
 268     }
 269     else
 270     {
 271         if( pData->Namespace.getLength() == 0L )
 272         {
 273             if( mpContainer->AddAttr( aName, pData->Value ) )
 274                 return;
 275         }
 276     }
 277 }
 278
 279 void SAL_CALL SvUnoAttributeContainer::removeByName(const OUString& Name)
 280     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
 281 {
 282     sal_uInt16 nAttr = getIndexByName(Name);
 283     if( nAttr == USHRT_MAX )
 284         throw container::NoSuchElementException();
 285
 286     mpContainer->Remove( nAttr );
 287 }
 288
 289 //XServiceInfo
 290 OUString SAL_CALL SvUnoAttributeContainer::getImplementationName(void) throw( uno::RuntimeException )
 291 {
 292     return OUString::createFromAscii( "SvUnoAttributeContainer" );
 293 }
 294
 295 uno::Sequence< OUString > SvUnoAttributeContainer::getSupportedServiceNames(void)
 296     throw( uno::RuntimeException )
 297 {
 298     OUString aSN( OUString::createFromAscii( "com.sun.star.xml.AttributeContainer" ) );
 299     uno::Sequence< OUString > aNS( &aSN, 1L );
 300     return aNS;
 301 }
 302
 303 sal_Bool SvUnoAttributeContainer::supportsService(const OUString& ServiceName)
 304     throw( uno::RuntimeException )
 305 {
 306     const uno::Sequence < OUString > aServiceNames( getSupportedServiceNames() );
 307     const OUString* pNames = aServiceNames.getConstArray();
 308     sal_Int32 nCount = aServiceNames.getLength();
 309     while( nCount-- )
 310     {
 311         if( *pNames++ == ServiceName )
 312             return sal_True;
 313     }
 314
 315     return sal_False;
 316 }
 317
 318