configmgr/source/tree/localizedtreeactions.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: localizedtreeactions.cxx,v $
  10  * $Revision: 1.19 $
  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 <stdio.h>
  35
  36 #include "localizedtreeactions.hxx"
  37 #include "treeactions.hxx"
  38 #include "builddata.hxx"
  39 #include "subtree.hxx"
  40 #include "matchlocale.hxx"
  41 #include "typeconverter.hxx"
  42 #include "change.hxx"
  43 #include "treechangefactory.hxx"
  44 #include "treenodefactory.hxx"
  45 #include "strdecl.hxx"
  46 #include <osl/diagnose.h>
  47
  48
  49 //..........................................................................
  50 namespace configmgr
  51 {
  52
  53 //--------------------------------------------------------------------------
  54 namespace
  55 {
  56 //--------------------------------------------------------------------------
  57     //==========================================================================
  58     //= OCloneForLocale
  59     //==========================================================================
  60     //= clones a subtree , in the process selecting only the best match locale
  61     //= from the set representation of localized values
  62     //==========================================================================
  63     class OCloneForLocale : public NodeAction
  64     {
  65         rtl::OUString                   m_sTargetLocale;
  66         std::auto_ptr<INode>    m_pClone;
  67     public:
  68         OCloneForLocale(rtl::OUString const& aLocale) : m_sTargetLocale(aLocale) {}
  69         std::auto_ptr<INode> getResult() { return m_pClone; }
  70
  71     private:
  72         void handle(ValueNode const& _aValue);
  73         void handle(ISubtree const&  _aSubtree);
  74     };
  75 //--------------------------------------------------------------------------
  76     struct OCloneChildrenForLocale : NodeAction
  77     {
  78         ISubtree&                               m_rParent;
  79         localehelper::FindBestLocale&                   m_rLocaleMatcher;
  80     public:
  81         OCloneChildrenForLocale(ISubtree& _rParent, localehelper::FindBestLocale& _rLocaleMatcher)
  82             : m_rParent(_rParent)
  83             , m_rLocaleMatcher(_rLocaleMatcher)
  84         {}
  85
  86         virtual void handle(ValueNode const& _aValue);
  87         virtual void handle(ISubtree const&  _aSubtree);
  88     };
  89
  90 //--------------------------------------------------------------------------
  91     struct OSelectForLocale : NodeAction
  92     {
  93         ValueNode const*        m_pFound;
  94         localehelper::FindBestLocale&           m_rLocaleMatcher;
  95     public:
  96         OSelectForLocale(localehelper::FindBestLocale& _rLocaleMatcher)
  97             : m_pFound(NULL)
  98             , m_rLocaleMatcher(_rLocaleMatcher)
  99         {}
 100
 101
 102         bool hasResult() const
 103         { return m_pFound != NULL; }
 104
 105         ValueNode const* getResult() const
 106         { return m_pFound; }
 107
 108     private:
 109         virtual void handle(ValueNode const& _aValue);
 110         virtual void handle(ISubtree const&  _aSubtree);
 111
 112         void maybeSelect(ValueNode const& _aNode);
 113     };
 114
 115 //--------------------------------------------------------------------------
 116 //--------------------------------------------------------------------------
 117     void OSelectForLocale::handle(ValueNode const& _aValue)
 118     {
 119         maybeSelect(_aValue);
 120     }
 121 //--------------------------------------------------------------------------
 122        void OSelectForLocale::handle(ISubtree const&  /*_aSubtree*/)
 123     {
 124         OSL_ENSURE(false, "INTERNAL ERROR: Inconsistent data: Found a Subtree in a set of localized values");
 125     }
 126 //--------------------------------------------------------------------------
 127     void OSelectForLocale::maybeSelect(ValueNode const& _aNode)
 128     {
 129         if (m_rLocaleMatcher.accept( localehelper::makeLocale(_aNode.getName()) ) )
 130             m_pFound = &_aNode;
 131
 132         else
 133             OSL_ENSURE(m_pFound, "WARNING: Node Locale wasn't accepted, but no node had been found before");
 134     }
 135
 136 //--------------------------------------------------------------------------
 137 //--------------------------------------------------------------------------
 138     std::auto_ptr< INode > implReduceLocalizedSet(ISubtree const&  _aSubtree, localehelper::FindBestLocale& _rLocaleMatcher)
 139     {
 140     // -- find the best-match locale -----------------------------
 141         _rLocaleMatcher.reset();
 142
 143         OSelectForLocale aSelector(_rLocaleMatcher);
 144
 145         aSelector.applyToChildren(_aSubtree);
 146
 147         std::auto_ptr< INode > pResult;
 148
 149     // -- look for a non-NULL value -----------------------------
 150         uno::Type aValueType;
 151         if (aSelector.hasResult())
 152         {
 153             ValueNode const& rSelected = *aSelector.getResult();
 154
 155             aValueType = rSelected.getValueType();
 156
 157             if (!rSelected.isNull()) // values are present - clone it from the values
 158             {
 159                 pResult.reset ( new ValueNode(  _aSubtree.getName(),
 160                                                 rSelected.getValue(), rSelected.getDefault(),
 161                                                 _aSubtree.getAttributes()
 162                               ) );
 163
 164             }
 165         }
 166         else // no entry - exract the type to be used from the template name
 167             aValueType = parseTemplateName(_aSubtree.getElementTemplateName());
 168
 169     // --  create NULL value, if none was found -----------------------------
 170         // create a NULL of the found type
 171         if (pResult.get() == NULL)
 172         {
 173             pResult.reset( new ValueNode(  _aSubtree.getName(),
 174                                             aValueType,
 175                                             _aSubtree.getAttributes()
 176                          ) );
 177         }
 178
 179     // -- -----------------------------
 180         OSL_ENSURE( aValueType != uno::Type(), "VOID result type found");
 181 #if OSL_DEBUG_LEVEL > 0
 182         uno::Type aTemplateType = parseTemplateName( _aSubtree.getElementTemplateName() );
 183         OSL_ENSURE( ( aValueType == aTemplateType ) || ( aTemplateType.getTypeClass() == uno::TypeClass_ANY ),
 184                     "ERROR: Found Value Type doesn't match encoded value type in pseudo template name");
 185 #endif
 186         OSL_POSTCOND( static_cast<ValueNode&>(*pResult).getValueType() == aValueType,
 187                       "ERROR: Resulting Value Type doesn't match original value type" );
 188
 189         return pResult;
 190     }
 191 //--------------------------------------------------------------------------
 192     std::auto_ptr< INode > implCloneForLocale(ISubtree const&  _aSubtree, localehelper::FindBestLocale& _rLocaleMatcher)
 193     {
 194         std::auto_ptr< INode > pClone;
 195
 196         if (isLocalizedValueSet(_aSubtree))
 197         {
 198             pClone = implReduceLocalizedSet(_aSubtree, _rLocaleMatcher);
 199         }
 200         else
 201         {
 202             // ISubtree should get a clone(NoChildCopy) member ...
 203             std::auto_ptr< Subtree > pCloneTree( new Subtree(_aSubtree, treeop::NoChildCopy()) );
 204
 205             OCloneChildrenForLocale aSubCloner(*pCloneTree,_rLocaleMatcher);
 206
 207             aSubCloner.applyToChildren(_aSubtree);
 208
 209             pClone.reset( pCloneTree.release() );
 210         }
 211
 212         return pClone;
 213     }
 214 //--------------------------------------------------------------------------
 215 //--- OCloneChildrenForLocale:-----------------------------------------------------------------------
 216
 217     void OCloneChildrenForLocale::handle(ValueNode const& _aValue)
 218     {
 219         // just a single value - nothing to do
 220         std::auto_ptr< INode > pClone( _aValue.clone() );
 221
 222         m_rParent.addChild(pClone);
 223
 224     }
 225 //--------------------------------------------------------------------------
 226     void OCloneChildrenForLocale::handle(ISubtree const&  _aSubtree)
 227     {
 228         std::auto_ptr< INode > pClone = implCloneForLocale(_aSubtree,m_rLocaleMatcher);
 229
 230         m_rParent.addChild(pClone);
 231     }
 232
 233     //--------------------------------------------------------------------------
 234     //= OCloneForLocale
 235
 236     //          rtl::OUString                   m_sTargetLocale;
 237     //          std::auto_ptr<INode>    m_pClone;
 238
 239     void OCloneForLocale::handle(ValueNode const& _aValue)
 240     {
 241         // just a single value - nothing to do
 242         std::auto_ptr< INode > pClone( _aValue.clone() );
 243
 244         m_pClone = pClone;
 245     }
 246     //--------------------------------------------------------------------------
 247     void OCloneForLocale::handle(ISubtree const&  _aSubtree)
 248     {
 249         localehelper::FindBestLocale aLocaleMatcher( localehelper::makeLocale(m_sTargetLocale) );
 250
 251         m_pClone = implCloneForLocale(_aSubtree,aLocaleMatcher);
 252     }
 253     //--------------------------------------------------------------------------
 254
 255 //--------------------------------------------------------------------------
 256 } // anonymous namespace
 257
 258 //==========================================================================
 259 // Helper function to invoke the previous ones properly
 260
 261 // convert to the given locale format, assuming the original representation was expanded
 262 static std::auto_ptr<INode> impl_cloneExpandedForLocale(INode const* _pNode, rtl::OUString const& _sLocale)
 263 {
 264     OSL_ASSERT(_pNode != NULL);
 265
 266     if ( localehelper::designatesAllLocales(localehelper::makeLocale(_sLocale)) ) // from expanded to expanded
 267     {
 268         return _pNode->clone();
 269     }
 270
 271     else // needs reduction
 272     {
 273         OCloneForLocale aCloner(_sLocale);
 274         aCloner.applyToNode(*_pNode);
 275         return aCloner.getResult();
 276     }
 277 }
 278 //--------------------------------------------------------------------------
 279
 280 // convert to the given locale format, assuming the original representation was expanded
 281 static rtl::Reference< data::TreeSegment > old_cloneExpandedForLocale(rtl::OUString const& _sName, INode const* _pNode, rtl::OUString const& _sLocale)
 282 {
 283     if (_pNode == NULL)
 284         return rtl::Reference< data::TreeSegment >();
 285
 286     std::auto_ptr<INode> aResult;
 287     if (dynamic_cast< ISubtree const * >(_pNode) == 0) // simple value - nothing to reduce
 288         aResult = _pNode->clone();
 289
 290     else
 291         aResult = impl_cloneExpandedForLocale(_pNode,_sLocale);
 292
 293     return data::TreeSegment::create(_sName,aResult);
 294 }
 295 //--------------------------------------------------------------------------
 296
 297 // -----------------------------------------------------------------------------
 298 //--------------------------------------------------------------------------
 299 rtl::Reference< data::TreeSegment > cloneExpandedForLocale(sharable::TreeFragment * tree, rtl::OUString const& _sLocale)
 300 {
 301     std::auto_ptr<INode> aOldTree = data::convertTree(tree, true);
 302
 303     return old_cloneExpandedForLocale(tree->getName(), aOldTree.get(), _sLocale);
 304 }
 305 //--------------------------------------------------------------------------
 306 // convert to the given locale format, assuming the original representation was expanded
 307 std::auto_ptr<INode> reduceExpandedForLocale(std::auto_ptr<ISubtree> _pNode, rtl::OUString const& _sLocale)
 308 {
 309     std::auto_ptr<INode> aResult;
 310
 311     if ( _pNode.get() == NULL ||                           // nothing to reduce
 312          localehelper::designatesAllLocales(localehelper::makeLocale(_sLocale)) ) // from expanded to expanded
 313     {
 314         aResult.reset( _pNode.release() );
 315     }
 316
 317     else // needs reduction
 318     {
 319         OCloneForLocale aCloner(_sLocale);
 320         aCloner.applyToNode(*_pNode);
 321         aResult = aCloner.getResult();
 322
 323         OSL_ENSURE(aResult.get(),"Cloning a tree for a locale unexpectedly produced NOTHING");
 324     }
 325     return aResult;
 326 }
 327 //--------------------------------------------------------------------------
 328 namespace
 329 {
 330 //--------------------------------------------------------------------------
 331     class ExpandTreeForLocale : NodeModification
 332     {
 333         ISubtree & m_rParent;
 334         rtl::OUString const & m_aSourceLocale;
 335
 336         ExpandTreeForLocale(ISubtree & _rParent,rtl::OUString const & _aSourceLocale)
 337         : m_rParent(_rParent)
 338         , m_aSourceLocale(_aSourceLocale)
 339         {}
 340
 341         void handle(ISubtree& _rNode);
 342         void handle(ValueNode& _rNode);
 343
 344         void substitute(std::auto_ptr<INode> _aExpanded);
 345     public:
 346         static void expand(ISubtree& _rTree, rtl::OUString const & _aSourceLocale)
 347         {
 348             ExpandTreeForLocale(_rTree,_aSourceLocale).applyToChildren(_rTree);
 349         }
 350
 351         // returns NULL, if not a localized value
 352         static std::auto_ptr<ISubtree> expanded(ValueNode const& _aNode, rtl::OUString const & _aSourceLocale);
 353     };
 354
 355 //--------------------------------------------------------------------------
 356     class ExpandChangesForLocale : ChangeTreeModification
 357     {
 358         SubtreeChange & m_rParent;
 359         rtl::OUString const & m_aSourceLocale;
 360
 361         ExpandChangesForLocale(SubtreeChange & _rParent,rtl::OUString const & _aSourceLocale)
 362         : m_rParent(_rParent)
 363         , m_aSourceLocale(_aSourceLocale)
 364         {}
 365
 366         void handle(SubtreeChange& _rNode);
 367         void handle(ValueChange& _rNode);
 368
 369         void handle(AddNode& _rNode);
 370         void handle(RemoveNode& _rNode);
 371
 372         void substitute(std::auto_ptr<Change> _aExpanded);
 373     public:
 374         static void expand(SubtreeChange& _rTree, rtl::OUString const & _aSourceLocale)
 375         {
 376             ExpandChangesForLocale(_rTree,_aSourceLocale).applyToChildren(_rTree);
 377         }
 378
 379         // returns NULL, if not a localized value
 380         static std::auto_ptr<SubtreeChange> expanded(ValueChange const& _aNode, rtl::OUString const & _aSourceLocale);
 381     };
 382 //--------------------------------------------------------------------------
 383 inline
 384 void ExpandTreeForLocale::substitute(std::auto_ptr<INode> _aExpanded)
 385 {
 386     m_rParent.removeChild(_aExpanded->getName());
 387     m_rParent.addChild(_aExpanded);
 388 }
 389
 390 //--------------------------------------------------------------------------
 391 void ExpandTreeForLocale::handle(ISubtree& _rNode)
 392 {
 393     expand(_rNode,m_aSourceLocale);
 394 }
 395
 396 //--------------------------------------------------------------------------
 397 void ExpandTreeForLocale::handle(ValueNode& _rNode)
 398 {
 399     std::auto_ptr<ISubtree>  aExpanded = expanded(_rNode,m_aSourceLocale);
 400
 401     if (aExpanded.get())
 402         substitute( base_ptr(aExpanded) );
 403 }
 404
 405 //--------------------------------------------------------------------------
 406
 407 std::auto_ptr<ISubtree>  ExpandTreeForLocale::expanded(ValueNode const& _aNode, rtl::OUString const & _aSourceLocale)
 408 {
 409     if (!_aNode.isLocalized()) return std::auto_ptr<ISubtree>();
 410
 411     OTreeNodeFactory & rFactory = getDefaultTreeNodeFactory();
 412
 413     node::Attributes aValueAttributes = _aNode.getAttributes();
 414
 415     aValueAttributes.setLocalized(false);
 416     if (aValueAttributes.state() == node::isMerged)
 417         aValueAttributes.setState( node::isReplaced );
 418
 419
 420     std::auto_ptr<ValueNode> aValue = _aNode.isNull()
 421                 ? rFactory.createNullValueNode(_aSourceLocale,_aNode.getValueType(),aValueAttributes)
 422                 : rFactory.createValueNode(_aSourceLocale,_aNode.getValue(),aValueAttributes);
 423
 424     std::auto_ptr<ISubtree> aRet = rFactory.createSetNode(  _aNode.getName(),
 425                                                             toTemplateName(_aNode.getValueType()),
 426                                                             TEMPLATE_MODULE_LOCALIZED_VALUE,
 427                                                             _aNode.getAttributes() );
 428
 429     aRet->addChild(base_ptr(aValue));
 430
 431     return aRet;
 432 }
 433
 434 //--------------------------------------------------------------------------
 435 //--------------------------------------------------------------------------
 436 inline
 437 void ExpandChangesForLocale::substitute(std::auto_ptr<Change> _aExpanded)
 438 {
 439     m_rParent.removeChange(_aExpanded->getNodeName());
 440     m_rParent.addChange(_aExpanded);
 441 }
 442
 443 //--------------------------------------------------------------------------
 444
 445 void ExpandChangesForLocale::handle(SubtreeChange& _rNode)
 446 {
 447     expand(_rNode,m_aSourceLocale);
 448 }
 449
 450 //--------------------------------------------------------------------------
 451 void ExpandChangesForLocale::handle(ValueChange& _rNode)
 452 {
 453     std::auto_ptr<SubtreeChange> aExpanded = expanded(_rNode,m_aSourceLocale);
 454
 455     if (aExpanded.get())
 456         substitute( base_ptr( aExpanded ) );
 457 }
 458
 459 //--------------------------------------------------------------------------
 460 void ExpandChangesForLocale::handle(AddNode& _rNode)
 461 {
 462     rtl::Reference< data::TreeSegment > seg(_rNode.getNewTree());
 463     std::auto_ptr<INode> pAdded(data::convertTree(seg.is() ? seg->fragment : 0, false));
 464     if (pAdded.get() != NULL)
 465     {
 466         std::auto_ptr<INode> pExpanded;
 467         if (ISubtree * pAddedTree = pAdded->asISubtree())
 468         {
 469             ExpandTreeForLocale::expand(*pAddedTree,m_aSourceLocale);
 470             pExpanded = pAdded;
 471         }
 472         else if(ValueNode * pAddedValue = pAdded->asValueNode())
 473         {
 474             pExpanded = base_ptr(ExpandTreeForLocale::expanded(*pAddedValue,m_aSourceLocale));
 475         }
 476         else
 477             OSL_ENSURE(false, "Cannot expand unknown Node type (found in AddNode)");
 478
 479
 480         if (pExpanded.get())
 481         {
 482             rtl::Reference< data::TreeSegment > aExpanded = data::TreeSegment::create( _rNode.getNodeName(),pExpanded);
 483             std::auto_ptr<AddNode> aExpandedAdd( new AddNode( aExpanded, _rNode.getNodeName(), _rNode.isToDefault() ) );
 484
 485             if (_rNode.isReplacing()) aExpandedAdd->setReplacing();
 486
 487             substitute( base_ptr( aExpandedAdd ) );
 488         }
 489     }
 490     else
 491         OSL_ENSURE(false, "Cannot expand AddNode without content");
 492 }
 493
 494 //--------------------------------------------------------------------------
 495 void ExpandChangesForLocale::handle(RemoveNode& )
 496 {
 497     // nothing to do
 498 }
 499
 500 //--------------------------------------------------------------------------
 501 std::auto_ptr<SubtreeChange> ExpandChangesForLocale::expanded(ValueChange const& _aNode, rtl::OUString const & _aSourceLocale)
 502 {
 503     std::auto_ptr<SubtreeChange> aRet;
 504     if (_aNode.isLocalizedValue())
 505     {
 506         OTreeNodeFactory & rNodeFactory = getDefaultTreeNodeFactory();
 507         OTreeChangeFactory & rFactory = getDefaultTreeChangeFactory();
 508
 509         node::Attributes aValueAttributes = _aNode.getAttributes();
 510
 511         aValueAttributes.setLocalized(false);
 512         if (aValueAttributes.state() == node::isMerged)
 513             aValueAttributes.setState( node::isReplaced );
 514
 515
 516         rtl::OUString const sTemplateName = toTemplateName(_aNode.getValueType());
 517
 518         std::auto_ptr<ValueNode> aValue = _aNode.getNewValue().hasValue()
 519                     ? rNodeFactory.createValueNode(sTemplateName,_aNode.getNewValue(),aValueAttributes)
 520                     : rNodeFactory.createNullValueNode(sTemplateName,_aNode.getValueType(),aValueAttributes);
 521
 522         rtl::Reference< data::TreeSegment > aValueSegment = data::TreeSegment::create(_aSourceLocale, base_ptr(aValue));
 523
 524         std::auto_ptr<AddNode> aAddValue = rFactory.createAddNodeChange(aValueSegment,_aSourceLocale,_aNode.isToDefault());
 525         aAddValue->setReplacing();
 526
 527         aRet = rFactory.createSetNodeChange( _aNode.getNodeName(),
 528                                             sTemplateName,
 529                                             TEMPLATE_MODULE_LOCALIZED_VALUE,
 530                                             _aNode.getAttributes() );
 531
 532         aRet->addChange(base_ptr(aAddValue));
 533     }
 534     return aRet;
 535 }
 536
 537 //--------------------------------------------------------------------------
 538 } // anonymous namespace
 539 //--------------------------------------------------------------------------
 540
 541 //--------------------------------------------------------------------------
 542 //..........................................................................
 543 }       // namespace configmgr
 544 //..........................................................................
 545
 546