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()
  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)
  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     {
  96         ::osl::MutexGuard const g(m_rMutex);
  97
  98         Reference< XNode > aNode;
  99         xmlNodePtr pNode = m_pElement->GetNodePtr();
 100         if (pNode != nullptr)
 101         {
 102             OString o1 = OUStringToOString(localName, RTL_TEXTENCODING_UTF8);
 103             xmlChar const * pName = reinterpret_cast<xmlChar const *>(o1.getStr());
 104             OString o2 = OUStringToOString(namespaceURI, RTL_TEXTENCODING_UTF8);
 105             xmlChar const* pSearchNs =
 106                 reinterpret_cast<xmlChar const*>(o2.getStr());
 107             xmlNsPtr const pNs = xmlSearchNsByHref(pNode->doc, pNode, pSearchNs);
 108             xmlAttrPtr cur = pNode->properties;
 109             while (cur != nullptr && pNs != nullptr)
 110             {
 111                 if( strcmp(reinterpret_cast<char const *>(pName), reinterpret_cast<char const *>(cur->name)) == 0 &&
 112                     cur->ns == pNs)
 113                 {
 114                     aNode.set( m_pElement->GetOwnerDocument().GetCNode(
 115                                   reinterpret_cast<xmlNodePtr>(cur)).get() );
 116                     break;
 117                 }
 118                 cur = cur->next;
 119             }
 120         }
 121         return aNode;
 122     }
 123
 124     /**
 125     Returns the indexth item in the map.
 126     */
 127     Reference< XNode > SAL_CALL
 128     CAttributesMap::item(sal_Int32 index)
 129     {
 130         ::osl::MutexGuard const g(m_rMutex);
 131
 132         Reference< XNode > aNode;
 133         xmlNodePtr pNode = m_pElement->GetNodePtr();
 134         if (pNode != nullptr)
 135         {
 136             xmlAttrPtr cur = pNode->properties;
 137             sal_Int32 count = 0;
 138             while (cur != nullptr)
 139             {
 140                 if (count == index)
 141                 {
 142                     aNode.set( m_pElement->GetOwnerDocument().GetCNode(
 143                                 reinterpret_cast<xmlNodePtr>(cur)).get() );
 144                     break;
 145                 }
 146                 count++;
 147                 cur = cur->next;
 148             }
 149         }
 150         return aNode;
 151     }
 152
 153     /**
 154     Removes a node specified by name.
 155     */
 156     Reference< XNode > SAL_CALL
 157     CAttributesMap::removeNamedItem(OUString const& name)
 158     {
 159         // no MutexGuard needed: m_pElement is const
 160         Reference< XAttr > const xAttr(m_pElement->getAttributeNode(name));
 161         if (!xAttr.is()) {
 162             throw DOMException(
 163                 "CAttributesMap::removeNamedItem: no such attribute",
 164                 static_cast<OWeakObject*>(this),
 165                 DOMExceptionType_NOT_FOUND_ERR);
 166         }
 167         Reference< XNode > const xRet(
 168             m_pElement->removeAttributeNode(xAttr), UNO_QUERY);
 169         return xRet;
 170     }
 171
 172     /**
 173     // Removes a node specified by local name and namespace URI.
 174     */
 175     Reference< XNode > SAL_CALL
 176     CAttributesMap::removeNamedItemNS(
 177             OUString const& namespaceURI, OUString const& localName)
 178     {
 179         // no MutexGuard needed: m_pElement is const
 180         Reference< XAttr > const xAttr(
 181             m_pElement->getAttributeNodeNS(namespaceURI, localName));
 182         if (!xAttr.is()) {
 183             throw DOMException(
 184                 "CAttributesMap::removeNamedItemNS: no such attribute",
 185                 static_cast<OWeakObject*>(this),
 186                 DOMExceptionType_NOT_FOUND_ERR);
 187         }
 188         Reference< XNode > const xRet(
 189             m_pElement->removeAttributeNode(xAttr), UNO_QUERY);
 190         return xRet;
 191     }
 192
 193     /**
 194     // Adds a node using its nodeName attribute.
 195     */
 196     Reference< XNode > SAL_CALL
 197     CAttributesMap::setNamedItem(Reference< XNode > const& xNode)
 198     {
 199         Reference< XAttr > const xAttr(xNode, UNO_QUERY);
 200         if (!xNode.is()) {
 201             throw DOMException(
 202                 "CAttributesMap::setNamedItem: XAttr argument expected",
 203                 static_cast<OWeakObject*>(this),
 204                 DOMExceptionType_HIERARCHY_REQUEST_ERR);
 205         }
 206         // no MutexGuard needed: m_pElement is const
 207         Reference< XNode > const xRet(
 208             m_pElement->setAttributeNode(xAttr), UNO_QUERY);
 209         return xRet;
 210     }
 211
 212     /**
 213     Adds a node using its namespaceURI and localName.
 214     */
 215     Reference< XNode > SAL_CALL
 216     CAttributesMap::setNamedItemNS(Reference< XNode > const& xNode)
 217     {
 218         Reference< XAttr > const xAttr(xNode, UNO_QUERY);
 219         if (!xNode.is()) {
 220             throw DOMException(
 221                 "CAttributesMap::setNamedItemNS: XAttr argument expected",
 222                 static_cast<OWeakObject*>(this),
 223                 DOMExceptionType_HIERARCHY_REQUEST_ERR);
 224         }
 225         // no MutexGuard needed: m_pElement is const
 226         Reference< XNode > const xRet(
 227             m_pElement->setAttributeNodeNS(xAttr), UNO_QUERY);
 228         return xRet;
 229     }
 230 }
 231
 232 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */