configmgr/workben/local_io/xmlimport.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: xmlimport.cxx,v $
  10  * $Revision: 1.7 $
  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 <memory>
  35 #include <vector>
  36 #include <stack>
  37 #include<osl/file.hxx>
  38
  39 #include <rtl/ustring.hxx>
  40 #include <com/sun/star/uno/Sequence.hxx>
  41 #include <com/sun/star/uno/Any.hxx>
  42 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  43 #include <cppuhelper/implbase1.hxx>
  44 #include <cppuhelper/implbase2.hxx>
  45 #include <cppuhelper/servicefactory.hxx>
  46
  47 #ifndef _COM_SUN_STAR_LANG_XCOMPONENT_HDL_
  48 #include <com/sun/star/lang/XComponent.hpp>
  49 #endif
  50 #ifndef _COM_SUN_STAR_IO_XACTIVEDATASOURCE_HDL_
  51 #include <com/sun/star/io/XActiveDataSource.hpp>
  52 #endif
  53 #ifndef _COM_SUN_STAR_IO_XACTIVEDATASINK_HDL_
  54 #include <com/sun/star/io/XActiveDataSink.hpp>
  55 #endif
  56 #ifndef _COM_SUN_STAR_IO_XACTIVEDATACONTROL_HDL_
  57 #include <com/sun/star/io/XActiveDataControl.hpp>
  58 #endif
  59 #ifndef _COM_SUN_STAR_IO_XDATATRANSFEREVENTLISTENER_HDL_
  60 #include <com/sun/star/io/XDataTransferEventListener.hpp>
  61 #endif
  62 #ifndef _COM_SUN_STAR_IO_XDATAIMPORTER_HDL_
  63 #include <com/sun/star/io/XDataImporter.hpp>
  64 #endif
  65
  66 #ifndef _COM_SUN_STAR_IO_XINPUTSTREAM_HDL_
  67 #include <com/sun/star/io/XInputStream.hpp>
  68 #endif
  69 #include <com/sun/star/xml/sax/XParser.hpp>
  70 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  71 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  72
  73 #include <com/sun/star/xml/sax/InputSource.hpp>
  74 #include <vos/thread.hxx>
  75
  76 #include <vos/pipe.hxx>
  77 #include <osl/diagnose.h>
  78 #include "oslstream.hxx"
  79 #include <com/sun/star/xml/sax/XAttributeList.hpp>
  80
  81 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  82 #include <com/sun/star/container/XNameAccess.hpp>
  83 #include <com/sun/star/container/XHierarchicalName.hpp>
  84
  85 #include <com/sun/star/container/XNameReplace.hpp>
  86 #include <com/sun/star/util/XChangesBatch.hpp>
  87 #include <com/sun/star/script/XTypeConverter.hpp>
  88 #include <com/sun/star/container/XNameContainer.hpp>
  89 #include <osl/conditn.hxx>
  90
  91 #include "xmltreebuilder.hxx"
  92
  93 #include "dataimport.hxx"
  94
  95 #include "createpropertyvalue.hxx"
  96 // -----------------------------------------------------------------------------
  97 // --------------------------------- namespaces ---------------------------------
  98 // -----------------------------------------------------------------------------
  99 namespace uno = com::sun::star::uno;
 100 namespace lang = com::sun::star::lang;
 101 namespace io = com::sun::star::io;
 102 namespace sax = com::sun::star::xml::sax;
 103 namespace script = com::sun::star::script;
 104
 105 using ::rtl::OUString;
 106 using ::osl::File;
 107
 108 using namespace ::com::sun::star::uno;
 109 using namespace ::com::sun::star::lang;
 110 using namespace ::com::sun::star::container;
 111 using namespace ::com::sun::star::util;
 112
 113 // -----------------------------------------------------------------------------
 114 // ---------------------------------- defines ----------------------------------
 115 // -----------------------------------------------------------------------------
 116 #ifndef ASCII
 117 #define ASCII(x) OUString::createFromAscii(x)
 118 #endif
 119
 120
 121 // -----------------------------------------------------------------------------
 122 // ---------------------------------- a Class ----------------------------------
 123 // -----------------------------------------------------------------------------
 124 // <Name a="xyz" b="bar">
 125
 126 //==========================================================================
 127 //= Visitors
 128 //==========================================================================
 129
 130
 131 // -----------------------------------------------------------------------------
 132 class Listener : public ::cppu::WeakImplHelper1<io::XDataTransferEventListener>
 133 {
 134     osl::Condition m_aCondition;
 135 public:
 136     Listener()
 137         {
 138             m_aCondition.reset();                                // will block
 139         }
 140
 141     virtual void SAL_CALL disposing( const lang::EventObject& Source )
 142         throw(::com::sun::star::uno::RuntimeException)
 143         {
 144             OSL_ENSURE(0, "disposing");
 145             m_aCondition.set();                          // will not block
 146         }
 147
 148     virtual void SAL_CALL finished( const io::DataTransferEvent& aEvent )
 149         throw(uno::RuntimeException)
 150         {
 151             OSL_ENSURE(0, "finished");
 152             m_aCondition.set();                          // will not block
 153         }
 154
 155     virtual void SAL_CALL cancelled( const io::DataTransferEvent& aEvent )
 156         throw(uno::RuntimeException)
 157         {
 158             OSL_ENSURE(0, "cancelled");
 159             m_aCondition.set();                          // will not block
 160         }
 161 public:
 162     void wait()
 163         {
 164             m_aCondition.wait();
 165         }
 166 };
 167
 168 class Component: public ::cppu::WeakImplHelper1<lang::XComponent>
 169 {
 170     virtual void SAL_CALL dispose(  )
 171         throw(uno::RuntimeException)
 172         {
 173             OSL_ENSURE(0, "dispose");
 174
 175         }
 176     virtual void SAL_CALL addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 177         throw(uno::RuntimeException)
 178         {
 179             OSL_ENSURE(0, "addEventListener");
 180         }
 181     virtual void SAL_CALL removeEventListener( const uno::Reference< lang::XEventListener >& aListener )
 182         throw(uno::RuntimeException)
 183         {
 184             OSL_ENSURE(0, "removeEventListener");
 185         }
 186 };
 187
 188
 189
 190 namespace configmgr
 191 {
 192
 193 // -----------------------------------------------------------------------------
 194 // ------------------------------------ Test ------------------------------------
 195 // -----------------------------------------------------------------------------
 196 #define ASCII_STRING(rtlOUString)       rtl::OUStringToOString(rtlOUString, RTL_TEXTENCODING_ASCII_US).getStr()
 197     static ::rtl::OUString      sRegistry = ::rtl::OUString::createFromAscii("applicat.rdb");
 198
 199     void importTest()
 200     {
 201         uno::Reference< lang::XMultiServiceFactory > xMSF;
 202         try
 203         {
 204             xMSF = cppu::createRegistryServiceFactory(sRegistry, ::rtl::OUString());
 205         }
 206         catch (uno::Exception& e)
 207         {
 208             cout << "could not bootstrap the services from " << ASCII_STRING(sRegistry) << endl ;
 209             cout << "    (error message : " << ASCII_STRING(e.Message) << ")" << endl;
 210         }
 211
 212         if (!xMSF.is())
 213         {
 214             cerr << "could not create the service factory !" << endl;
 215             return;
 216         }
 217
 218         OUString aPath = ASCII("l:/SRC601/configmgr/workben/local_io");
 219         OUString aFilename = ASCII("hierarchy");
 220         OUString aExtension = ASCII("xml");
 221
 222         OUString aFullname = aPath + ASCII("/") + aFilename + ASCII(".") + aExtension;
 223
 224         // Filename convertieren
 225         OUString aURL;
 226         File aConvert(ASCII(""));
 227         aConvert.normalizePath(aFullname, aURL);
 228
 229         // File oeffnen
 230         File aFile(aURL);
 231         aFile.open(osl_File_OpenFlag_Read);
 232
 233         // sal_uInt64 nBytesRead;
 234         // uno::Sequence< sal_Int8 > aBufferSeq(2000);
 235         // sal_Int8 *pBuff = aBufferSeq.getArray();
 236         // aFile.read(pBuff, 2000, nBytesRead);
 237         //
 238         // aFile.close();
 239
 240         uno::Reference<io::XInputStream> xInputStream = new configmgr::OSLInputStreamWrapper(aFile);
 241
 242         uno::Reference <uno::XInterface> xPump = xMSF->createInstance( L"com.sun.star.io.Pump" );
 243         OSL_ENSURE(xPump.is(), "there is no pump");
 244
 245         uno::Reference<io::XActiveDataSink> xPumpSink(xPump, uno::UNO_QUERY);
 246         xPumpSink->setInputStream(xInputStream);
 247
 248         uno::Reference<io::XActiveDataSource> xPumpSource(xPump, uno::UNO_QUERY);
 249
 250         Listener *pListener = new Listener();
 251         uno::Reference<io::XDataTransferEventListener>  rListener = pListener;
 252         uno::Reference<lang::XComponent> rComponent = new Component();
 253
 254         // Create a TypeConverter
 255         uno::Reference<script::XTypeConverter> aConverter;
 256         aConverter = aConverter.query(xMSF->createInstance(ASCII( "com.sun.star.script.Converter" )) );
 257
 258         Sequence< uno::Any > aArgs(1);                   // optional arg.
 259         aArgs[0] <<= configmgr::createPropertyValue(ASCII("TypeConverter"), aConverter);
 260
 261         Reference< XInterface > xDataImport = xMSF->createInstanceWithArguments(
 262             OUString::createFromAscii("com.sun.star.configuration.DataImport"),
 263             aArgs);
 264
 265         if (xDataImport.is())
 266         {
 267             uno::Reference<io::XDataImporter>  rImporter(xDataImport, UNO_QUERY);
 268
 269             // Import Data
 270             rImporter->importData(xPumpSource, rComponent, rListener);
 271
 272             // lets pump
 273             uno::Reference<io::XActiveDataControl> xControl(xPump, uno::UNO_QUERY);
 274             xControl->start();
 275
 276             // TEST:
 277             // rImporter->cancel();
 278
 279             // pImporter->wait();
 280             // Wait until the listener send ready
 281             pListener->wait();
 282         }
 283         return;
 284     }
 285
 286 // -----------------------------------------------------------------------------
 287 // -------------------------------- Import Test --------------------------------
 288 // -----------------------------------------------------------------------------
 289
 290     // ----------- TEST ReadAccess -----------
 291     void showSequence(const Sequence<OUString> &aSeq);
 292
 293 void hierarchyTest()
 294 {
 295
 296     uno::Reference< lang::XMultiServiceFactory > xMSF;
 297     try
 298     {
 299         xMSF = cppu::createRegistryServiceFactory(sRegistry, ::rtl::OUString());
 300     }
 301     catch (uno::Exception& e)
 302     {
 303         cout << "could not bootstrap the services from " << ASCII_STRING(sRegistry) << endl ;
 304         cout << "    (error message : " << ASCII_STRING(e.Message) << ")" << endl;
 305     }
 306
 307     if (!xMSF.is())
 308     {
 309         cerr << "could not create the service factory !" << endl;
 310         return;
 311     }
 312
 313
 314     Reference< XMultiServiceFactory > xCfgProvider( xMSF->createInstance(
 315         ::rtl::OUString::createFromAscii("com.sun.star.configuration.ConfigurationProvider")),
 316                                                     UNO_QUERY);
 317
 318     if (!xCfgProvider.is())
 319     {
 320         OSL_ENSURE(0, "No Configuration Provider");
 321     }
 322
 323     OUString sPath = ASCII("com.sun.star.ucb.Hierarchy");
 324
 325     Sequence< Any > aArgs(1);
 326     aArgs[0] <<= sPath;
 327
 328     Reference< XInterface > xCfgUpdt = xCfgProvider->createInstanceWithArguments(
 329         OUString::createFromAscii("com.sun.star.configuration.ConfigurationUpdateAccess"),
 330         aArgs);
 331
 332     Reference< XNameAccess > xNameAccess(xCfgUpdt, UNO_QUERY);
 333
 334     // which Names are exist?
 335     showSequence(xNameAccess->getElementNames());
 336
 337     OUString aNamePath = ASCII("Root");
 338     if (xNameAccess->hasByName(aNamePath))
 339     {
 340         Any aAny;
 341         aAny = xNameAccess->getByName(aNamePath);
 342         TypeClass aTypeClass = aAny.getValueTypeClass();
 343         if (aAny.getValueTypeClass() == TypeClass_INTERFACE)
 344         {
 345             Reference< XInterface > xInterface;
 346             aAny >>= xInterface;
 347             Reference< XNameAccess > xNameAccess2(xInterface, UNO_QUERY);
 348             if (xNameAccess.is())
 349             {
 350                 Sequence<OUString> aSeq = xNameAccess2->getElementNames();
 351                 showSequence(aSeq);
 352
 353                 // insert a new set
 354 /*
 355                 Reference<XHierarchicalName> xHierarchical(xNameAccess, UNO_QUERY);
 356                 OUString aHierachicalName = xHierarchical->getHierarchicalName();
 357
 358                 Sequence< Any > aArgs(2);
 359                 aArgs[0] <<= aHierachicalName;
 360                 sal_Int32 nLevels=1;
 361                 aArgs[1] <<= nLevels;
 362
 363                 Reference< XInterface > xCfgNewUpdt = xCfgProvider->createInstanceWithArguments(
 364                     OUString::createFromAscii("com.sun.star.configuration.ConfigurationUpdateAccess"),
 365                     aArgs);
 366 */
 367                 Reference< lang::XSingleServiceFactory > xChildFactory(xNameAccess2, UNO_QUERY);
 368                 if (xChildFactory.is())
 369                 {
 370                     Reference< XInterface > xChild = xChildFactory->createInstance();
 371                     if (xChild.is())
 372                     {
 373                         Reference<XNameAccess> xObjectOnTheMedow(xChild, UNO_QUERY);
 374
 375
 376
 377
 378                         // which Names are exist?
 379                         showSequence(xObjectOnTheMedow->getElementNames());
 380
 381                         OUString aChildren = ASCII("Children");
 382                         if (xObjectOnTheMedow->hasByName(aChildren))
 383                         {
 384                             Any aAny;
 385                             aAny = xObjectOnTheMedow->getByName(aChildren);
 386                             TypeClass aTypeClass = aAny.getValueTypeClass();
 387                             if (aAny.getValueTypeClass() == TypeClass_INTERFACE)
 388                             {
 389                                 Reference< XInterface > xInterface;
 390                                 aAny >>= xInterface;
 391                                 Reference< XNameAccess > xChildFromOOM(xInterface, UNO_QUERY);
 392
 393                                 if (xChildFromOOM.is())
 394                                 {
 395                                     // insert a new Object in the new Object
 396
 397                                     Reference< lang::XSingleServiceFactory > xChildFactory(xChildFromOOM, UNO_QUERY);
 398                                     if (xChildFactory.is())
 399                                     {
 400                                         Reference< XInterface > xChild = xChildFactory->createInstance();
 401                                         if (xChild.is())
 402                                         {
 403                                             Reference<XNameContainer> xNameContainer(xChildFromOOM, UNO_QUERY);
 404                                             if (xNameContainer.is())
 405                                             {
 406                                                 xNameContainer->insertByName(ASCII("Test2"), makeAny(xChild));
 407                                             }
 408                                         }
 409                                     }
 410                                 }
 411                             }
 412                         }
 413
 414
 415                         Reference<XNameContainer> xNameContainer(xNameAccess2, UNO_QUERY);
 416                         if (xNameContainer.is())
 417                         {
 418                             xNameContainer->insertByName(ASCII("Test"), makeAny(xObjectOnTheMedow));
 419                         }
 420                     }
 421
 422                     // commit changes
 423                     Reference< XChangesBatch > xChangesBatch(xCfgUpdt, UNO_QUERY);
 424                     if (xChangesBatch.is())
 425                     {
 426                         xChangesBatch->commitChanges();
 427                     }
 428                 }
 429
 430                 Sequence<OUString> aSeq2 = xNameAccess2->getElementNames();
 431                 showSequence(aSeq2);
 432
 433 /*
 434                 OUString *pStr = aSeq.getArray();
 435                 for (int i=0;i<aSeq.getLength();i++)
 436                 {
 437                     OUString aStr = pStr[i];
 438                     Any aAny;
 439                     aAny = xNameAccess->getByName(aStr);
 440                     TypeClass aTypeClass = aAny.getValueTypeClass();
 441
 442                     Reference< XNameReplace > xNameReplace(xNameAccess, UNO_QUERY);
 443
 444                     Any aNewAny;
 445                     sal_Bool bValue = false;
 446                     aNewAny <<= bValue;
 447                     xNameReplace->replaceByName(aStr, aNewAny);
 448
 449                     volatile int dummy = 0;
 450                 }
 451 */
 452             }
 453         }
 454         volatile int dummy = 0;
 455     }
 456 }
 457
 458 // ------------------------------ Helperfunctions ------------------------------
 459
 460     void showSequence(const Sequence<OUString> &aSeq)
 461     {
 462         OUString aArray;
 463         const OUString *pStr = aSeq.getConstArray();
 464         for (int i=0;i<aSeq.getLength();i++)
 465         {
 466             OUString aStr = pStr[i];
 467             aArray += aStr + ASCII(", ");
 468         }
 469         volatile int dummy = 0;
 470     }
 471
 472 } // namespace configmgr