configmgr/source/xml/schemaparser.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: schemaparser.cxx,v $
  10  * $Revision: 1.13 $
  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 "schemaparser.hxx"
  35
  36 // -----------------------------------------------------------------------------
  37 #include "wrapexception.hxx"
  38
  39 #define WRAP_PARSE_EXCEPTIONS()  \
  40     PASS_EXCEPTION(sax::SAXException)       \
  41     PASS_EXCEPTION(uno::RuntimeException)   \
  42     WRAP_CONFIGDATA_EXCEPTIONS( raiseParseException )   \
  43     WRAP_OTHER_EXCEPTIONS( raiseParseException )
  44
  45 #define WRAP_PARSE_EXCEPTIONS_MSG( msg )  \
  46     PASS_EXCEPTION(sax::SAXException)       \
  47     PASS_EXCEPTION(uno::RuntimeException)   \
  48     WRAP_CONFIGDATA_EXCEPTIONS1( raiseParseException, msg ) \
  49     WRAP_OTHER_EXCEPTIONS1( raiseParseException, msg )
  50
  51 // -----------------------------------------------------------------------------
  52
  53 namespace configmgr
  54 {
  55 // -----------------------------------------------------------------------------
  56     namespace xml
  57     {
  58 // -----------------------------------------------------------------------------
  59         namespace uno           = ::com::sun::star::uno;
  60         namespace sax           = ::com::sun::star::xml::sax;
  61 // -----------------------------------------------------------------------------
  62
  63 SchemaParser::SchemaParser(uno::Reference< uno::XComponentContext > const & _xContext, uno::Reference< backenduno::XSchemaHandler > const & _xHandler, Select _selector)
  64 : BasicParser(_xContext)
  65 , m_xHandler(_xHandler)
  66 , m_sComponent()
  67 , m_selector(_selector)
  68 , m_selected(selectNone)
  69 {
  70     if (!m_xHandler.is())
  71     {
  72         rtl::OUString sMessage(RTL_CONSTASCII_USTRINGPARAM("Cannot create SchemaParser: Unexpected NULL Handler"));
  73         throw uno::RuntimeException(sMessage, *this);
  74     }
  75     OSL_ENSURE(m_selector != selectNone, "Warning: Schema handler will handle no part of the schema");
  76 }
  77 // -----------------------------------------------------------------------------
  78
  79 SchemaParser::~SchemaParser()
  80 {
  81 }
  82 // -----------------------------------------------------------------------------
  83
  84 void SAL_CALL SchemaParser::startDocument(  )
  85         throw (sax::SAXException, uno::RuntimeException)
  86 {
  87     BasicParser::startDocument();
  88
  89     OSL_ENSURE(isEmptyNode(), "BasicParser does not mark new document as empty");
  90
  91     m_sComponent = rtl::OUString();
  92     m_selected = selectNone;
  93 }
  94 // -----------------------------------------------------------------------------
  95
  96 void SAL_CALL SchemaParser::endDocument(  ) throw (sax::SAXException, uno::RuntimeException)
  97 {
  98     if (isSelected())
  99         raiseParseException("Schema XML Parser: Invalid XML: Document ends while section is open");
 100
 101     if (isEmptyNode()) OSL_TRACE("Configuration Parser: XML schema document ended without any data");
 102
 103     BasicParser::endDocument();
 104 }
 105 // -----------------------------------------------------------------------------
 106
 107 void SAL_CALL SchemaParser::startElement( const rtl::OUString& aName, const uno::Reference< sax::XAttributeList >& xAttribs )
 108         throw (sax::SAXException, uno::RuntimeException)
 109 {
 110     if ( this->isSkipping() )
 111     {
 112         this->startSkipping( aName, xAttribs );
 113         return;
 114     }
 115
 116     ElementInfo aInfo = getDataParser().parseElementInfo(aName,xAttribs);
 117
 118     try
 119     {
 120         switch (aInfo.type)
 121         {
 122         case ElementType::schema:
 123             this->startSchema(aInfo,xAttribs);
 124             break;
 125
 126         case ElementType::component:
 127             this->startSection(selectComponent, aInfo, xAttribs);
 128             break;
 129
 130         case ElementType::templates:
 131             this->startSection(selectTemplates, aInfo, xAttribs);
 132             break;
 133
 134         case ElementType::import:
 135             this->handleImport(aInfo,xAttribs);
 136             this->startSkipping( aName, xAttribs );
 137             break;
 138
 139         case ElementType::uses:
 140             this->startSkipping( aName, xAttribs );
 141             break;
 142
 143         case ElementType::instance:
 144             this->handleInstance(aInfo,xAttribs);
 145             this->startSkipping( aName, xAttribs );
 146             break;
 147
 148         case ElementType::item_type:
 149             this->handleItemType(aInfo,xAttribs);
 150             this->startSkipping( aName, xAttribs );
 151             break;
 152
 153         case ElementType::layer:
 154         case ElementType::node:
 155             raiseParseException( "Schema XML parser - Invalid data: found unspecified 'node' element.\n");
 156             // fall thru
 157         case ElementType::group: case ElementType::set:
 158             this->startNode(aInfo,xAttribs);
 159             OSL_ASSERT( this->isInNode()  );
 160             break;
 161
 162         case ElementType::property:
 163             this->startProperty(aInfo,xAttribs);
 164             OSL_ASSERT( this->isInUnhandledProperty() );
 165             break;
 166
 167         case ElementType::value:
 168             this->startValueData(xAttribs);
 169             OSL_ASSERT( this->isInValueData() );
 170             break;
 171
 172         default: // skip unknown elements
 173             OSL_ENSURE( aInfo.type <= ElementType::other, "Schema XML parser - Error: invalid element type value\n");
 174             OSL_ENSURE( aInfo.type >= ElementType::other, "Schema XML parser - Unexpected: found layer element in schema data\n");
 175         // accept (and skip) unknown (ElementType::other) tags in schema to allow documentation and constraints to pass without assertion
 176           //OSL_ENSURE( aInfo.type <  ElementType::other, "Schema XML parser - Warning: ignoring unknown element tag\n");
 177
 178             this->startSkipping( aName, xAttribs );
 179             OSL_ASSERT( this->isSkipping() );
 180             return;
 181         }
 182     }
 183     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Starting Element")
 184
 185     OSL_ENSURE(aInfo.op == Operation::none || this->isSkipping(),
 186                 "Schema Parser: The 'op' attribute is not supported in a schema");
 187 }
 188 // -----------------------------------------------------------------------------
 189
 190 void SAL_CALL SchemaParser::endElement( const rtl::OUString& aName )
 191         throw (sax::SAXException, uno::RuntimeException)
 192 {
 193     if ( this->wasSkipping(aName) )
 194         return;
 195
 196     try
 197     {
 198         if ( this->isInValueData())
 199             this->endValueData();
 200
 201         else if (this->isInProperty())
 202             this->endProperty();
 203
 204         else if (this->isInNode())
 205             this->endNode();
 206
 207         else if (this->isSelected())
 208             this->endSection();
 209
 210         else
 211             this->endSchema();
 212     }
 213     WRAP_PARSE_EXCEPTIONS_MSG("LayerParser - Ending Element")
 214 }
 215 // -----------------------------------------------------------------------------
 216 // -----------------------------------------------------------------------------
 217
 218 void SchemaParser::startSchema( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& /*xAttribs*/ )
 219 {
 220     m_sComponent = aInfo.name;
 221     m_xHandler->startSchema();
 222 }
 223 // -----------------------------------------------------------------------------
 224
 225 void SchemaParser::endSchema( )
 226 {
 227     m_xHandler->endSchema();
 228     m_sComponent = rtl::OUString();
 229 }
 230 // -----------------------------------------------------------------------------
 231
 232 bool SchemaParser::select(Select _select)
 233 {
 234     if (isSelected())
 235         raiseParseException("Schema XML parser - Invalid data: found start of section while a section is still open.\n");
 236
 237     m_selected = static_cast<Select>(m_selector & _select);
 238
 239     return m_selected != 0;
 240 }
 241 // -----------------------------------------------------------------------------
 242
 243 void SchemaParser::startSection( Select _select, ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 244 {
 245     if (this->select(_select))
 246     {
 247         if (_select == selectComponent)
 248         {
 249             m_xHandler->startComponent(m_sComponent);
 250         }
 251     }
 252     else
 253         startSkipping(aInfo.name,xAttribs);
 254 }
 255 // -----------------------------------------------------------------------------
 256
 257 void SchemaParser::endSection( )
 258 {
 259     if (m_selected == selectComponent)
 260     {
 261         m_xHandler->endComponent();
 262     }
 263     m_selected = selectNone;
 264 }
 265 // -----------------------------------------------------------------------------
 266
 267 void SchemaParser::handleImport( ElementInfo const & /*aInfo*/, const uno::Reference< sax::XAttributeList >& xAttribs )
 268 {
 269     rtl::OUString aComponent;
 270     if (getDataParser().getImportComponent(xAttribs,aComponent))
 271         m_xHandler->importComponent(aComponent);
 272
 273     else
 274         raiseParseException("Schema XML parser - Invalid data: Missing component attribute for import directive.\n");
 275 }
 276 // -----------------------------------------------------------------------------
 277
 278 void SchemaParser::handleInstance( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 279 {
 280     backenduno::TemplateIdentifier aTemplate;
 281     if (getDataParser().getInstanceType(xAttribs, aTemplate.Name, aTemplate.Component))
 282         m_xHandler->addInstance(aInfo.name, aTemplate);
 283
 284     else
 285         raiseParseException("Schema XML parser - Invalid data: Missing type information for instantiation directive.\n");
 286 }
 287 // -----------------------------------------------------------------------------
 288
 289 void SchemaParser::handleItemType( ElementInfo const & /*aInfo*/, const uno::Reference< sax::XAttributeList >& xAttribs )
 290 {
 291     backenduno::TemplateIdentifier aTemplate;
 292     if (getDataParser().getInstanceType(xAttribs, aTemplate.Name, aTemplate.Component))
 293         m_xHandler->addItemType(aTemplate);
 294
 295     else
 296         raiseParseException("Schema XML parser - Invalid data: Missing type information for instantiation directive.\n");
 297 }
 298 // -----------------------------------------------------------------------------
 299
 300 void SchemaParser::startNode( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 301 {
 302     bool bStartTemplate = ( !isInNode() && m_selected == selectTemplates );
 303
 304     BasicParser::startNode(aInfo,xAttribs);
 305
 306     OSL_ASSERT(aInfo.type == ElementType::set || aInfo.type == ElementType::group);
 307
 308     if (aInfo.type == ElementType::group)
 309     {
 310         if (bStartTemplate)
 311             m_xHandler->startGroupTemplate( backenduno::TemplateIdentifier(aInfo.name,m_sComponent), aInfo.flags );
 312
 313         else
 314             m_xHandler->startGroup( aInfo.name, aInfo.flags );
 315     }
 316     else
 317     {
 318         backenduno::TemplateIdentifier aItemType;
 319
 320         if (!getDataParser().getSetElementType(xAttribs, aItemType.Name, aItemType.Component))
 321             raiseParseException("Schema XML parser - Invalid data: Missing item-type information for set node.\n");
 322
 323         if (bStartTemplate)
 324             m_xHandler->startSetTemplate( backenduno::TemplateIdentifier(aInfo.name,m_sComponent), aInfo.flags, aItemType );
 325
 326         else
 327             m_xHandler->startSet( aInfo.name, aInfo.flags, aItemType );
 328     }
 329 }
 330 // -----------------------------------------------------------------------------
 331
 332 void SchemaParser::endNode()
 333 {
 334     BasicParser::endNode();
 335
 336     bool bEndedTemplate = ( !isInNode() && m_selected == selectTemplates );
 337
 338     if (bEndedTemplate)
 339         m_xHandler->endTemplate();
 340
 341     else
 342         m_xHandler->endNode();
 343 }
 344 // -----------------------------------------------------------------------------
 345
 346 void SchemaParser::startProperty( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 347 {
 348     BasicParser::startProperty(aInfo,xAttribs);
 349
 350     OSL_ENSURE( isInUnhandledProperty(), "Property not recognizable as unhandled");
 351 }
 352 // -----------------------------------------------------------------------------
 353
 354 void SchemaParser::endProperty()
 355 {
 356     if (isInUnhandledProperty())
 357     {
 358         ElementInfo const & aInfo = this->getActiveNodeInfo();
 359
 360         m_xHandler->addProperty(aInfo.name,
 361                                 aInfo.flags,
 362                                 getActivePropertyType());
 363     }
 364
 365     BasicParser::endProperty();
 366 }
 367 // -----------------------------------------------------------------------------
 368
 369 void SchemaParser::startValueData(const uno::Reference< sax::XAttributeList >& xAttribs)
 370 {
 371     OSL_ENSURE( this->isInUnhandledProperty(),"Schema XML parser - multiple values in property are not permitted in the schema.\n");
 372
 373     BasicParser::startValueData(xAttribs);
 374
 375     if (this->isValueDataLocalized())
 376         getLogger().warning("Language attributes on values are ignored in the schema.",
 377                             "endValueData()","configuration::xml::SchemaParser");
 378 }
 379 // -----------------------------------------------------------------------------
 380
 381 void SchemaParser::endValueData()
 382 {
 383     uno::Any aValue = this->getCurrentValue();
 384
 385     ElementInfo const & aInfo = this->getActiveNodeInfo();
 386
 387     if (aValue.hasValue())
 388     {
 389         m_xHandler->addPropertyWithDefault(aInfo.name,aInfo.flags,aValue);
 390     }
 391     else
 392     {
 393         getLogger().warning("Found deprecated explicit NIL value in schema data.",
 394                             "endValueData()","configuration::xml::SchemaParser");
 395         m_xHandler->addProperty(aInfo.name,aInfo.flags,getActivePropertyType());
 396     }
 397
 398     BasicParser::endValueData();
 399
 400     OSL_ENSURE( !isInUnhandledProperty(), "Property not recognizable as handled");
 401 }
 402 // -----------------------------------------------------------------------------
 403
 404 // -----------------------------------------------------------------------------
 405     } // namespace
 406
 407 // -----------------------------------------------------------------------------
 408 } // namespace
 409