sccomp/source/solver/solver.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: solver.cxx,v $
  10  * $Revision: 1.3 $
  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 #undef LANGUAGE_NONE
  32 #define WINAPI __stdcall
  33 #define LoadInverseLib FALSE
  34 #define LoadLanguageLib FALSE
  35 #include <lpsolve/lp_lib.h>
  36 #undef LANGUAGE_NONE
  37
  38 #include "solver.hxx"
  39 #include "solver.hrc"
  40
  41 #include <com/sun/star/beans/XPropertySet.hpp>
  42 #include <com/sun/star/container/XIndexAccess.hpp>
  43 #include <com/sun/star/frame/XModel.hpp>
  44 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  45 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  46 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  47 #include <com/sun/star/table/CellAddress.hpp>
  48 #include <com/sun/star/table/CellRangeAddress.hpp>
  49 #include <com/sun/star/text/XTextRange.hpp>
  50
  51 #include <rtl/math.hxx>
  52 #include <rtl/ustrbuf.hxx>
  53 #include <cppuhelper/factory.hxx>
  54 #include <vector>
  55 #include <hash_map>
  56
  57 #include <tools/resmgr.hxx>
  58
  59 using namespace com::sun::star;
  60
  61 using ::rtl::OUString;
  62
  63 #define C2U(constAsciiStr) (::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( constAsciiStr ) ))
  64
  65 #define STR_NONNEGATIVE   "NonNegative"
  66 #define STR_INTEGER       "Integer"
  67 #define STR_TIMEOUT       "Timeout"
  68 #define STR_EPSILONLEVEL  "EpsilonLevel"
  69 #define STR_LIMITBBDEPTH  "LimitBBDepth"
  70
  71 // -----------------------------------------------------------------------
  72 //  Resources from tools are used for translated strings
  73
  74 static ResMgr* pSolverResMgr = NULL;
  75
  76 OUString lcl_GetResourceString( sal_uInt32 nId )
  77 {
  78     if (!pSolverResMgr)
  79         pSolverResMgr = CREATEVERSIONRESMGR( solver );
  80
  81     return String( ResId( nId, *pSolverResMgr ) );
  82 }
  83
  84 // -----------------------------------------------------------------------
  85
  86 namespace
  87 {
  88     enum
  89     {
  90         PROP_NONNEGATIVE,
  91         PROP_INTEGER,
  92         PROP_TIMEOUT,
  93         PROP_EPSILONLEVEL,
  94         PROP_LIMITBBDEPTH
  95     };
  96 }
  97
  98 // -----------------------------------------------------------------------
  99
 100 // hash map for the coefficients of a dependent cell (objective or constraint)
 101 // The size of each vector is the number of columns (variable cells) plus one, first entry is initial value.
 102
 103 struct ScSolverCellHash
 104 {
 105     size_t operator()( const table::CellAddress& rAddress ) const
 106     {
 107         return ( rAddress.Sheet << 24 ) | ( rAddress.Column << 16 ) | rAddress.Row;
 108     }
 109 };
 110
 111 inline bool AddressEqual( const table::CellAddress& rAddr1, const table::CellAddress& rAddr2 )
 112 {
 113     return rAddr1.Sheet == rAddr2.Sheet && rAddr1.Column == rAddr2.Column && rAddr1.Row == rAddr2.Row;
 114 }
 115
 116 struct ScSolverCellEqual
 117 {
 118     bool operator()( const table::CellAddress& rAddr1, const table::CellAddress& rAddr2 ) const
 119     {
 120         return AddressEqual( rAddr1, rAddr2 );
 121     }
 122 };
 123
 124 typedef std::hash_map< table::CellAddress, std::vector<double>, ScSolverCellHash, ScSolverCellEqual > ScSolverCellHashMap;
 125
 126 // -----------------------------------------------------------------------
 127
 128 uno::Reference<table::XCell> lcl_GetCell( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
 129                                           const table::CellAddress& rPos )
 130 {
 131     uno::Reference<container::XIndexAccess> xSheets( xDoc->getSheets(), uno::UNO_QUERY );
 132     uno::Reference<sheet::XSpreadsheet> xSheet( xSheets->getByIndex( rPos.Sheet ), uno::UNO_QUERY );
 133     return xSheet->getCellByPosition( rPos.Column, rPos.Row );
 134 }
 135
 136 void lcl_SetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
 137                    const table::CellAddress& rPos, double fValue )
 138 {
 139     lcl_GetCell( xDoc, rPos )->setValue( fValue );
 140 }
 141
 142 double lcl_GetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
 143                      const table::CellAddress& rPos )
 144 {
 145     return lcl_GetCell( xDoc, rPos )->getValue();
 146 }
 147
 148 // -------------------------------------------------------------------------
 149
 150 SolverComponent::SolverComponent( const uno::Reference<uno::XComponentContext>& /* rSMgr */ ) :
 151     OPropertyContainer( GetBroadcastHelper() ),
 152     mbMaximize( sal_True ),
 153     mbNonNegative( sal_False ),
 154     mbInteger( sal_False ),
 155     mnTimeout( 100 ),
 156     mnEpsilonLevel( 0 ),
 157     mbLimitBBDepth( sal_True ),
 158     mbSuccess( sal_False ),
 159     mfResultValue( 0.0 )
 160 {
 161     // for XPropertySet implementation:
 162     registerProperty( C2U(STR_NONNEGATIVE),  PROP_NONNEGATIVE,  0, &mbNonNegative,  getCppuType( &mbNonNegative )  );
 163     registerProperty( C2U(STR_INTEGER),      PROP_INTEGER,      0, &mbInteger,      getCppuType( &mbInteger )      );
 164     registerProperty( C2U(STR_TIMEOUT),      PROP_TIMEOUT,      0, &mnTimeout,      getCppuType( &mnTimeout )      );
 165     registerProperty( C2U(STR_EPSILONLEVEL), PROP_EPSILONLEVEL, 0, &mnEpsilonLevel, getCppuType( &mnEpsilonLevel ) );
 166     registerProperty( C2U(STR_LIMITBBDEPTH), PROP_LIMITBBDEPTH, 0, &mbLimitBBDepth, getCppuType( &mbLimitBBDepth ) );
 167 }
 168
 169 SolverComponent::~SolverComponent()
 170 {
 171 }
 172
 173 IMPLEMENT_FORWARD_XINTERFACE2( SolverComponent, SolverComponent_Base, OPropertyContainer )
 174 IMPLEMENT_FORWARD_XTYPEPROVIDER2( SolverComponent, SolverComponent_Base, OPropertyContainer )
 175
 176 cppu::IPropertyArrayHelper* SolverComponent::createArrayHelper() const
 177 {
 178     uno::Sequence<beans::Property> aProps;
 179     describeProperties( aProps );
 180     return new cppu::OPropertyArrayHelper( aProps );
 181 }
 182
 183 cppu::IPropertyArrayHelper& SAL_CALL SolverComponent::getInfoHelper()
 184 {
 185     return *getArrayHelper();
 186 }
 187
 188 uno::Reference<beans::XPropertySetInfo> SAL_CALL SolverComponent::getPropertySetInfo() throw(uno::RuntimeException)
 189 {
 190     return createPropertySetInfo( getInfoHelper() );
 191 }
 192
 193 // XSolverDescription
 194
 195 OUString SAL_CALL SolverComponent::getComponentDescription() throw (uno::RuntimeException)
 196 {
 197     return lcl_GetResourceString( RID_SOLVER_COMPONENT );
 198 }
 199
 200 OUString SAL_CALL SolverComponent::getStatusDescription() throw (uno::RuntimeException)
 201 {
 202     return maStatus;
 203 }
 204
 205 OUString SAL_CALL SolverComponent::getPropertyDescription( const OUString& rPropertyName ) throw (uno::RuntimeException)
 206 {
 207     sal_uInt32 nResId = 0;
 208     sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
 209     switch (nHandle)
 210     {
 211         case PROP_NONNEGATIVE:
 212             nResId = RID_PROPERTY_NONNEGATIVE;
 213             break;
 214         case PROP_INTEGER:
 215             nResId = RID_PROPERTY_INTEGER;
 216             break;
 217         case PROP_TIMEOUT:
 218             nResId = RID_PROPERTY_TIMEOUT;
 219             break;
 220         case PROP_EPSILONLEVEL:
 221             nResId = RID_PROPERTY_EPSILONLEVEL;
 222             break;
 223         case PROP_LIMITBBDEPTH:
 224             nResId = RID_PROPERTY_LIMITBBDEPTH;
 225             break;
 226         default:
 227             {
 228                 // unknown - leave empty
 229             }
 230     }
 231     OUString aRet;
 232     if ( nResId )
 233         aRet = lcl_GetResourceString( nResId );
 234     return aRet;
 235 }
 236
 237 // XSolver: settings
 238
 239 uno::Reference<sheet::XSpreadsheetDocument> SAL_CALL SolverComponent::getDocument() throw(uno::RuntimeException)
 240 {
 241     return mxDoc;
 242 }
 243
 244 void SAL_CALL SolverComponent::setDocument( const uno::Reference<sheet::XSpreadsheetDocument>& _document )
 245                                 throw(uno::RuntimeException)
 246 {
 247     mxDoc = _document;
 248 }
 249
 250 table::CellAddress SAL_CALL SolverComponent::getObjective() throw(uno::RuntimeException)
 251 {
 252     return maObjective;
 253 }
 254
 255 void SAL_CALL SolverComponent::setObjective( const table::CellAddress& _objective ) throw(uno::RuntimeException)
 256 {
 257     maObjective = _objective;
 258 }
 259
 260 uno::Sequence<table::CellAddress> SAL_CALL SolverComponent::getVariables() throw(uno::RuntimeException)
 261 {
 262     return maVariables;
 263 }
 264
 265 void SAL_CALL SolverComponent::setVariables( const uno::Sequence<table::CellAddress>& _variables )
 266                                 throw(uno::RuntimeException)
 267 {
 268     maVariables = _variables;
 269 }
 270
 271 uno::Sequence<sheet::SolverConstraint> SAL_CALL SolverComponent::getConstraints() throw(uno::RuntimeException)
 272 {
 273     return maConstraints;
 274 }
 275
 276 void SAL_CALL SolverComponent::setConstraints( const uno::Sequence<sheet::SolverConstraint>& _constraints )
 277                                 throw(uno::RuntimeException)
 278 {
 279     maConstraints = _constraints;
 280 }
 281
 282 sal_Bool SAL_CALL SolverComponent::getMaximize() throw(uno::RuntimeException)
 283 {
 284     return mbMaximize;
 285 }
 286
 287 void SAL_CALL SolverComponent::setMaximize( sal_Bool _maximize ) throw(uno::RuntimeException)
 288 {
 289     mbMaximize = _maximize;
 290 }
 291
 292 // XSolver: get results
 293
 294 sal_Bool SAL_CALL SolverComponent::getSuccess() throw(uno::RuntimeException)
 295 {
 296     return mbSuccess;
 297 }
 298
 299 double SAL_CALL SolverComponent::getResultValue() throw(uno::RuntimeException)
 300 {
 301     return mfResultValue;
 302 }
 303
 304 uno::Sequence<double> SAL_CALL SolverComponent::getSolution() throw(uno::RuntimeException)
 305 {
 306     return maSolution;
 307 }
 308
 309 // -------------------------------------------------------------------------
 310
 311 void SAL_CALL SolverComponent::solve() throw(uno::RuntimeException)
 312 {
 313     uno::Reference<frame::XModel> xModel( mxDoc, uno::UNO_QUERY );
 314     if ( !xModel.is() )
 315         throw uno::RuntimeException();
 316
 317     maStatus = OUString();
 318     mbSuccess = false;
 319
 320     if ( mnEpsilonLevel < EPS_TIGHT || mnEpsilonLevel > EPS_BAGGY )
 321     {
 322         maStatus = lcl_GetResourceString( RID_ERROR_EPSILONLEVEL );
 323         return;
 324     }
 325
 326     xModel->lockControllers();
 327
 328     // collect variables in vector (?)
 329
 330     std::vector<table::CellAddress> aVariableCells;
 331     for (sal_Int32 nPos=0; nPos<maVariables.getLength(); nPos++)
 332         aVariableCells.push_back( maVariables[nPos] );
 333     size_t nVariables = aVariableCells.size();
 334     size_t nVar = 0;
 335
 336     // collect all dependent cells
 337
 338     ScSolverCellHashMap aCellsHash;
 339     aCellsHash[maObjective].reserve( nVariables + 1 );                  // objective function
 340
 341     for (sal_Int32 nConstrPos = 0; nConstrPos < maConstraints.getLength(); ++nConstrPos)
 342     {
 343         table::CellAddress aCellAddr = maConstraints[nConstrPos].Left;
 344         aCellsHash[aCellAddr].reserve( nVariables + 1 );                // constraints: left hand side
 345
 346         if ( maConstraints[nConstrPos].Right >>= aCellAddr )
 347             aCellsHash[aCellAddr].reserve( nVariables + 1 );            // constraints: right hand side
 348     }
 349
 350     // set all variables to zero
 351     //! store old values?
 352     //! use old values as initial values?
 353     std::vector<table::CellAddress>::const_iterator aVarIter;
 354     for ( aVarIter = aVariableCells.begin(); aVarIter != aVariableCells.end(); ++aVarIter )
 355     {
 356         lcl_SetValue( mxDoc, *aVarIter, 0.0 );
 357     }
 358
 359     // read initial values from all dependent cells
 360     ScSolverCellHashMap::iterator aCellsIter;
 361     for ( aCellsIter = aCellsHash.begin(); aCellsIter != aCellsHash.end(); ++aCellsIter )
 362     {
 363         double fValue = lcl_GetValue( mxDoc, aCellsIter->first );
 364         aCellsIter->second.push_back( fValue );                         // store as first element, as-is
 365     }
 366
 367     // loop through variables
 368     for ( aVarIter = aVariableCells.begin(); aVarIter != aVariableCells.end(); ++aVarIter )
 369     {
 370         lcl_SetValue( mxDoc, *aVarIter, 1.0 );      // set to 1 to examine influence
 371
 372         // read value change from all dependent cells
 373         for ( aCellsIter = aCellsHash.begin(); aCellsIter != aCellsHash.end(); ++aCellsIter )
 374         {
 375             double fChanged = lcl_GetValue( mxDoc, aCellsIter->first );
 376             double fInitial = aCellsIter->second.front();
 377             aCellsIter->second.push_back( fChanged - fInitial );
 378         }
 379
 380         lcl_SetValue( mxDoc, *aVarIter, 2.0 );      // minimal test for linearity
 381
 382         for ( aCellsIter = aCellsHash.begin(); aCellsIter != aCellsHash.end(); ++aCellsIter )
 383         {
 384             double fInitial = aCellsIter->second.front();
 385             double fCoeff   = aCellsIter->second.back();       // last appended: coefficient for this variable
 386             double fTwo     = lcl_GetValue( mxDoc, aCellsIter->first );
 387
 388             bool bLinear = rtl::math::approxEqual( fTwo, fInitial + 2.0 * fCoeff ) ||
 389                            rtl::math::approxEqual( fInitial, fTwo - 2.0 * fCoeff );
 390             // second comparison is needed in case fTwo is zero
 391             if ( !bLinear )
 392                 maStatus = lcl_GetResourceString( RID_ERROR_NONLINEAR );
 393         }
 394
 395         lcl_SetValue( mxDoc, *aVarIter, 0.0 );      // set back to zero for examining next variable
 396     }
 397
 398     xModel->unlockControllers();
 399
 400     if ( maStatus.getLength() )
 401         return;
 402
 403     //
 404     // build lp_solve model
 405     //
 406
 407     lprec* lp = make_lp( 0, nVariables );
 408     if ( !lp )
 409         return;
 410
 411     set_outputfile( lp, const_cast<char*>( "" ) );  // no output
 412
 413     // set objective function
 414
 415     const std::vector<double>& rObjCoeff = aCellsHash[maObjective];
 416     REAL* pObjVal = new REAL[nVariables+1];
 417     pObjVal[0] = 0.0;                           // ignored
 418     for (nVar=0; nVar<nVariables; nVar++)
 419         pObjVal[nVar+1] = rObjCoeff[nVar+1];
 420     set_obj_fn( lp, pObjVal );
 421     delete[] pObjVal;
 422     set_rh( lp, 0, rObjCoeff[0] );              // constant term of objective
 423
 424     // add rows
 425
 426     set_add_rowmode(lp, TRUE);
 427
 428     for (sal_Int32 nConstrPos = 0; nConstrPos < maConstraints.getLength(); ++nConstrPos)
 429     {
 430         // integer constraints are set later
 431         sheet::SolverConstraintOperator eOp = maConstraints[nConstrPos].Operator;
 432         if ( eOp == sheet::SolverConstraintOperator_LESS_EQUAL ||
 433              eOp == sheet::SolverConstraintOperator_GREATER_EQUAL ||
 434              eOp == sheet::SolverConstraintOperator_EQUAL )
 435         {
 436             double fDirectValue = 0.0;
 437             bool bRightCell = false;
 438             table::CellAddress aRightAddr;
 439             const uno::Any& rRightAny = maConstraints[nConstrPos].Right;
 440             if ( rRightAny >>= aRightAddr )
 441                 bRightCell = true;                  // cell specified as right-hand side
 442             else
 443                 rRightAny >>= fDirectValue;         // constant value
 444
 445             table::CellAddress aLeftAddr = maConstraints[nConstrPos].Left;
 446
 447             const std::vector<double>& rLeftCoeff = aCellsHash[aLeftAddr];
 448             REAL* pValues = new REAL[nVariables+1];
 449             pValues[0] = 0.0;                               // ignored?
 450             for (nVar=0; nVar<nVariables; nVar++)
 451                 pValues[nVar+1] = rLeftCoeff[nVar+1];
 452
 453             // if left hand cell has a constant term, put into rhs value
 454             double fRightValue = -rLeftCoeff[0];
 455
 456             if ( bRightCell )
 457             {
 458                 const std::vector<double>& rRightCoeff = aCellsHash[aRightAddr];
 459                 // modify pValues with rhs coefficients
 460                 for (nVar=0; nVar<nVariables; nVar++)
 461                     pValues[nVar+1] -= rRightCoeff[nVar+1];
 462
 463                 fRightValue += rRightCoeff[0];      // constant term
 464             }
 465             else
 466                 fRightValue += fDirectValue;
 467
 468             int nConstrType = LE;
 469             switch ( eOp )
 470             {
 471                 case sheet::SolverConstraintOperator_LESS_EQUAL:    nConstrType = LE; break;
 472                 case sheet::SolverConstraintOperator_GREATER_EQUAL: nConstrType = GE; break;
 473                 case sheet::SolverConstraintOperator_EQUAL:         nConstrType = EQ; break;
 474                 default:
 475                     OSL_ENSURE( false, "unexpected enum type" );
 476             }
 477             add_constraint( lp, pValues, nConstrType, fRightValue );
 478
 479             delete[] pValues;
 480         }
 481     }
 482
 483     set_add_rowmode(lp, FALSE);
 484
 485     // apply settings to all variables
 486
 487     for (nVar=0; nVar<nVariables; nVar++)
 488     {
 489         if ( !mbNonNegative )
 490             set_unbounded(lp, nVar+1);          // allow negative (default is non-negative)
 491                                                 //! collect bounds from constraints?
 492         if ( mbInteger )
 493             set_int(lp, nVar+1, TRUE);
 494     }
 495
 496     // apply single-var integer constraints
 497
 498     for (sal_Int32 nConstrPos = 0; nConstrPos < maConstraints.getLength(); ++nConstrPos)
 499     {
 500         sheet::SolverConstraintOperator eOp = maConstraints[nConstrPos].Operator;
 501         if ( eOp == sheet::SolverConstraintOperator_INTEGER ||
 502              eOp == sheet::SolverConstraintOperator_BINARY )
 503         {
 504             table::CellAddress aLeftAddr = maConstraints[nConstrPos].Left;
 505             // find variable index for cell
 506             for (nVar=0; nVar<nVariables; nVar++)
 507                 if ( AddressEqual( aVariableCells[nVar], aLeftAddr ) )
 508                 {
 509                     if ( eOp == sheet::SolverConstraintOperator_INTEGER )
 510                         set_int(lp, nVar+1, TRUE);
 511                     else
 512                         set_binary(lp, nVar+1, TRUE);
 513                 }
 514         }
 515     }
 516
 517     if ( mbMaximize )
 518         set_maxim(lp);
 519     else
 520         set_minim(lp);
 521
 522     if ( !mbLimitBBDepth )
 523         set_bb_depthlimit( lp, 0 );
 524
 525     set_epslevel( lp, mnEpsilonLevel );
 526     set_timeout( lp, mnTimeout );
 527
 528     // solve model
 529
 530     int nResult = ::solve( lp );
 531
 532     mbSuccess = ( nResult == OPTIMAL );
 533     if ( mbSuccess )
 534     {
 535         // get solution
 536
 537         maSolution.realloc( nVariables );
 538
 539         REAL* pResultVar = NULL;
 540         get_ptr_variables( lp, &pResultVar );
 541         for (nVar=0; nVar<nVariables; nVar++)
 542             maSolution[nVar] = pResultVar[nVar];
 543
 544         mfResultValue = get_objective( lp );
 545     }
 546     else if ( nResult == INFEASIBLE )
 547         maStatus = lcl_GetResourceString( RID_ERROR_INFEASIBLE );
 548     else if ( nResult == UNBOUNDED )
 549         maStatus = lcl_GetResourceString( RID_ERROR_UNBOUNDED );
 550     else if ( nResult == TIMEOUT || nResult == SUBOPTIMAL )
 551         maStatus = lcl_GetResourceString( RID_ERROR_TIMEOUT );
 552     // SUBOPTIMAL is assumed to be caused by a timeout, and reported as an error
 553
 554     delete_lp( lp );
 555 }
 556
 557 // -------------------------------------------------------------------------
 558
 559 // XServiceInfo
 560
 561 uno::Sequence< OUString > SolverComponent_getSupportedServiceNames()
 562 {
 563     uno::Sequence< OUString > aServiceNames( 1 );
 564     aServiceNames[ 0 ] = OUString::createFromAscii( "com.sun.star.sheet.Solver" );
 565     return aServiceNames;
 566 }
 567
 568 OUString SolverComponent_getImplementationName()
 569 {
 570     return OUString::createFromAscii( "com.sun.star.comp.Calc.Solver" );
 571 }
 572
 573 OUString SAL_CALL SolverComponent::getImplementationName() throw(uno::RuntimeException)
 574 {
 575     return SolverComponent_getImplementationName();
 576 }
 577
 578 sal_Bool SAL_CALL SolverComponent::supportsService( const OUString& rServiceName ) throw(uno::RuntimeException)
 579 {
 580     const uno::Sequence< OUString > aServices = SolverComponent_getSupportedServiceNames();
 581     const OUString* pArray = aServices.getConstArray();
 582     const OUString* pArrayEnd = pArray + aServices.getLength();
 583     return ::std::find( pArray, pArrayEnd, rServiceName ) != pArrayEnd;
 584 }
 585
 586 uno::Sequence<OUString> SAL_CALL SolverComponent::getSupportedServiceNames() throw(uno::RuntimeException)
 587 {
 588     return SolverComponent_getSupportedServiceNames();
 589 }
 590
 591 uno::Reference<uno::XInterface> SolverComponent_createInstance( const uno::Reference<uno::XComponentContext>& rSMgr )
 592     throw(uno::Exception)
 593 {
 594     return (cppu::OWeakObject*) new SolverComponent( rSMgr );
 595 }
 596
 597 // -------------------------------------------------------------------------
 598
 599 extern "C"
 600 {
 601     SAL_DLLPUBLIC_EXPORT void SAL_CALL component_getImplementationEnvironment(
 602         const sal_Char ** ppEnvTypeName, uno_Environment ** )
 603     {
 604         *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
 605     }
 606
 607     // -------------------------------------------------------------------------
 608
 609     SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL component_writeInfo( void* /*pServiceManager*/, void* pRegistryKey )
 610     {
 611         if (pRegistryKey)
 612         {
 613             try
 614             {
 615                 uno::Reference<registry::XRegistryKey> xNewKey;
 616                 sal_Int32                              nPos;
 617
 618                 xNewKey = reinterpret_cast< registry::XRegistryKey * >( pRegistryKey )->createKey( SolverComponent_getImplementationName() );
 619                 xNewKey = xNewKey->createKey( OUString::createFromAscii( "/UNO/SERVICES" ) );
 620                 const uno::Sequence< OUString > & rSNL1 = SolverComponent_getSupportedServiceNames();
 621                 const OUString * pArray1 = rSNL1.getConstArray();
 622                 for ( nPos = rSNL1.getLength(); nPos--; )
 623                     xNewKey->createKey( pArray1[nPos] );
 624
 625                 return sal_True;
 626             }
 627             catch (registry::InvalidRegistryException &)
 628             {
 629                 OSL_ENSURE( sal_False, "### InvalidRegistryException!" );
 630             }
 631         }
 632         return sal_False;
 633     }
 634
 635     // -------------------------------------------------------------------------
 636
 637     SAL_DLLPUBLIC_EXPORT void* SAL_CALL component_getFactory( const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
 638     {
 639         OUString    aImplName( OUString::createFromAscii( pImplName ) );
 640         void*       pRet = 0;
 641
 642         if( pServiceManager )
 643         {
 644             uno::Reference< lang::XSingleComponentFactory > xFactory;
 645             if( aImplName.equals( SolverComponent_getImplementationName() ) )
 646                 xFactory = cppu::createSingleComponentFactory(
 647                         SolverComponent_createInstance,
 648                         OUString::createFromAscii( pImplName ),
 649                         SolverComponent_getSupportedServiceNames() );
 650
 651             if( xFactory.is() )
 652             {
 653                 xFactory->acquire();
 654                 pRet = xFactory.get();
 655             }
 656         }
 657         return pRet;
 658     }
 659 }
 660