sax/test/saxdemo.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 // testcomponent - Loads a service and its testcomponent from dlls performs a test.
  22 // Expands the dll-names depending on the actual environment.
  23 // Example : testcomponent com.sun.star.io.Pipe stm
  24
  25 // Therefore the testcode must exist in teststm and the testservice must be named test.com.sun.star.uno.io.Pipe
  26
  27
  28 #include <stdio.h>
  29 #include <vector>
  30 #include <cstring>
  31
  32 #include <com/sun/star/registry/XImplementationRegistration.hpp>
  33 #include <com/sun/star/lang/XComponent.hpp>
  34
  35 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  36 #include <com/sun/star/xml/sax/XParser.hpp>
  37 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  38
  39 #include <com/sun/star/io/XOutputStream.hpp>
  40 #include <com/sun/star/io/XActiveDataSource.hpp>
  41
  42 #include <cppuhelper/servicefactory.hxx>
  43 #include <cppuhelper/implbase1.hxx>
  44 #include <cppuhelper/implbase3.hxx>
  45
  46 #include <osl/diagnose.h>
  47
  48 using namespace ::std;
  49 using namespace ::cppu;
  50 using namespace ::com::sun::star::uno;
  51 using namespace ::com::sun::star::lang;
  52 using namespace ::com::sun::star::registry;
  53 using namespace ::com::sun::star::xml::sax;
  54 using namespace ::com::sun::star::io;
  55
  56
  57 /************
  58  * Sequence of bytes -> InputStream
  59  ************/
  60 class OInputStream : public WeakImplHelper1 < XInputStream >
  61 {
  62 public:
  63     OInputStream( const Sequence< sal_Int8 >&seq ) :
  64         m_seq( seq ),
  65         nPos( 0 )
  66         {}
  67
  68 public:
  69     virtual sal_Int32 SAL_CALL readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
  70         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
  71         {
  72             nBytesToRead = (nBytesToRead > m_seq.getLength() - nPos ) ?
  73                 m_seq.getLength() - nPos :
  74                 nBytesToRead;
  75             aData = Sequence< sal_Int8 > ( &(m_seq.getConstArray()[nPos]) , nBytesToRead );
  76             nPos += nBytesToRead;
  77             return nBytesToRead;
  78         }
  79     virtual sal_Int32 SAL_CALL readSomeBytes(
  80         ::com::sun::star::uno::Sequence< sal_Int8 >& aData,
  81         sal_Int32 nMaxBytesToRead )
  82         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
  83         {
  84             return readBytes( aData, nMaxBytesToRead );
  85         }
  86     virtual void SAL_CALL skipBytes( sal_Int32 /* nBytesToSkip */ )
  87         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
  88         {
  89             // not implemented
  90         }
  91     virtual sal_Int32 SAL_CALL available(  )
  92         throw(NotConnectedException, IOException, RuntimeException)
  93         {
  94             return m_seq.getLength() - nPos;
  95         }
  96     virtual void SAL_CALL closeInput(  )
  97         throw(NotConnectedException, IOException, RuntimeException)
  98         {
  99             // not needed
 100         }
 101     Sequence< sal_Int8> m_seq;
 102     sal_Int32 nPos;
 103 };
 104
 105
 106 // Helper : create an input stream from a file
 107
 108 Reference< XInputStream > createStreamFromFile(
 109     const char *pcFile )
 110 {
 111     FILE *f = fopen( pcFile , "rb" );
 112     Reference<  XInputStream >  r;
 113
 114     if( f ) {
 115         fseek( f , 0 , SEEK_END );
 116         int nLength = ftell( f );
 117         fseek( f , 0 , SEEK_SET );
 118
 119         Sequence<sal_Int8> seqIn(nLength);
 120         fread( seqIn.getArray() , nLength , 1 , f );
 121
 122         r = Reference< XInputStream > ( new OInputStream( seqIn ) );
 123         fclose( f );
 124     }
 125     return r;
 126 }
 127
 128
 129 // The document handler, which is needed for the saxparser
 130 // The Documenthandler for reading sax
 131
 132 class TestDocumentHandler :
 133     public WeakImplHelper3< XExtendedDocumentHandler , XEntityResolver , XErrorHandler >
 134 {
 135 public:
 136     TestDocumentHandler(  )
 137     {
 138     }
 139
 140 public: // Error handler
 141     virtual void SAL_CALL error(const Any& aSAXParseException) throw (SAXException, RuntimeException)
 142     {
 143         printf( "Error !\n" );
 144         throw  SAXException(
 145             OUString( "error from error handler") ,
 146             Reference < XInterface >() ,
 147             aSAXParseException );
 148     }
 149     virtual void SAL_CALL fatalError(const Any& /* aSAXParseException */) throw (SAXException, RuntimeException)
 150     {
 151         printf( "Fatal Error !\n" );
 152     }
 153     virtual void SAL_CALL warning(const Any& /* aSAXParseException */) throw (SAXException, RuntimeException)
 154     {
 155         printf( "Warning !\n" );
 156     }
 157
 158
 159 public: // ExtendedDocumentHandler
 160
 161     virtual void SAL_CALL startDocument() throw (SAXException, RuntimeException)
 162     {
 163         m_iElementCount = 0;
 164         m_iAttributeCount = 0;
 165         m_iWhitespaceCount =0;
 166         m_iCharCount=0;
 167            printf( "document started\n" );
 168     }
 169     virtual void SAL_CALL endDocument() throw (SAXException, RuntimeException)
 170     {
 171         printf( "document finished\n" );
 172         printf( "(ElementCount %d),(AttributeCount %d),(WhitespaceCount %d),(CharCount %d)\n",
 173                 m_iElementCount, m_iAttributeCount, m_iWhitespaceCount , m_iCharCount );
 174
 175     }
 176     virtual void SAL_CALL startElement(const OUString& /* aName */,
 177                               const Reference< XAttributeList > & xAttribs)
 178         throw (SAXException,RuntimeException)
 179     {
 180         m_iElementCount ++;
 181         m_iAttributeCount += xAttribs->getLength();
 182     }
 183
 184     virtual void SAL_CALL endElement(const OUString& /* aName */) throw (SAXException,RuntimeException)
 185     {
 186         // ignored
 187     }
 188
 189     virtual void SAL_CALL characters(const OUString& aChars) throw (SAXException,RuntimeException)
 190     {
 191         m_iCharCount += aChars.getLength();
 192     }
 193     virtual void SAL_CALL ignorableWhitespace(const OUString& aWhitespaces) throw (SAXException,RuntimeException)
 194     {
 195         m_iWhitespaceCount += aWhitespaces.getLength();
 196     }
 197
 198     virtual void SAL_CALL processingInstruction(const OUString& /* aTarget */, const OUString& /* aData */) throw (SAXException,RuntimeException)
 199     {
 200         // ignored
 201     }
 202
 203     virtual void SAL_CALL setDocumentLocator(const Reference< XLocator> & /* xLocator */)
 204         throw (SAXException,RuntimeException)
 205     {
 206         // ignored
 207     }
 208
 209     virtual InputSource SAL_CALL resolveEntity(
 210         const OUString& sPublicId,
 211         const OUString& sSystemId)
 212         throw (RuntimeException)
 213     {
 214         InputSource source;
 215         source.sSystemId = sSystemId;
 216         source.sPublicId = sPublicId;
 217
 218         source.aInputStream = createStreamFromFile(
 219             OUStringToOString( sSystemId, RTL_TEXTENCODING_ASCII_US).getStr() );
 220
 221         return source;
 222     }
 223
 224     virtual void SAL_CALL startCDATA() throw (SAXException,RuntimeException)
 225     {
 226     }
 227     virtual void SAL_CALL endCDATA() throw (SAXException,RuntimeException)
 228     {
 229     }
 230     virtual void SAL_CALL comment(const OUString& /* sComment */) throw (SAXException,RuntimeException)
 231     {
 232     }
 233     virtual void SAL_CALL unknown(const OUString& /* sString */) throw (SAXException,RuntimeException)
 234     {
 235     }
 236
 237     virtual void SAL_CALL allowLineBreak() throw (SAXException, RuntimeException )
 238     {
 239
 240     }
 241
 242 public:
 243     int m_iElementCount;
 244     int m_iAttributeCount;
 245     int m_iWhitespaceCount;
 246     int m_iCharCount;
 247 };
 248
 249
 250 // helper implementation for writing
 251 // implements an XAttributeList
 252
 253 struct AttributeListImpl_impl;
 254 class AttributeListImpl : public WeakImplHelper1< XAttributeList >
 255 {
 256 public:
 257     AttributeListImpl();
 258     AttributeListImpl( const AttributeListImpl & );
 259     ~AttributeListImpl();
 260
 261 public:
 262     virtual sal_Int16 SAL_CALL getLength() throw  (RuntimeException);
 263     virtual OUString SAL_CALL getNameByIndex(sal_Int16 i) throw  (RuntimeException);
 264     virtual OUString SAL_CALL getTypeByIndex(sal_Int16 i) throw  (RuntimeException);
 265     virtual OUString SAL_CALL getTypeByName(const OUString& aName) throw  (RuntimeException);
 266     virtual OUString SAL_CALL getValueByIndex(sal_Int16 i) throw  (RuntimeException);
 267     virtual OUString SAL_CALL getValueByName(const OUString& aName) throw  (RuntimeException);
 268
 269 public:
 270     void addAttribute( const OUString &sName ,
 271                        const OUString &sType ,
 272                        const OUString &sValue );
 273     void clear();
 274
 275 private:
 276     struct AttributeListImpl_impl *m_pImpl;
 277 };
 278
 279
 280 struct TagAttribute
 281 {
 282     TagAttribute(){}
 283     TagAttribute( const OUString &s_Name,
 284                   const OUString &s_Type ,
 285                   const OUString &s_Value )
 286     {
 287         this->sName     = s_Name;
 288         this->sType     = s_Type;
 289         this->sValue    = s_Value;
 290     }
 291
 292     OUString sName;
 293     OUString sType;
 294     OUString sValue;
 295 };
 296
 297 struct AttributeListImpl_impl
 298 {
 299     AttributeListImpl_impl()
 300     {
 301         // performance improvement during adding
 302         vecAttribute.reserve(20);
 303     }
 304     vector<struct TagAttribute> vecAttribute;
 305 };
 306
 307
 308
 309 sal_Int16 AttributeListImpl::getLength() throw  (RuntimeException)
 310 {
 311     return (sal_Int16) m_pImpl->vecAttribute.size();
 312 }
 313
 314
 315 AttributeListImpl::AttributeListImpl( const AttributeListImpl &r )
 316 {
 317     m_pImpl = new AttributeListImpl_impl;
 318     *m_pImpl = *(r.m_pImpl);
 319 }
 320
 321 OUString AttributeListImpl::getNameByIndex(sal_Int16 i) throw  (RuntimeException)
 322 {
 323     if( i < sal::static_int_cast<sal_Int16>(m_pImpl->vecAttribute.size()) ) {
 324         return m_pImpl->vecAttribute[i].sName;
 325     }
 326     return OUString();
 327 }
 328
 329
 330 OUString AttributeListImpl::getTypeByIndex(sal_Int16 i) throw  (RuntimeException)
 331 {
 332     if( i < sal::static_int_cast<sal_Int16>(m_pImpl->vecAttribute.size()) ) {
 333         return m_pImpl->vecAttribute[i].sType;
 334     }
 335     return OUString();
 336 }
 337
 338 OUString AttributeListImpl::getValueByIndex(sal_Int16 i) throw  (RuntimeException)
 339 {
 340     if( i < sal::static_int_cast<sal_Int16>(m_pImpl->vecAttribute.size()) ) {
 341         return m_pImpl->vecAttribute[i].sValue;
 342     }
 343     return OUString();
 344
 345 }
 346
 347 OUString AttributeListImpl::getTypeByName( const OUString& sName ) throw  (RuntimeException)
 348 {
 349     vector<struct TagAttribute>::iterator ii = m_pImpl->vecAttribute.begin();
 350
 351     for( ; ii != m_pImpl->vecAttribute.end() ; ++ii ) {
 352         if( (*ii).sName == sName ) {
 353             return (*ii).sType;
 354         }
 355     }
 356     return OUString();
 357 }
 358
 359 OUString AttributeListImpl::getValueByName(const OUString& sName) throw  (RuntimeException)
 360 {
 361     vector<struct TagAttribute>::iterator ii = m_pImpl->vecAttribute.begin();
 362
 363     for( ; ii != m_pImpl->vecAttribute.end() ; ++ii ) {
 364         if( (*ii).sName == sName ) {
 365             return (*ii).sValue;
 366         }
 367     }
 368     return OUString();
 369 }
 370
 371
 372
 373 AttributeListImpl::AttributeListImpl()
 374 {
 375     m_pImpl = new AttributeListImpl_impl;
 376 }
 377
 378
 379
 380 AttributeListImpl::~AttributeListImpl()
 381 {
 382     delete m_pImpl;
 383 }
 384
 385
 386 void AttributeListImpl::addAttribute(   const OUString &sName ,
 387                                         const OUString &sType ,
 388                                         const OUString &sValue )
 389 {
 390     m_pImpl->vecAttribute.push_back( TagAttribute( sName , sType , sValue ) );
 391 }
 392
 393 void AttributeListImpl::clear()
 394 {
 395     m_pImpl->vecAttribute.clear();
 396 }
 397
 398
 399
 400 // helper function for writing
 401 // ensures that linebreaks are inserted
 402 // when writing a long text.
 403 // Note: this implementation may be a bit slow,
 404 // but it shows, how the SAX-Writer handles the allowLineBreak calls.
 405
 406 void writeParagraphHelper(
 407     const  Reference< XExtendedDocumentHandler > &r ,
 408     const OUString & s)
 409 {
 410     int nMax = s.getLength();
 411     int nStart = 0;
 412     int n = 1;
 413
 414     Sequence<sal_uInt16> seq( s.getLength() );
 415     memcpy( seq.getArray() , s.getStr() , s.getLength() * sizeof( sal_uInt16 ) );
 416
 417     for( n = 1 ; n < nMax ; n++ ){
 418         if( 32 == seq.getArray()[n] ) {
 419             r->allowLineBreak();
 420             r->characters( s.copy( nStart , n - nStart ) );
 421             nStart = n;
 422         }
 423     }
 424     r->allowLineBreak();
 425     r->characters( s.copy( nStart , n - nStart ) );
 426 }
 427
 428
 429
 430 // helper implementation for SAX-Writer
 431 // writes data to a file
 432
 433 class OFileWriter :
 434         public WeakImplHelper1< XOutputStream >
 435 {
 436 public:
 437     OFileWriter( char *pcFile ) { strncpy( m_pcFile , pcFile, 256 - 1 ); m_f = 0; }
 438
 439
 440 public:
 441     virtual void SAL_CALL writeBytes(const Sequence< sal_Int8 >& aData)
 442         throw  (NotConnectedException, BufferSizeExceededException, RuntimeException);
 443     virtual void SAL_CALL flush()
 444         throw  (NotConnectedException, BufferSizeExceededException, RuntimeException);
 445     virtual void SAL_CALL closeOutput()
 446         throw  (NotConnectedException, BufferSizeExceededException, RuntimeException);
 447 private:
 448     char m_pcFile[256];
 449     FILE *m_f;
 450 };
 451
 452
 453 void OFileWriter::writeBytes(const Sequence< sal_Int8 >& aData)
 454     throw  (NotConnectedException, BufferSizeExceededException, RuntimeException)
 455 {
 456     if( ! m_f ) {
 457         m_f = fopen( m_pcFile , "w" );
 458     }
 459
 460     fwrite( aData.getConstArray() , 1 , aData.getLength() , m_f );
 461 }
 462
 463
 464 void OFileWriter::flush()
 465     throw  (NotConnectedException, BufferSizeExceededException, RuntimeException)
 466 {
 467     fflush( m_f );
 468 }
 469
 470 void OFileWriter::closeOutput()
 471     throw  (NotConnectedException, BufferSizeExceededException, RuntimeException)
 472 {
 473     fclose( m_f );
 474     m_f = 0;
 475 }
 476
 477
 478
 479 // Needed to switch on solaris threads
 480 #ifdef SOLARIS
 481 extern "C" void ChangeGlobalInit();
 482 #endif
 483 int main (int argc, char **argv)
 484 {
 485
 486     if( argc < 3) {
 487         printf( "usage : saxdemo inputfile outputfile\n" );
 488         exit( 0 );
 489     }
 490 #ifdef SOLARIS
 491     // switch on threads in solaris
 492     ChangeGlobalInit();
 493 #endif
 494
 495     // create service manager
 496     Reference< XMultiServiceFactory > xSMgr = createRegistryServiceFactory(
 497         OUString(  "applicat.rdb" ) );
 498
 499     Reference < XImplementationRegistration > xReg;
 500     try
 501     {
 502         // Create registration service
 503         Reference < XInterface > x = xSMgr->createInstance(
 504             OUString("com.sun.star.registry.ImplementationRegistration") );
 505         xReg = Reference<  XImplementationRegistration > ( x , UNO_QUERY );
 506     }
 507     catch( Exception & ) {
 508         printf( "Couldn't create ImplementationRegistration service\n" );
 509         exit(1);
 510     }
 511
 512     OString sTestName;
 513     try
 514     {
 515         // Load dll for the tested component
 516         OUString aDllName( "sax.uno" SAL_DLLEXTENSION );
 517         xReg->registerImplementation(
 518             OUString("com.sun.star.loader.SharedLibrary"),
 519             aDllName,
 520             Reference< XSimpleRegistry > ()  );
 521     }
 522     catch( Exception &e ) {
 523         printf( "Couldn't reach sax dll\n" );
 524         printf( "%s\n" , OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US ).getStr() );
 525
 526         exit(1);
 527     }
 528
 529
 530
 531     // parser demo
 532     // read xml from a file and count elements
 533
 534     Reference< XInterface > x = xSMgr->createInstance(
 535         OUString("com.sun.star.xml.sax.Parser") );
 536     if( x.is() )
 537     {
 538         Reference< XParser > rParser( x , UNO_QUERY );
 539
 540         // create and connect the document handler to the parser
 541         TestDocumentHandler *pDocHandler = new TestDocumentHandler( );
 542
 543         Reference < XDocumentHandler >  rDocHandler( (XDocumentHandler *) pDocHandler );
 544         Reference< XEntityResolver > rEntityResolver( (XEntityResolver *) pDocHandler );
 545
 546         rParser->setDocumentHandler( rDocHandler );
 547         rParser->setEntityResolver( rEntityResolver );
 548
 549         // create the input stream
 550         InputSource source;
 551         source.aInputStream = createStreamFromFile( argv[1] );
 552         source.sSystemId    = OUString::createFromAscii( argv[1] );
 553
 554         try
 555         {
 556             // start parsing
 557             rParser->parseStream( source );
 558         }
 559
 560         catch( Exception & e )
 561         {
 562             OString o1 = OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8 );
 563             printf( "Exception during parsing : %s\n" ,  o1.getStr() );
 564         }
 565     }
 566     else
 567     {
 568         printf( "couldn't create sax-parser component\n" );
 569     }
 570
 571
 572
 573     // The SAX-Writer demo
 574
 575     x= xSMgr->createInstance("com.sun.star.xml.sax.Writer");
 576     if( x.is() )
 577     {
 578         printf( "start writing to %s\n" , argv[2] );
 579
 580         OFileWriter *pw = new OFileWriter( argv[2] );
 581         Reference< XActiveDataSource > source( x , UNO_QUERY );
 582         source->setOutputStream( Reference< XOutputStream> ( (XOutputStream*) pw ) );
 583
 584         AttributeListImpl *pList = new AttributeListImpl;
 585         Reference< XAttributeList > rList( (XAttributeList *) pList );
 586
 587         Reference< XExtendedDocumentHandler > r( x , UNO_QUERY );
 588         r->startDocument();
 589
 590         pList->addAttribute( OUString( "Arg1" ),
 591                              OUString( "CDATA") ,
 592                              OUString( "foo\n   u") );
 593         pList->addAttribute( OUString( "Arg2") ,
 594                              OUString( "CDATA") ,
 595                              OUString( "foo2") );
 596
 597         r->startElement( OUString( "tag1")  , rList );
 598         // tells the writer to insert a linefeed
 599         r->ignorableWhitespace( OUString() );
 600
 601         r->characters( OUString( "huhu") );
 602         r->ignorableWhitespace( OUString() );
 603
 604         r->startElement( OUString( "hi") , rList );
 605         r->ignorableWhitespace( OUString() );
 606
 607         // the enpassant must be converted & -> &amp;
 608         r->characters( OUString( "&#252;") );
 609         r->ignorableWhitespace( OUString() );
 610
 611         // '>' must not be converted
 612         r->startCDATA();
 613         r->characters( OUString( " > foo < ")  );
 614         r->endCDATA();
 615         r->ignorableWhitespace( OUString() );
 616
 617         OUString testParagraph = OUString(
 618             "This is only a test to check, if the writer inserts line feeds "
 619             "if needed or if the writer puts the whole text into one line." );
 620         writeParagraphHelper( r , testParagraph );
 621
 622         r->ignorableWhitespace( OUString() );
 623         r->comment( OUString( "This is a comment !") );
 624         r->ignorableWhitespace( OUString() );
 625
 626         r->startElement( OUString( "emptytagtest")  , rList );
 627         r->endElement( OUString( "emptytagtest") );
 628         r->ignorableWhitespace( OUString() );
 629
 630         r->endElement( OUString( "hi") );
 631         r->ignorableWhitespace( OUString() );
 632
 633         r->endElement( OUString( "tag1") );
 634         r->endDocument();
 635
 636         printf( "finished writing\n" );
 637     }
 638     else
 639     {
 640         printf( "couldn't create sax-writer component\n" );
 641     }
 642 }
 643
 644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */