configmgr/source/xml/layerparser.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: layerparser.cxx,v $
  10  * $Revision: 1.15 $
  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_configmgr.hxx"
  33
  34 #include "com/sun/star/configuration/backend/NodeAttribute.hpp"
  35 #include "layerparser.hxx"
  36
  37 // -----------------------------------------------------------------------------
  38 #include "wrapexception.hxx"
  39
  40 #define WRAP_PARSE_EXCEPTIONS()  \
  41     PASS_EXCEPTION(sax::SAXException)       \
  42     PASS_EXCEPTION(uno::RuntimeException)   \
  43     WRAP_CONFIGDATA_EXCEPTIONS( raiseParseException )   \
  44     WRAP_OTHER_EXCEPTIONS( raiseParseException )
  45
  46 #define WRAP_PARSE_EXCEPTIONS_MSG( msg )  \
  47     PASS_EXCEPTION(sax::SAXException)       \
  48     PASS_EXCEPTION(uno::RuntimeException)   \
  49     WRAP_CONFIGDATA_EXCEPTIONS1( raiseParseException, msg ) \
  50     WRAP_OTHER_EXCEPTIONS1( raiseParseException, msg )
  51
  52 // -----------------------------------------------------------------------------
  53
  54 namespace configmgr
  55 {
  56 // -----------------------------------------------------------------------------
  57     namespace xml
  58     {
  59 // -----------------------------------------------------------------------------
  60         namespace uno           = ::com::sun::star::uno;
  61         namespace sax           = ::com::sun::star::xml::sax;
  62 // -----------------------------------------------------------------------------
  63
  64 LayerParser::LayerParser(uno::Reference< uno::XComponentContext > const & _xContext, uno::Reference< backenduno::XLayerHandler > const & _xHandler)
  65 : BasicParser(_xContext)
  66 , m_xHandler(_xHandler)
  67 , m_bRemoved(false)
  68 , m_bNewProp(false)
  69 {
  70     if (!m_xHandler.is())
  71     {
  72         rtl::OUString sMessage(RTL_CONSTASCII_USTRINGPARAM("Cannot create LayerParser: Unexpected NULL Handler"));
  73         throw uno::RuntimeException(sMessage, NULL);
  74     }
  75 }
  76 // -----------------------------------------------------------------------------
  77
  78 LayerParser::~LayerParser()
  79 {
  80 }
  81 // -----------------------------------------------------------------------------
  82
  83 void SAL_CALL LayerParser::startDocument(  )
  84         throw (sax::SAXException, uno::RuntimeException)
  85 {
  86     BasicParser::startDocument();
  87
  88     try
  89     {
  90         OSL_ENSURE(isEmptyNode(), "BasicParser does not mark new document as empty");
  91
  92         m_xHandler->startLayer();
  93         m_bRemoved = false;
  94         m_bNewProp = false;
  95     }
  96     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Starting layer")
  97 }
  98 // -----------------------------------------------------------------------------
  99
 100 void SAL_CALL LayerParser::endDocument(  ) throw (sax::SAXException, uno::RuntimeException)
 101 {
 102     if (isEmptyNode()) OSL_TRACE("Configuration Parser: XML layer document ended without any data");
 103
 104     BasicParser::endDocument();
 105
 106     try
 107     {
 108         m_xHandler->endLayer();
 109     }
 110     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Ending layer")
 111 }
 112 // -----------------------------------------------------------------------------
 113
 114 void SAL_CALL LayerParser::startElement( const rtl::OUString& aName, const uno::Reference< sax::XAttributeList >& xAttribs )
 115         throw (sax::SAXException, uno::RuntimeException)
 116 {
 117     if ( this->isSkipping() )
 118     {
 119         this->startSkipping( aName, xAttribs );
 120         return;
 121     }
 122
 123     ElementInfo aInfo = getDataParser().parseElementInfo(aName,xAttribs);
 124
 125     try
 126     {
 127         switch (aInfo.type)
 128         {
 129         case ElementType::group: case ElementType::set:
 130             OSL_ENSURE( false, "Layer XML parser - Unexpected: found group/set element (should be 'node')\n");
 131             // fall thru
 132         case ElementType::layer:
 133         case ElementType::node:
 134             this->startNode(aInfo,xAttribs);
 135             OSL_ASSERT( this->isInNode() && !this->isInProperty() );
 136             break;
 137
 138         case ElementType::property:
 139             this->startProperty(aInfo,xAttribs);
 140             OSL_ASSERT( this->isInUnhandledProperty() );
 141             break;
 142
 143         case ElementType::value:
 144             this->startValueData(xAttribs);
 145             OSL_ASSERT( this->isInValueData() );
 146             break;
 147
 148         default: // skip unknown elements
 149             OSL_ENSURE( aInfo.type >= ElementType::other, "Layer XML parser - Unexpected: found schema element in layer data\n");
 150             OSL_ENSURE( aInfo.type <  ElementType::other, "Layer XML parser - Warning: ignoring unknown element tag\n");
 151             this->startSkipping( aName, xAttribs );
 152             return;
 153         }
 154     }
 155     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Starting Element")
 156 }
 157 // -----------------------------------------------------------------------------
 158
 159 void SAL_CALL LayerParser::endElement( const rtl::OUString& aName )
 160         throw (sax::SAXException, uno::RuntimeException)
 161 {
 162     if ( this->wasSkipping(aName) )
 163         return;
 164
 165     try
 166     {
 167         if ( this->isInValueData())
 168             this->endValueData();
 169
 170         else if (this->isInProperty())
 171             this->endProperty();
 172
 173         else if (this->isInNode())
 174             this->endNode();
 175
 176         else {
 177             this->raiseParseException("Layer parser: Invalid XML: endElement without matching startElement");
 178         }
 179     }
 180     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Ending Element")
 181 }
 182 // -----------------------------------------------------------------------------
 183 // -----------------------------------------------------------------------------
 184
 185 void LayerParser::startNode( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 186 {
 187     this->checkNotRemoved();
 188
 189     BasicParser::startNode(aInfo,xAttribs);
 190
 191     switch (aInfo.op)
 192     {
 193     case Operation::none:
 194     case Operation::modify:
 195         m_xHandler->overrideNode(aInfo.name,aInfo.flags,false);
 196         break;
 197
 198     case Operation::clear:
 199         m_xHandler->overrideNode(aInfo.name,aInfo.flags,true);
 200         break;
 201
 202     case Operation::replace:
 203     case Operation::fuse:
 204         {
 205             backenduno::TemplateIdentifier aTemplate;
 206             sal_Int16 flags = aInfo.flags;
 207             if (aInfo.op == Operation::fuse) {
 208                 flags |=
 209                     com::sun::star::configuration::backend::NodeAttribute::FUSE;
 210             }
 211             if (getDataParser().getInstanceType(xAttribs,aTemplate.Name,aTemplate.Component))
 212                 m_xHandler->addOrReplaceNodeFromTemplate(aInfo.name,aTemplate,flags);
 213             else
 214                 m_xHandler->addOrReplaceNode(aInfo.name,flags);
 215         }
 216         break;
 217
 218     case Operation::remove:
 219         m_xHandler->dropNode(aInfo.name);
 220         m_bRemoved = true;
 221         break;
 222
 223     default: OSL_ASSERT(false);
 224     case Operation::unknown:
 225         this->raiseParseException("Layer parser: Invalid Data: unknown operation");
 226     }
 227 }
 228 // -----------------------------------------------------------------------------
 229
 230 void LayerParser::endNode()
 231 {
 232     if (!this->isInRemoved())
 233         m_xHandler->endNode();
 234     else
 235         m_bRemoved = false;
 236
 237     BasicParser::endNode();
 238 }
 239 // -----------------------------------------------------------------------------
 240
 241 void LayerParser::startProperty( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 242 {
 243     this->checkNotRemoved();
 244
 245     BasicParser::startProperty(aInfo,xAttribs);
 246
 247     switch (aInfo.op)
 248     {
 249     case Operation::none:
 250     case Operation::modify:
 251         m_xHandler->overrideProperty(aInfo.name,aInfo.flags,getActivePropertyType(),false);
 252         OSL_ASSERT(!m_bNewProp);
 253         break;
 254
 255     case Operation::clear:
 256         m_xHandler->overrideProperty(aInfo.name,aInfo.flags,getActivePropertyType(),true);
 257         OSL_ASSERT(!m_bNewProp);
 258         break;
 259
 260     case Operation::replace:
 261         // defer to later
 262         m_bNewProp = true;
 263         break;
 264
 265     case Operation::fuse:
 266         this->raiseParseException("Layer parser: Invalid Data: operation 'fuse' is not permitted for properties");
 267
 268     case Operation::remove:
 269         this->raiseParseException("Layer parser: Invalid Data: operation 'remove' is not permitted for properties");
 270
 271     default: OSL_ASSERT(false);
 272     case Operation::unknown:
 273         this->raiseParseException("Layer parser: Invalid Data: unknown operation");
 274     }
 275     OSL_POSTCOND(this->isInUnhandledProperty(),"Error: Property not reckognized as unhandled");
 276 }
 277 // -----------------------------------------------------------------------------
 278
 279 void LayerParser::addOrReplaceCurrentProperty(const uno::Any& aValue)
 280 {
 281     const ElementInfo& currentInfo = getActiveNodeInfo() ;
 282
 283     OSL_ASSERT(currentInfo.op == Operation::replace) ;
 284
 285     if (aValue.hasValue())
 286     {
 287         m_xHandler->addPropertyWithValue(currentInfo.name,
 288                                          currentInfo.flags, aValue) ;
 289     }
 290     else
 291     {
 292         m_xHandler->addProperty(currentInfo.name, currentInfo.flags,
 293                                 getActivePropertyType()) ;
 294     }
 295 }
 296 // -----------------------------------------------------------------------------
 297
 298 void LayerParser::endProperty()
 299 {
 300     OSL_ASSERT(!this->isInRemoved());
 301
 302     if (m_bNewProp)
 303     {
 304         OSL_ASSERT(getActiveNodeInfo().op == Operation::replace);
 305         if (this->isInUnhandledProperty())
 306         {
 307             // No value tag is treated as NULL
 308             addOrReplaceCurrentProperty( uno::Any() ) ;
 309         }
 310         m_bNewProp = false;
 311     }
 312     else
 313     {
 314         OSL_ASSERT(getActiveNodeInfo().op != Operation::replace);
 315         m_xHandler->endProperty();
 316     }
 317
 318     BasicParser::endProperty();
 319 }
 320 // -----------------------------------------------------------------------------
 321
 322 void LayerParser::startValueData(const uno::Reference< sax::XAttributeList >& xAttribs)
 323 {
 324     this->checkNotRemoved();
 325
 326     BasicParser::startValueData(xAttribs);
 327 }
 328 // -----------------------------------------------------------------------------
 329
 330 void LayerParser::endValueData()
 331 {
 332     uno::Any aValue = this->getCurrentValue();
 333
 334     if (m_bNewProp)
 335     {
 336         if (this->isValueDataLocalized())
 337             getLogger().warning("Language attribute ignored for value of added property.",
 338                                 "endValueData()","configuration::xml::SchemaParser");
 339
 340         addOrReplaceCurrentProperty(aValue) ;
 341     }
 342     else if (this->isValueDataLocalized())
 343     {
 344         rtl::OUString aLocale = this->getValueDataLocale();
 345
 346         m_xHandler->setPropertyValueForLocale(aValue,aLocale);
 347     }
 348     else
 349     {
 350         m_xHandler->setPropertyValue(aValue);
 351     }
 352
 353     BasicParser::endValueData();
 354
 355     OSL_POSTCOND(!this->isInUnhandledProperty(),"Error: Property not reckognized as unhandled");
 356 }
 357 // -----------------------------------------------------------------------------
 358
 359 void LayerParser::checkNotRemoved()
 360 {
 361     if (m_bRemoved)
 362         raiseParseException("Layer parser: Invalid Data: Data inside removed node.");
 363 }
 364 // -----------------------------------------------------------------------------
 365
 366 // -----------------------------------------------------------------------------
 367     } // namespace
 368
 369 // -----------------------------------------------------------------------------
 370 } // namespace
 371