configmgr/source/backendhelper/backendlayerhelper.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: backendlayerhelper.cxx,v $
  10  * $Revision: 1.5 $
  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
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_configmgr.hxx"
  34
  35
  36 #include "backendlayerhelper.hxx"
  37 #include <com/sun/star/configuration/backend/PropertyInfo.hpp>
  38
  39 namespace configmgr { namespace backendhelper {
  40
  41 //==============================================================================
  42
  43 //------------------------------------------------------------------------------
  44 uno::Type toType(const ::rtl::OUString& _rType)
  45     {
  46         uno::Type aRet;
  47
  48         if  (_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("boolean")))
  49             aRet = ::getBooleanCppuType();
  50
  51         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("short")))
  52             aRet = ::getCppuType(static_cast<sal_Int16 const*>(0));
  53
  54         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("int")))
  55             aRet = ::getCppuType(static_cast<sal_Int32 const*>(0));
  56
  57         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("integer")))
  58             aRet = ::getCppuType(static_cast<sal_Int32 const*>(0));
  59
  60         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("long")))
  61             aRet = ::getCppuType(static_cast<sal_Int64 const*>(0));
  62
  63         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("double")))
  64             aRet = ::getCppuType(static_cast<double const*>(0));
  65
  66         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("string")))
  67             aRet = ::getCppuType(static_cast<rtl::OUString const*>(0));
  68
  69         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("binary")))
  70             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Int8> const*>(0));
  71
  72         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("any")))
  73             aRet = ::getCppuType(static_cast<uno::Any const*>(0));
  74
  75         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("boolean-list")))
  76             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Bool> const*>(0));
  77
  78         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("short-list")))
  79             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Int16> const*>(0));
  80
  81         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("int-list")))
  82             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Int32> const*>(0));
  83
  84         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("integer-list")))
  85             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Int32> const*>(0));
  86
  87         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("long-list")))
  88             aRet = ::getCppuType(static_cast<uno::Sequence<sal_Int64> const*>(0));
  89
  90         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("double-list")))
  91             aRet = ::getCppuType(static_cast<uno::Sequence<double> const*>(0));
  92
  93         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("string-list")))
  94             aRet = ::getCppuType(static_cast<uno::Sequence<rtl::OUString> const*>(0));
  95
  96         else if(_rType.equalsIgnoreAsciiCase(::rtl::OUString::createFromAscii("binary-list")))
  97             aRet = ::getCppuType(static_cast<uno::Sequence<uno::Sequence<sal_Int8> > const*>(0));
  98
  99         else
 100         {
 101             ::rtl::OString aStr("Unknown type! ");
 102             aStr += rtl::OUStringToOString(_rType,RTL_TEXTENCODING_ASCII_US);
 103             OSL_ENSURE(0,aStr.getStr());
 104         }
 105
 106         return aRet;
 107     }
 108
 109 //------------------------------------------------------------------------------
 110
 111 IOONode::IOONode(const rtl::OUString& sName):
 112     mName(sName)
 113 {
 114 }
 115
 116 //------------------------------------------------------------------------------
 117 OOProperty::OOProperty(
 118     const rtl::OUString& sName,const rtl::OUString& sPropType,
 119     const uno::Any& aPropValue,sal_Bool bProtected)
 120     :IOONode(sName), mPropType(sPropType), mPropValue(aPropValue),
 121     mbProtected(bProtected)
 122 {
 123 }
 124 //------------------------------------------------------------------------------
 125 OONode::OONode(const rtl::OUString& sName)
 126     :IOONode(sName)
 127 {
 128 }
 129
 130 OONode::OONode()
 131     :IOONode(rtl::OUString())
 132 {
 133 }
 134 IOONode* OONode::addChild(IOONode* aChild)
 135 {
 136     mChildList.push_back(aChild);
 137     return aChild;
 138 }
 139 const std::vector<IOONode*>& OONode::getChildren()
 140 {
 141     return mChildList;
 142 }
 143
 144 IOONode* OONode::getChild(const rtl::OUString& aChildName)
 145 {
 146     for (sal_uInt32 i=0; i< mChildList.size();++i)
 147     {
 148         if (mChildList[i]->getName() == aChildName)
 149             return mChildList[i];
 150     }
 151     return NULL;
 152 }
 153 OONode::~OONode()
 154 {
 155     for (sal_uInt32 i=0; i< mChildList.size();++i)
 156     {
 157         delete mChildList[i];
 158     }
 159     mChildList.clear();
 160 }
 161 //------------------------------------------------------------------------------
 162  sal_Bool addChildrenToNodeTree(
 163      OONode * aNode,
 164      sal_Int32 nNextToken,
 165      const backend::PropertyInfo& aPropInfo,
 166      const uno::Reference<uno::XInterface>& xContext)
 167 {
 168     do
 169     {
 170         rtl::OUString aName = aPropInfo.Name.getToken(0, '/',nNextToken);
 171         if (aName.getLength() == 0)
 172         {
 173             throw backend::MalformedDataException(
 174                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 175                         "Malformed OpenOffice Key specified")),
 176                         xContext, uno::Any()) ;
 177         }
 178         //Check if Property -> nNextToken == -1
 179         if(nNextToken != -1)
 180         {
 181             //check if child already exists
 182             IOONode* aChildNode= aNode->getChild(aName);
 183             if (aChildNode == NULL)
 184             {
 185                 aChildNode = new OONode(aName);
 186                 if (aChildNode != 0)
 187                 {
 188                     aNode->addChild( aChildNode);
 189                 }
 190             }
 191
 192             sal_Bool bFinished =addChildrenToNodeTree(
 193                 aChildNode->getComposite(),
 194                 nNextToken,
 195                 aPropInfo,
 196                 xContext);
 197             //Check that if you have finished parsing string therefore no
 198             //more children
 199             if (bFinished)
 200                 break;
 201         }
 202         else
 203         {
 204             //Add Property
 205             IOONode* aProperty = new OOProperty(aName,
 206                                                 aPropInfo.Type,
 207                                                 aPropInfo.Value,
 208                                                 aPropInfo.Protected);
 209             if (aProperty != 0)
 210             {
 211                 aNode->addChild( aProperty);
 212             }
 213             //Return finished is true when you are finished parsing the string
 214             if( nNextToken == -1)
 215             {
 216                 return sal_True;
 217             }
 218         }
 219     }
 220     while (nNextToken >= 0 ) ;
 221     return sal_True;
 222 }
 223 //------------------------------------------------------------------------------
 224 void processChildren(
 225      std::vector<IOONode*> aChildList,
 226     const uno::Reference<backend::XLayerHandler>& xHandler)
 227 {
 228     for(sal_uInt32 i=0; i <aChildList.size(); ++i)
 229     {
 230         OONode * aTestOONode = aChildList[i]->getComposite();
 231         if (aTestOONode)
 232         {
 233             xHandler->overrideNode(aTestOONode->getName(),0,false);
 234             processChildren(aTestOONode->getChildren(),xHandler);
 235             xHandler->endNode();
 236         }
 237         else
 238         {
 239             OOProperty* aProperty = aChildList[i]->asOOProperty();
 240             sal_Int16 aAttributes = aProperty->isProtected() ? 256:0;
 241             //Convert Type either simple or list
 242             uno::Type aType = toType( aProperty->getType());
 243
 244             xHandler->overrideProperty(aProperty->getName(),
 245                                        aAttributes,
 246                                        aType,
 247                                        false);
 248
 249             xHandler->setPropertyValue(aProperty->getValue());
 250             xHandler->endProperty();
 251         }
 252
 253     }
 254 }
 255 //------------------------------------------------------------------------------
 256 void buildNodeTree(
 257     const uno::Sequence< backend::PropertyInfo >& aPropertyInfos,
 258     const uno::Reference<uno::XInterface>& xContext,
 259     OONode& aNodeTree)
 260 {
 261     sal_Int32 nNextToken =0;
 262     rtl::OUString aName = aPropertyInfos[0].Name.getToken(0, '/',nNextToken);
 263     if((nNextToken ==-1)||(aName.getLength()==0))
 264     {
 265          throw backend::MalformedDataException(
 266                rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 267                        "Malformed OpenOffice Key specified")),
 268                     xContext, uno::Any()) ;
 269
 270     }
 271     aNodeTree.setName(aName);
 272     sal_Int32 size = aPropertyInfos.getLength();
 273     for (sal_Int32 i =0; i < size; ++i)
 274     {
 275         addChildrenToNodeTree(&aNodeTree, nNextToken,aPropertyInfos[i],xContext);
 276     }
 277
 278 }
 279 //------------------------------------------------------------------------------
 280 BackendLayerHelper::BackendLayerHelper(
 281     const uno::Reference<uno::XComponentContext>& /*xContext*/)
 282     :cppu::WeakComponentImplHelper2<backend::XLayerContentDescriber, lang::XServiceInfo>(mMutex)
 283 {
 284 }
 285 //------------------------------------------------------------------------------
 286
 287 BackendLayerHelper::~BackendLayerHelper(void) {}
 288
 289 //------------------------------------------------------------------------------
 290
 291 rtl::OUString SAL_CALL BackendLayerHelper::
 292     getBackendLayerHelperName(void)
 293 {
 294     static const rtl::OUString kImplementationName(
 295             RTL_CONSTASCII_USTRINGPARAM(
 296                 "com.sun.star.comp.configuration.backend.LayerDescriber")) ;
 297
 298     return kImplementationName ;
 299 }
 300 //------------------------------------------------------------------------------
 301 void SAL_CALL BackendLayerHelper::describeLayer(
 302     const uno::Reference< backend::XLayerHandler >& xHandler,
 303     const uno::Sequence< backend::PropertyInfo >& aPropertyInfos )
 304         throw (lang::NullPointerException,
 305                backend::MalformedDataException,
 306                uno::RuntimeException)
 307
 308
 309
 310 {
 311     OONode aNodeTree;
 312     buildNodeTree(aPropertyInfos, *this, aNodeTree);
 313
 314     //Descirbe the Layer to the XHandler Object
 315     xHandler->startLayer();
 316     xHandler->overrideNode(aNodeTree.getName(),0,false);
 317     std::vector<IOONode*> aChildList = aNodeTree.getChildren();
 318     processChildren(aChildList,xHandler);
 319     xHandler->endNode();
 320     xHandler->endLayer();
 321
 322
 323 }
 324 //------------------------------------------------------------------------------
 325
 326 rtl::OUString SAL_CALL BackendLayerHelper::getImplementationName(void)
 327     throw (uno::RuntimeException)
 328 {
 329     return getBackendLayerHelperName() ;
 330 }
 331 //------------------------------------------------------------------------------
 332
 333 uno::Sequence<rtl::OUString> SAL_CALL BackendLayerHelper::
 334     getBackendLayerHelperServiceNames(void)
 335 {
 336     uno::Sequence<rtl::OUString> aServices(1) ;
 337     aServices[0] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.configuration.backend.LayerDescriber")) ;
 338     return aServices ;
 339 }
 340 //------------------------------------------------------------------------------
 341
 342 sal_Bool SAL_CALL BackendLayerHelper::supportsService(
 343     const rtl::OUString& aServiceName)
 344     throw (uno::RuntimeException)
 345 {
 346     uno::Sequence< rtl::OUString > const svc = getBackendLayerHelperServiceNames();
 347
 348     for(sal_Int32 i = 0; i < svc.getLength(); ++i )
 349         if(svc[i] == aServiceName)
 350             return true;
 351     return false;
 352 }
 353 //------------------------------------------------------------------------------
 354
 355 uno::Sequence<rtl::OUString>
 356 SAL_CALL BackendLayerHelper::getSupportedServiceNames(void)
 357     throw (uno::RuntimeException)
 358 {
 359     return getBackendLayerHelperServiceNames() ;
 360 }
 361 //------------------------------------------------------------------------------
 362
 363 } // backendhelper
 364 } // configmgr