configmgr/source/backend/schemabuilder.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: schemabuilder.cxx,v $
  10  * $Revision: 1.18 $
  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 "schemabuilder.hxx"
  35 #include "treenodefactory.hxx"
  36 #include "matchlocale.hxx"
  37 #include <com/sun/star/configuration/backend/SchemaAttribute.hpp>
  38 #include <rtl/ustrbuf.hxx>
  39
  40 #ifndef INCLUDED_ALGORITHM
  41 #include <algorithm>
  42 #define INCLUDED_ALGORITHM
  43 #endif
  44 #ifndef INCLUDED_VECTOR
  45 #include <vector>
  46 #define INCLUDED_VECTOR
  47 #endif
  48
  49 namespace configmgr
  50 {
  51 // -----------------------------------------------------------------------------
  52     namespace backend
  53     {
  54 // -----------------------------------------------------------------------------
  55
  56         namespace SchemaAttribute = backenduno::SchemaAttribute;
  57 // -----------------------------------------------------------------------------
  58 //#if OSL_DEBUG_LEVEL > 0
  59 // currently not used in debug builds
  60 #if 0
  61         static void check_if_complete(MergedComponentData & md, uno::Reference< uno::XComponentContext > const & xContext)
  62         {
  63             uno::Reference< backenduno::XSchemaHandler >
  64                  test(new SchemaBuilder(xContext, rtl::OUString(),md,NULL));
  65         }
  66 #endif
  67 // -----------------------------------------------------------------------------
  68
  69 SchemaBuilder::SchemaBuilder(uno::Reference< uno::XComponentContext > const & xContext, const rtl::OUString& aExpectedComponentName, MergedComponentData & rData, ITemplateDataProvider* aTemplateProvider )
  70 : m_aData(rData)
  71 , m_aContext(xContext)
  72 //, m_aContext(xContext,static_cast<backenduno::XSchemaHandler*>(this), aExpectedComponentName, aTemplateProvider )
  73 , m_aFactory()
  74 {
  75     m_aContext = DataBuilderContext(xContext,static_cast<backenduno::XSchemaHandler*>(this), aExpectedComponentName, aTemplateProvider );
  76 }
  77 // -----------------------------------------------------------------------------
  78
  79 SchemaBuilder::~SchemaBuilder(  )
  80 {
  81
  82 }
  83 // -----------------------------------------------------------------------------
  84
  85 // -----------------------------------------------------------------------------
  86 // XSchemaHandler
  87
  88 void SAL_CALL SchemaBuilder::startSchema(  )
  89         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
  90 {
  91     if (!this->isDone())
  92         m_aContext.raiseMalformedDataException("Schema builder: Unexpected Restart of Schema");
  93
  94     m_aData.clear();
  95
  96     OSL_ASSERT(!m_aContext.hasActiveComponent());
  97     OSL_ASSERT( m_aContext.isDone());
  98 }
  99 // -----------------------------------------------------------------------------
 100
 101 void SAL_CALL SchemaBuilder::endSchema(  )
 102         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 103 {
 104     if (!this->isDone())
 105         m_aContext.raiseMalformedDataException("Schema builder: Unexpected End of Schema");
 106
 107     substituteInstances();
 108 }
 109 // -----------------------------------------------------------------------------
 110
 111 void SAL_CALL SchemaBuilder::importComponent( const rtl::OUString& /*aName*/ )
 112         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 113 {
 114     //OSL_TRACE("WARNING: Configuration schema parser: Cross-component references are not yet supported\n");
 115 }
 116 // -----------------------------------------------------------------------------
 117
 118
 119 void SAL_CALL SchemaBuilder::startComponent( const rtl::OUString& aName )
 120         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 121 {
 122     if (m_aData.hasSchema())
 123         m_aContext.raiseElementExistException("Schema builder: The component schema is already loaded", rtl::OUString());
 124
 125     m_aContext.startActiveComponent(aName);
 126
 127     std::auto_ptr<ISubtree> apSchema =
 128         m_aFactory.createGroup(aName,0,getComponentRootAttributes());
 129
 130     ISubtree * pSchema = m_aData.setSchemaRoot(apSchema);
 131
 132     m_aContext.pushNode(pSchema);
 133 }
 134 // -----------------------------------------------------------------------------
 135
 136 void SAL_CALL SchemaBuilder::endComponent( )
 137         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 138 {
 139     m_aContext.popNode();
 140
 141     m_aContext.endActiveComponent();
 142 }
 143 // -----------------------------------------------------------------------------
 144
 145 bool SchemaBuilder::isExtensible(sal_Int16 aSchemaAttributes)
 146 {
 147     sal_Int16 const aValidAttributes = aSchemaAttributes & SchemaAttribute::EXTENSIBLE;
 148
 149     if (aValidAttributes != aSchemaAttributes)
 150         m_aContext.raiseIllegalArgumentException("Schema builder: Illegal attribute specified for node.",2);
 151
 152     return (aValidAttributes != 0);
 153 }
 154 // -----------------------------------------------------------------------------
 155
 156 void SAL_CALL SchemaBuilder::startGroupTemplate( const backenduno::TemplateIdentifier& aTemplate, sal_Int16 aAttributes )
 157         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 158 {
 159     if (aTemplate.Component.getLength() == 0)
 160         m_aContext.raiseIllegalArgumentException("Schema builder: Starting template without owning component",1);
 161
 162     m_aContext.startActiveComponent(aTemplate.Component);
 163
 164     if (m_aData.hasTemplate(aTemplate.Name))
 165         m_aContext.raiseElementExistException("Schema builder: Template already exists",aTemplate.Name);
 166
 167     rtl::OUString aName = m_aData.getTemplateAccessor(aTemplate);
 168     bool bExtensible = isExtensible(aAttributes);
 169
 170     std::auto_ptr<ISubtree> aTemplateTree =
 171         m_aFactory.createGroup(aName,bExtensible,getTemplateBaseAttributes());
 172
 173     ISubtree * pTree = m_aData.addTemplate(aTemplateTree,aTemplate);
 174
 175     m_aContext.pushNode(pTree);
 176 }
 177 // -----------------------------------------------------------------------------
 178
 179 void SAL_CALL SchemaBuilder::startSetTemplate( const backenduno::TemplateIdentifier& aTemplate, sal_Int16 aAttributes, const backenduno::TemplateIdentifier& aItemType )
 180         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 181 {
 182     if (aTemplate.Component.getLength() == 0)
 183         m_aContext.raiseIllegalArgumentException("Schema builder: Starting template without owning component",1);
 184
 185     m_aContext.startActiveComponent(aTemplate.Component);
 186
 187     if (m_aData.hasTemplate(aTemplate.Name))
 188         m_aContext.raiseElementExistException("Schema builder: Template already exists",aTemplate.Name);
 189
 190     rtl::OUString aName = m_aData.getTemplateAccessor(aTemplate);
 191     backenduno::TemplateIdentifier aFullType = m_aContext.completeComponent(aItemType);
 192     bool bExtensible = isExtensible(aAttributes);
 193
 194     std::auto_ptr<ISubtree> aTemplateTree =
 195         m_aFactory.createSet( aName,aFullType,bExtensible,getTemplateBaseAttributes());
 196
 197     ISubtree * pTree = m_aData.addTemplate(aTemplateTree,aTemplate);
 198
 199     m_aContext.pushNode(pTree);
 200 }
 201 // -----------------------------------------------------------------------------
 202
 203 void SAL_CALL SchemaBuilder::endTemplate( )
 204         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 205 {
 206     m_aContext.popNode();
 207
 208     m_aContext.endActiveComponent();
 209 }
 210 // -----------------------------------------------------------------------------
 211
 212 void SAL_CALL SchemaBuilder::startGroup( const rtl::OUString& aName, sal_Int16 aAttributes )
 213         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 214 {
 215     bool bExtensible = isExtensible(aAttributes);
 216
 217     std::auto_ptr<ISubtree> aTree = m_aFactory.createGroup(aName,bExtensible,getNodeAttributes());
 218
 219     ISubtree * pTree = m_aContext.addNodeToCurrent(aTree);
 220
 221     m_aContext.pushNode(pTree);
 222 }
 223 // -----------------------------------------------------------------------------
 224
 225 void SAL_CALL SchemaBuilder::startSet( const rtl::OUString& aName, sal_Int16 aAttributes, const backenduno::TemplateIdentifier& aItemType )
 226         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 227 {
 228     backenduno::TemplateIdentifier aFullType = m_aContext.completeComponent(aItemType);
 229     bool bExtensible = isExtensible(aAttributes);
 230
 231     std::auto_ptr<ISubtree> aTree = m_aFactory.createSet(aName,aFullType,bExtensible,getNodeAttributes());
 232
 233     ISubtree * pTree = m_aContext.addNodeToCurrent(aTree);
 234
 235     m_aContext.pushNode(pTree);
 236 }
 237 // -----------------------------------------------------------------------------
 238
 239 void SAL_CALL SchemaBuilder::endNode( )
 240         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 241 {
 242     m_aContext.popNode();
 243
 244     if (m_aContext.isDone())
 245         m_aContext.raiseMalformedDataException("Schema builder: Incorrect Termination");
 246 }
 247 // -----------------------------------------------------------------------------
 248
 249 node::Attributes SchemaBuilder::makePropertyAttributes(sal_Int16 aSchemaAttributes) const
 250 {
 251     const sal_uInt16 c_AllPropertyAttributes =
 252         SchemaAttribute::REQUIRED | SchemaAttribute::LOCALIZED;
 253
 254     if ((aSchemaAttributes & c_AllPropertyAttributes) != aSchemaAttributes)
 255         m_aContext.raiseIllegalArgumentException("SchemaBuilder: Unreckognized Attribute for Property",2);
 256
 257     node::Attributes aAttributes = getNodeAttributes();
 258
 259     if (aSchemaAttributes & SchemaAttribute::REQUIRED)
 260         aAttributes.setNullable (false);
 261
 262     return aAttributes;
 263 }
 264 // -----------------------------------------------------------------------------
 265
 266 void SAL_CALL SchemaBuilder::addProperty( const rtl::OUString& aName, sal_Int16 aAttributes, const uno::Type& aType )
 267         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 268 {
 269     // TODO: add type validation
 270     node::Attributes aValueAttributes = makePropertyAttributes(aAttributes);
 271
 272     if (aAttributes & SchemaAttribute::LOCALIZED)
 273     {
 274         std::auto_ptr<ISubtree> aLocalizedProp =
 275             m_aFactory.createLocalizedContainer(aName,aType,aValueAttributes);
 276
 277         m_aContext.addLocalizedToCurrent(aLocalizedProp);
 278     }
 279     else
 280     {
 281         std::auto_ptr<ValueNode> aPropertyValue =
 282             m_aFactory.getNodeFactory().createNullValueNode(aName,aType,aValueAttributes);
 283
 284         m_aContext.addPropertyToCurrent(aPropertyValue);
 285     }
 286 }
 287 // -----------------------------------------------------------------------------
 288
 289 void SAL_CALL SchemaBuilder::addPropertyWithDefault( const rtl::OUString& aName, sal_Int16 aAttributes, const uno::Any& aDefaultValue )
 290         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 291 {
 292     // TODO: add parameter validation
 293     node::Attributes aValueAttributes = makePropertyAttributes(aAttributes);
 294
 295     if (aAttributes & SchemaAttribute::LOCALIZED)
 296     {
 297         std::auto_ptr<ISubtree> aLocalizedProp =
 298             m_aFactory.createLocalizedContainer(aName,aDefaultValue.getValueType(),aValueAttributes);
 299
 300         std::auto_ptr<ValueNode> aPropertyValue =
 301             m_aFactory.getNodeFactory().createValueNode(localehelper::getDefaultLanguage(),aDefaultValue,aValueAttributes);
 302
 303         aLocalizedProp->addChild( base_ptr(aPropertyValue) );
 304
 305         m_aContext.addLocalizedToCurrent(aLocalizedProp);
 306     }
 307     else
 308     {
 309         std::auto_ptr<ValueNode> aPropertyValue =
 310             m_aFactory.getNodeFactory().createValueNode(aName,aDefaultValue,aValueAttributes);
 311
 312
 313         m_aContext.addPropertyToCurrent( aPropertyValue);
 314     }
 315 }
 316 // -----------------------------------------------------------------------------
 317
 318 void SAL_CALL SchemaBuilder::addInstance( const rtl::OUString& aName, const backenduno::TemplateIdentifier& aTemplate )
 319         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 320 {
 321     backenduno::TemplateIdentifier aFullType = m_aContext.completeComponent(aTemplate);
 322
 323     std::auto_ptr<ISubtree> aPlaceHolder =
 324         m_aFactory.createPlaceHolder(aName,aFullType);
 325
 326     m_aContext.addNodeToCurrent(aPlaceHolder);
 327 }
 328 // -----------------------------------------------------------------------------
 329
 330 void SAL_CALL SchemaBuilder::addItemType( const backenduno::TemplateIdentifier& aItemType )
 331         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 332 {
 333     if ( m_aContext.getCurrentParent().getElementTemplateName() != aItemType.Name ||
 334          m_aContext.getCurrentParent().getElementTemplateModule() != m_aContext.getTemplateComponent(aItemType) )
 335     {
 336         OSL_ENSURE(false, "SchemaBuilder: Multiple ItemTypes for Sets are currently not supported");
 337         m_aContext.raiseMalformedDataException("SchemaBuilder: Unsupported Feature: Multiple ItemTypes for Sets");
 338     }
 339 }
 340 // -----------------------------------------------------------------------------
 341 // -----------------------------------------------------------------------------
 342
 343 node::Attributes SchemaBuilder::getNodeAttributes() const
 344 {
 345     node::Attributes aResult = m_aContext.getCurrentAttributes();
 346     aResult.setState( node::isDefault );
 347     return aResult;
 348 }
 349 // -----------------------------------------------------------------------------
 350
 351 node::Attributes SchemaBuilder::getComponentRootAttributes()
 352 {
 353     node::Attributes aResult;
 354     aResult.setState( node::isDefault );
 355     return aResult;
 356 }
 357 // -----------------------------------------------------------------------------
 358
 359 node::Attributes SchemaBuilder::getTemplateBaseAttributes()
 360 {
 361     node::Attributes aResult;
 362     aResult.setState( node::isReplaced );
 363     return aResult;
 364 }
 365 // -----------------------------------------------------------------------------
 366 // -----------------------------------------------------------------------------
 367
 368 namespace
 369 {
 370     class SubstitutionHelper : NodeModification
 371     {
 372         MergedComponentData &   m_rData;
 373         DataBuilderContext      m_aContext;
 374         ComponentDataFactory    m_aFactory;
 375
 376         std::vector< rtl::OUString >            m_aReplacementList;
 377         std::vector< ISubtree const * >           m_aTemplateStack;
 378     public:
 379         SubstitutionHelper(DataBuilderContext const & aBaseContext, MergedComponentData & _rData, uno::XInterface * _pContext)
 380         : m_rData(_rData)
 381         , m_aContext(aBaseContext,_pContext)
 382         , m_aReplacementList()
 383         , m_aTemplateStack()
 384         {}
 385
 386         void substituteInData();
 387     private:
 388         void substituteInComponent(ISubtree * _pComponent);
 389         void substituteInNode(ISubtree & _rNode);
 390         void substituteInList();
 391
 392         void substitute(rtl::OUString const & _aName);
 393
 394         virtual void handle(ValueNode&);
 395         virtual void handle(ISubtree&);
 396     };
 397 }
 398 // -----------------------------------------------------------------------------
 399
 400 void SchemaBuilder::substituteInstances()
 401 {
 402     SubstitutionHelper helper(m_aContext, m_aData, static_cast<backenduno::XSchemaHandler*>(this));
 403
 404     helper.substituteInData();
 405 }
 406 // -----------------------------------------------------------------------------
 407 // -----------------------------------------------------------------------------
 408 namespace
 409 {
 410 // -----------------------------------------------------------------------------
 411     void SubstitutionHelper::substituteInData()
 412     {
 413         if (m_rData.hasTemplates())
 414             substituteInComponent(m_rData.getTemplatesTree());
 415
 416         if (m_rData.hasSchema())
 417             substituteInComponent(m_rData.getSchemaTree());
 418     }
 419     // -----------------------------------------------------------------------------
 420
 421     void SubstitutionHelper::substituteInComponent(ISubtree * _pComponent)
 422     {
 423         OSL_ENSURE(_pComponent,"ERROR: Trying to substitute in NULL component");
 424
 425         if (_pComponent)
 426         {
 427             m_aContext.startActiveComponent(_pComponent->getName());
 428             this->substituteInNode(*_pComponent);
 429             m_aContext.endActiveComponent();
 430         }
 431     }
 432     // -----------------------------------------------------------------------------
 433
 434     void SubstitutionHelper::substituteInNode(ISubtree & _rNode)
 435     {
 436         std::vector< rtl::OUString > aSaveInstances;
 437         aSaveInstances.swap(m_aReplacementList);
 438
 439         // todo: own stack to check against infinite recursion
 440         m_aContext.pushNode(&_rNode);
 441
 442         this->applyToChildren(_rNode); // fill the list
 443
 444         this->substituteInList();
 445
 446         m_aContext.popNode();
 447
 448         aSaveInstances.swap(m_aReplacementList);
 449     }
 450     // -----------------------------------------------------------------------------
 451
 452     void SubstitutionHelper::substituteInList()
 453     {
 454         for(std::vector< rtl::OUString >::iterator it = m_aReplacementList.begin();
 455             it != m_aReplacementList.end(); ++it)
 456         {
 457             this->substitute(*it);
 458         }
 459     }
 460     // -----------------------------------------------------------------------------
 461
 462     void SubstitutionHelper::substitute(rtl::OUString const & _aName)
 463     {
 464
 465         ISubtree & rParent = m_aContext.getCurrentParent();
 466
 467         std::auto_ptr<INode> pReplacedNode = rParent.removeChild(_aName);
 468         OSL_ASSERT( pReplacedNode.get() != NULL );
 469
 470         ISubtree * pReplacedInstance = pReplacedNode->asISubtree();
 471         OSL_ASSERT( pReplacedInstance != NULL );
 472
 473         backenduno::TemplateIdentifier aTemplateName = m_aFactory.getInstanceType(*pReplacedInstance);
 474         if (aTemplateName.Component == m_aContext.getActiveComponent())
 475         {
 476             if (ISubtree const * pTemplate = m_rData.findTemplate(aTemplateName.Name))
 477             {
 478                 std::vector< ISubtree const * >::iterator beg = m_aTemplateStack.begin(), end = m_aTemplateStack.end();
 479                 if (std::find(beg,end,pTemplate) != end)
 480                     m_aContext.raiseMalformedDataException("SchemaBuilder: Could not expand instances: Template is recursive");
 481
 482                 m_aTemplateStack.push_back(pTemplate);
 483
 484                 std::auto_ptr< INode > pTemplateInstance = pTemplate->clone();
 485
 486                 pTemplateInstance->setName(_aName);
 487                 // TODO: adjust state/attributes here (?)
 488
 489                 ISubtree * pAddedTree = rParent.addChild(pTemplateInstance)->asISubtree();
 490
 491                 OSL_ENSURE(pAddedTree, "Could not obtain added template instance");
 492
 493                 this->substituteInNode(*pAddedTree);
 494
 495                 m_aTemplateStack.pop_back();
 496             }
 497             else
 498             {
 499                 m_aContext.raiseMalformedDataException("SchemaBuilder: Could not expand instances: Template not found");
 500             }
 501         }
 502          //Import Template from different component
 503         else
 504         {
 505             TemplateRequest aTemplateRequest(aTemplateName.Name,
 506                                              aTemplateName.Component );
 507              ResultHolder< TemplateInstance > aResult = m_aContext.getTemplateData( aTemplateRequest );
 508
 509              std::auto_ptr<INode> pTemplateInstance = aResult.extractDataAndClear();
 510              pTemplateInstance->setName(_aName);
 511
 512              // Add template instance - must be a tree as any template
 513              OSL_VERIFY(
 514         rParent.addChild(pTemplateInstance)->asISubtree() );
 515         }
 516     }
 517     // -----------------------------------------------------------------------------
 518
 519     void SubstitutionHelper::handle(ValueNode&)
 520     {
 521     }
 522     // -----------------------------------------------------------------------------
 523
 524     void SubstitutionHelper::handle(ISubtree& _rTree)
 525     {
 526         if (m_aFactory.isInstancePlaceHolder(_rTree))
 527             m_aReplacementList.push_back(_rTree.getName());
 528
 529         else
 530             substituteInNode(_rTree);
 531     }
 532 // -----------------------------------------------------------------------------
 533 }
 534 // -----------------------------------------------------------------------------
 535 // -----------------------------------------------------------------------------
 536     } // namespace backend
 537
 538 // -------------------------------------------------------------------------
 539 } // namespace configmgr