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