svx/source/unodraw/UnoNamespaceMap.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
  21 #include <climits>
  22 #include <set>
  23
  24 #include <svx/UnoNamespaceMap.hxx>
  25 #include <com/sun/star/container/XNameAccess.hpp>
  26 #include <com/sun/star/lang/XServiceInfo.hpp>
  27
  28 #include <comphelper/sequence.hxx>
  29 #include <cppuhelper/implbase.hxx>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <svl/itempool.hxx>
  32 #include <editeng/xmlcnitm.hxx>
  33
  34 using namespace ::cppu;
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::uno;
  37 using namespace ::com::sun::star::container;
  38 using namespace ::com::sun::star::lang;
  39
  40 namespace svx
  41 {
  42     namespace {
  43
  44     /** implements a component to export namespaces of all SvXMLAttrContainerItem inside
  45         one or two pools with a variable count of which ids.
  46     */
  47     class NamespaceMap : public WeakImplHelper< XNameAccess, XServiceInfo >
  48     {
  49     private:
  50         sal_uInt16* mpWhichIds;
  51         SfxItemPool* mpPool;
  52
  53     public:
  54         NamespaceMap( sal_uInt16* pWhichIds, SfxItemPool* pPool );
  55
  56         // XNameAccess
  57         virtual Any SAL_CALL getByName( const OUString& aName ) override;
  58         virtual Sequence< OUString > SAL_CALL getElementNames(  ) override;
  59         virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
  60
  61         // XElementAccess
  62         virtual Type SAL_CALL getElementType(  ) override;
  63         virtual sal_Bool SAL_CALL hasElements(  ) override;
  64
  65         // XServiceInfo
  66         virtual OUString SAL_CALL getImplementationName(  ) override;
  67         virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  68         virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
  69     };
  70
  71     }
  72
  73     Reference< XInterface > NamespaceMap_createInstance( sal_uInt16* pWhichIds, SfxItemPool* pPool )
  74     {
  75         return getXWeak(new NamespaceMap( pWhichIds, pPool ));
  76     }
  77
  78     static Sequence< OUString > NamespaceMap_getSupportedServiceNames()
  79         noexcept
  80     {
  81         Sequence<OUString> aSupportedServiceNames { u"com.sun.star.xml.NamespaceMap"_ustr };
  82         return aSupportedServiceNames;
  83     }
  84
  85     static OUString NamespaceMap_getImplementationName()
  86         noexcept
  87     {
  88         return u"com.sun.star.comp.Svx.NamespaceMap"_ustr;
  89     }
  90
  91     namespace {
  92
  93     class NamespaceIteratorImpl
  94     {
  95     private:
  96         SfxItemPool* mpPool;
  97
  98         sal_uInt16* mpWhichId;
  99
 100         std::vector<const SvXMLAttrContainerItem*> mvItems;
 101         sal_Int32 mnItem;
 102
 103         const SvXMLAttrContainerItem* mpCurrentAttr;
 104         sal_uInt16 mnCurrentAttr;
 105
 106     public:
 107
 108         NamespaceIteratorImpl( sal_uInt16* pWhichIds, SfxItemPool* pPool );
 109
 110         bool next( OUString& rPrefix, OUString& rURL );
 111     };
 112
 113     }
 114 }
 115
 116 using namespace ::svx;
 117
 118
 119 NamespaceIteratorImpl::NamespaceIteratorImpl( sal_uInt16* pWhichIds, SfxItemPool* pPool )
 120 {
 121     mpPool = pPool;
 122     mpCurrentAttr = nullptr;
 123     mnCurrentAttr = 0;
 124
 125     mpWhichId = pWhichIds;
 126
 127     mnItem = -1;
 128     if (mpWhichId && (0 != *mpWhichId) && mpPool)
 129     {
 130         ItemSurrogates aSurrogates;
 131         mpPool->GetItemSurrogates(aSurrogates, *mpWhichId);
 132         mvItems.reserve(aSurrogates.size());
 133         for (const SfxPoolItem* pItem : aSurrogates)
 134             mvItems.push_back(static_cast<const SvXMLAttrContainerItem*>(pItem));
 135     }
 136 }
 137
 138 bool NamespaceIteratorImpl::next( OUString& rPrefix, OUString& rURL )
 139 {
 140     // we still need to process the current attribute
 141     if( mpCurrentAttr && (mnCurrentAttr != USHRT_MAX) )
 142     {
 143         rPrefix = mpCurrentAttr->GetPrefix( mnCurrentAttr );
 144         rURL = mpCurrentAttr->GetNamespace( mnCurrentAttr );
 145
 146         mnCurrentAttr = mpCurrentAttr->GetNextNamespaceIndex( mnCurrentAttr );
 147         return true;
 148     }
 149
 150     // we need the next namespace item
 151     mpCurrentAttr = nullptr;
 152     mnItem++;
 153
 154     // are we finished with the current whichid?
 155     if( mnItem == static_cast<sal_Int32>(mvItems.size()) )
 156     {
 157         mpWhichId++;
 158
 159         // are we finished with the current pool?
 160         if( 0 == *mpWhichId )
 161             return false;
 162
 163         mnItem = -1;
 164         mvItems.clear();
 165         if (mpPool)
 166         {
 167             ItemSurrogates aSurrogates;
 168             mpPool->GetItemSurrogates(aSurrogates, *mpWhichId);
 169             mvItems.reserve(aSurrogates.size());
 170             for (const SfxPoolItem* pItem2 : aSurrogates)
 171                 mvItems.push_back(static_cast<const SvXMLAttrContainerItem*>(pItem2));
 172         }
 173         return next( rPrefix, rURL );
 174     }
 175
 176     auto pItem = mvItems[mnItem];
 177     // get that item and see if there namespaces inside
 178     if( pItem->GetAttrCount() > 0 )
 179     {
 180         mpCurrentAttr = pItem;
 181         mnCurrentAttr = pItem->GetFirstNamespaceIndex();
 182     }
 183     return next( rPrefix, rURL );
 184 }
 185
 186
 187 NamespaceMap::NamespaceMap( sal_uInt16* pWhichIds, SfxItemPool* pPool )
 188 : mpWhichIds( pWhichIds ), mpPool( pPool )
 189 {
 190 }
 191
 192 // XNameAccess
 193 Any SAL_CALL NamespaceMap::getByName( const OUString& aName )
 194 {
 195     NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
 196
 197     OUString aPrefix;
 198     OUString aURL;
 199
 200     bool bFound;
 201
 202     do
 203     {
 204         bFound = aIter.next( aPrefix, aURL );
 205     }
 206     while( bFound && (aPrefix != aName ) );
 207
 208     if( !bFound )
 209         throw NoSuchElementException();
 210
 211     return Any( aURL );
 212 }
 213
 214 Sequence< OUString > SAL_CALL NamespaceMap::getElementNames()
 215 {
 216     NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
 217
 218     OUString aPrefix;
 219     OUString aURL;
 220
 221     std::set< OUString > aPrefixSet;
 222
 223     while( aIter.next( aPrefix, aURL ) )
 224         aPrefixSet.insert( aPrefix );
 225
 226     return comphelper::containerToSequence(aPrefixSet);
 227 }
 228
 229 sal_Bool SAL_CALL NamespaceMap::hasByName( const OUString& aName )
 230 {
 231     NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
 232
 233     OUString aPrefix;
 234     OUString aURL;
 235
 236     bool bFound;
 237
 238     do
 239     {
 240         bFound = aIter.next( aPrefix, aURL );
 241     }
 242     while( bFound && (aPrefix != aName ) );
 243
 244     return bFound;
 245 }
 246
 247 // XElementAccess
 248 Type SAL_CALL NamespaceMap::getElementType()
 249 {
 250     return ::cppu::UnoType<OUString>::get();
 251 }
 252
 253 sal_Bool SAL_CALL NamespaceMap::hasElements()
 254 {
 255     NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
 256
 257     OUString aPrefix;
 258     OUString aURL;
 259
 260     return aIter.next( aPrefix, aURL );
 261 }
 262
 263 // XServiceInfo
 264 OUString SAL_CALL NamespaceMap::getImplementationName(  )
 265 {
 266     return NamespaceMap_getImplementationName();
 267 }
 268
 269 sal_Bool SAL_CALL NamespaceMap::supportsService( const OUString& serviceName )
 270 {
 271     return cppu::supportsService( this, serviceName );
 272 }
 273
 274 Sequence< OUString > SAL_CALL NamespaceMap::getSupportedServiceNames(  )
 275 {
 276     return NamespaceMap_getSupportedServiceNames();
 277 }
 278
 279 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */