unoxml/source/dom/attributesmap.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 <attributesmap.hxx>
  21
  22 #include <string.h>
  23
  24 #include <element.hxx>
  25 #include <document.hxx>
  26
  27 using namespace css::uno;
  28 using namespace css::xml::dom;
  29
  30 namespace DOM
  31 {
  32     CAttributesMap::CAttributesMap(::rtl::Reference<CElement> const& pElement,
  33                 ::osl::Mutex & rMutex)
  34         : m_pElement(pElement)
  35         , m_rMutex(rMutex)
  36     {
  37     }
  38
  39     /**
  40     The number of nodes in this map.
  41     */
  42     sal_Int32 SAL_CALL CAttributesMap::getLength() throw (RuntimeException, std::exception)
  43     {
  44         ::osl::MutexGuard const g(m_rMutex);
  45
  46         sal_Int32 count = 0;
  47         xmlNodePtr pNode = m_pElement->GetNodePtr();
  48         if (pNode != nullptr)
  49         {
  50             xmlAttrPtr cur = pNode->properties;
  51             while (cur != nullptr)
  52             {
  53                 count++;
  54                 cur = cur->next;
  55             }
  56         }
  57         return count;
  58     }
  59
  60     /**
  61     Retrieves a node specified by local name
  62     */
  63     Reference< XNode > SAL_CALL
  64     CAttributesMap::getNamedItem(OUString const& name) throw (RuntimeException, std::exception)
  65     {
  66         ::osl::MutexGuard const g(m_rMutex);
  67
  68         Reference< XNode > aNode;
  69         xmlNodePtr pNode = m_pElement->GetNodePtr();
  70         if (pNode != nullptr)
  71         {
  72             OString o1 = OUStringToOString(name, RTL_TEXTENCODING_UTF8);
  73             xmlChar const * pName = reinterpret_cast<xmlChar const *>(o1.getStr());
  74             xmlAttrPtr cur = pNode->properties;
  75             while (cur != nullptr)
  76             {
  77                 if( strcmp(reinterpret_cast<char const *>(pName), reinterpret_cast<char const *>(cur->name)) == 0)
  78                 {
  79                     aNode.set( m_pElement->GetOwnerDocument().GetCNode(
  80                                    reinterpret_cast<xmlNodePtr>(cur)).get() );
  81                     break;
  82                 }
  83                 cur = cur->next;
  84             }
  85         }
  86         return aNode;
  87     }
  88
  89     /**
  90     Retrieves a node specified by local name and namespace URI.
  91     */
  92     Reference< XNode > SAL_CALL
  93     CAttributesMap::getNamedItemNS(
  94             OUString const& namespaceURI, OUString const& localName)
  95     throw (RuntimeException, std::exception)
  96     {
  97         ::osl::MutexGuard const g(m_rMutex);
  98
  99         Reference< XNode > aNode;
 100         xmlNodePtr pNode = m_pElement->GetNodePtr();
 101         if (pNode != nullptr)
 102         {
 103             OString o1 = OUStringToOString(localName, RTL_TEXTENCODING_UTF8);
 104             xmlChar const * pName = reinterpret_cast<xmlChar const *>(o1.getStr());
 105             OString o2 = OUStringToOString(namespaceURI, RTL_TEXTENCODING_UTF8);
 106             xmlChar const* pSearchNs =
 107                 reinterpret_cast<xmlChar const*>(o2.getStr());
 108             xmlNsPtr const pNs = xmlSearchNsByHref(pNode->doc, pNode, pSearchNs);
 109             xmlAttrPtr cur = pNode->properties;
 110             while (cur != nullptr && pNs != nullptr)
 111             {
 112                 if( strcmp(reinterpret_cast<char const *>(pName), reinterpret_cast<char const *>(cur->name)) == 0 &&
 113                     cur->ns == pNs)
 114                 {
 115                     aNode.set( m_pElement->GetOwnerDocument().GetCNode(
 116                                   reinterpret_cast<xmlNodePtr>(cur)).get() );
 117                     break;
 118                 }
 119                 cur = cur->next;
 120             }
 121         }
 122         return aNode;
 123     }
 124
 125     /**
 126     Returns the indexth item in the map.
 127     */
 128     Reference< XNode > SAL_CALL
 129     CAttributesMap::item(sal_Int32 index) throw (RuntimeException, std::exception)
 130     {
 131         ::osl::MutexGuard const g(m_rMutex);
 132
 133         Reference< XNode > aNode;
 134         xmlNodePtr pNode = m_pElement->GetNodePtr();
 135         if (pNode != nullptr)
 136         {
 137             xmlAttrPtr cur = pNode->properties;
 138             sal_Int32 count = 0;
 139             while (cur != nullptr)
 140             {
 141                 if (count == index)
 142                 {
 143                     aNode.set( m_pElement->GetOwnerDocument().GetCNode(
 144                                 reinterpret_cast<xmlNodePtr>(cur)).get() );
 145                     break;
 146                 }
 147                 count++;
 148                 cur = cur->next;
 149             }
 150         }
 151         return aNode;
 152     }
 153
 154     /**
 155     Removes a node specified by name.
 156     */
 157     Reference< XNode > SAL_CALL
 158     CAttributesMap::removeNamedItem(OUString const& name)
 159     throw (DOMException, RuntimeException, std::exception)
 160     {
 161         // no MutexGuard needed: m_pElement is const
 162         Reference< XAttr > const xAttr(m_pElement->getAttributeNode(name));
 163         if (!xAttr.is()) {
 164             throw DOMException(
 165                 "CAttributesMap::removeNamedItem: no such attribute",
 166                 static_cast<OWeakObject*>(this),
 167                 DOMExceptionType_NOT_FOUND_ERR);
 168         }
 169         Reference< XNode > const xRet(
 170             m_pElement->removeAttributeNode(xAttr), UNO_QUERY);
 171         return xRet;
 172     }
 173
 174     /**
 175     // Removes a node specified by local name and namespace URI.
 176     */
 177     Reference< XNode > SAL_CALL
 178     CAttributesMap::removeNamedItemNS(
 179             OUString const& namespaceURI, OUString const& localName)
 180     throw (DOMException, RuntimeException, std::exception)
 181     {
 182         // no MutexGuard needed: m_pElement is const
 183         Reference< XAttr > const xAttr(
 184             m_pElement->getAttributeNodeNS(namespaceURI, localName));
 185         if (!xAttr.is()) {
 186             throw DOMException(
 187                 "CAttributesMap::removeNamedItemNS: no such attribute",
 188                 static_cast<OWeakObject*>(this),
 189                 DOMExceptionType_NOT_FOUND_ERR);
 190         }
 191         Reference< XNode > const xRet(
 192             m_pElement->removeAttributeNode(xAttr), UNO_QUERY);
 193         return xRet;
 194     }
 195
 196     /**
 197     // Adds a node using its nodeName attribute.
 198     */
 199     Reference< XNode > SAL_CALL
 200     CAttributesMap::setNamedItem(Reference< XNode > const& xNode)
 201     throw (DOMException, RuntimeException, std::exception)
 202     {
 203         Reference< XAttr > const xAttr(xNode, UNO_QUERY);
 204         if (!xNode.is()) {
 205             throw DOMException(
 206                 "CAttributesMap::setNamedItem: XAttr argument expected",
 207                 static_cast<OWeakObject*>(this),
 208                 DOMExceptionType_HIERARCHY_REQUEST_ERR);
 209         }
 210         // no MutexGuard needed: m_pElement is const
 211         Reference< XNode > const xRet(
 212             m_pElement->setAttributeNode(xAttr), UNO_QUERY);
 213         return xRet;
 214     }
 215
 216     /**
 217     Adds a node using its namespaceURI and localName.
 218     */
 219     Reference< XNode > SAL_CALL
 220     CAttributesMap::setNamedItemNS(Reference< XNode > const& xNode)
 221     throw (DOMException, RuntimeException, std::exception)
 222     {
 223         Reference< XAttr > const xAttr(xNode, UNO_QUERY);
 224         if (!xNode.is()) {
 225             throw DOMException(
 226                 "CAttributesMap::setNamedItemNS: XAttr argument expected",
 227                 static_cast<OWeakObject*>(this),
 228                 DOMExceptionType_HIERARCHY_REQUEST_ERR);
 229         }
 230         // no MutexGuard needed: m_pElement is const
 231         Reference< XNode > const xRet(
 232             m_pElement->setAttributeNodeNS(xAttr), UNO_QUERY);
 233         return xRet;
 234     }
 235 }
 236
 237 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */