sccomp: Share common code and have only one library.

And use constructor feature for UNO implementations.

Change-Id: I42b6a6f417049cc8e2d44b74c7adc552680b1f2d

Repository.mk

@@ -150,7 +150,6 @@ $(eval $(call gb_Helper_register_libraries_for_install,OOOLIBS,base, \
 $(eval $(call gb_Helper_register_libraries_for_install,OOOLIBS,calc, \
 	analysis \
 	calc \
-	$(if $(ENABLE_COINMP),coinmpsolver) \
 	date \
 	pricing \
 	sc \
@@ -158,7 +157,7 @@ $(eval $(call gb_Helper_register_libraries_for_install,OOOLIBS,calc, \
 	scfilt \
 	scui \
 	$(if $(ENABLE_OPENCL),scopencl) \
-	$(if $(ENABLE_LPSOLVE),solver) \
+	$(if $(ENABLE_COINMP)$(ENABLE_LPSOLVE),solver) \
 	$(if $(DISABLE_SCRIPTING),,vbaobj) \
 	$(if $(ENABLE_TELEPATHY),tubes) \
 ))

RepositoryExternal.mk

@@ -2020,6 +2020,10 @@ $(eval $(call gb_Helper_register_packages_for_install,ooo,\
 
 endif # SYSTEM_LPSOLVE
 
+else
+
+gb_LinkTarget__use_lpsolve :=
+
 endif # ENABLE_LPSOLVE
 
 ifneq ($(ENABLE_COINMP),)
@@ -2052,6 +2056,10 @@ $(eval $(call gb_Helper_register_packages_for_install,ooo,\
 	coinmp \
 ))
 
+else
+
+gb_LinkTarget__use_coinmp :=
+
 endif # ENABLE_COINMP
 
 ifeq ($(ENABLE_GIO),TRUE)

postprocess/Rdb_services.mk

@@ -113,7 +113,7 @@ $(eval $(call gb_Rdb_add_components,services,\
 		sccomp/source/solver/coinmpsolver \
 	) \
 	$(if $(ENABLE_LPSOLVE), \
-		sccomp/source/solver/solver \
+		sccomp/source/solver/lpsolvesolver \
 	) \
 	writerfilter/util/writerfilter \
 	writerperfect/source/draw/wpftdraw \

sccomp/Library_coinmpsolver.mk

-# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
-#
-# This file is part of the LibreOffice project.
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-$(eval $(call gb_Library_Library,coinmpsolver))
-
-$(eval $(call gb_Library_set_componentfile,coinmpsolver,sccomp/source/solver/coinmpsolver))
-
-$(eval $(call gb_Library_use_sdk_api,coinmpsolver))
-
-$(eval $(call gb_Library_use_libraries,coinmpsolver,\
-	comphelper \
-	cppu \
-	cppuhelper \
-	sal \
-	tl \
-	i18nlangtag \
-	$(gb_UWINAPI) \
-))
-
-$(eval $(call gb_Library_use_externals,coinmpsolver,\
-	boost_headers \
-	coinmp \
-))
-
-$(eval $(call gb_Library_add_exception_objects,coinmpsolver,\
-	sccomp/source/solver/solver \
-))
-
-# vim: set noet sw=4 ts=4:

sccomp/Library_solver.mk

@@ -19,7 +19,8 @@
 
 $(eval $(call gb_Library_Library,solver))
 
-$(eval $(call gb_Library_set_componentfile,solver,sccomp/source/solver/solver))
+$(if $(ENABLE_COINMP),$(eval $(call gb_Library_set_componentfile,solver,sccomp/source/solver/coinmpsolver)))
+$(if $(ENABLE_LPSOLVE),$(eval $(call gb_Library_set_componentfile,solver,sccomp/source/solver/lpsolvesolver)))
 
 $(eval $(call gb_Library_use_sdk_api,solver))
 
@@ -35,11 +36,14 @@ $(eval $(call gb_Library_use_libraries,solver,\
 
 $(eval $(call gb_Library_use_externals,solver,\
 	boost_headers \
+	coinmp \
 	lpsolve \
 ))
 
 $(eval $(call gb_Library_add_exception_objects,solver,\
-	sccomp/source/solver/solver-lpsolve \
+	sccomp/source/solver/SolverComponent \
+	$(if $(ENABLE_COINMP), sccomp/source/solver/CoinMPSolver) \
+	$(if $(ENABLE_LPSOLVE), sccomp/source/solver/LpsolveSolver) \
 ))
 
 # vim: set noet sw=4 ts=4:

sccomp/Module_sccomp.mk

@@ -20,8 +20,7 @@
 $(eval $(call gb_Module_Module,sccomp))
 
 $(eval $(call gb_Module_add_targets,sccomp,\
-	$(if $(ENABLE_COINMP), Library_coinmpsolver) \
-	$(if $(ENABLE_LPSOLVE), Library_solver) \
+	$(if $(ENABLE_COINMP)$(ENABLE_LPSOLVE), Library_solver) \
 ))
 
 $(eval $(call gb_Module_add_l10n_targets,sccomp,\

sccomp/source/solver/SolverComponent.cxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "SolverComponent.hxx"
+#include "solver.hrc"
+
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
+#include <com/sun/star/sheet/XSpreadsheet.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+
+#include <cppuhelper/supportsservice.hxx>
+#include <vector>
+
+#include <tools/resmgr.hxx>
+
+using namespace com::sun::star;
+
+
+#define STR_NONNEGATIVE   "NonNegative"
+#define STR_INTEGER       "Integer"
+#define STR_TIMEOUT       "Timeout"
+#define STR_EPSILONLEVEL  "EpsilonLevel"
+#define STR_LIMITBBDEPTH  "LimitBBDepth"
+
+
+//  Resources from tools are used for translated strings
+
+ResMgr* SolverComponent::pSolverResMgr = NULL;
+
+OUString SolverComponent::GetResourceString( sal_uInt32 nId )
+{
+    if (!pSolverResMgr)
+        pSolverResMgr = ResMgr::CreateResMgr("solver");
+
+    return ResId(nId, *pSolverResMgr).toString();
+}
+
+size_t ScSolverCellHash::operator()( const css::table::CellAddress& rAddress ) const
+{
+    return ( rAddress.Sheet << 24 ) | ( rAddress.Column << 16 ) | rAddress.Row;
+}
+
+bool ScSolverCellEqual::operator()( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 ) const
+{
+    return AddressEqual( rAddr1, rAddr2 );
+}
+
+namespace
+{
+    enum
+    {
+        PROP_NONNEGATIVE,
+        PROP_INTEGER,
+        PROP_TIMEOUT,
+        PROP_EPSILONLEVEL,
+        PROP_LIMITBBDEPTH
+    };
+}
+
+uno::Reference<table::XCell> SolverComponent::GetCell( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                                          const table::CellAddress& rPos )
+{
+    uno::Reference<container::XIndexAccess> xSheets( xDoc->getSheets(), uno::UNO_QUERY );
+    uno::Reference<sheet::XSpreadsheet> xSheet( xSheets->getByIndex( rPos.Sheet ), uno::UNO_QUERY );
+    return xSheet->getCellByPosition( rPos.Column, rPos.Row );
+}
+
+void SolverComponent::SetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                   const table::CellAddress& rPos, double fValue )
+{
+    SolverComponent::GetCell( xDoc, rPos )->setValue( fValue );
+}
+
+double SolverComponent::GetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                     const table::CellAddress& rPos )
+{
+    return SolverComponent::GetCell( xDoc, rPos )->getValue();
+}
+
+SolverComponent::SolverComponent() :
+    OPropertyContainer( GetBroadcastHelper() ),
+    mbMaximize( sal_True ),
+    mbNonNegative( sal_False ),
+    mbInteger( sal_False ),
+    mnTimeout( 100 ),
+    mnEpsilonLevel( 0 ),
+    mbLimitBBDepth( sal_True ),
+    mbSuccess( sal_False ),
+    mfResultValue( 0.0 )
+{
+    // for XPropertySet implementation:
+    registerProperty( STR_NONNEGATIVE,  PROP_NONNEGATIVE,  0, &mbNonNegative,  getCppuType( &mbNonNegative )  );
+    registerProperty( STR_INTEGER,      PROP_INTEGER,      0, &mbInteger,      getCppuType( &mbInteger )      );
+    registerProperty( STR_TIMEOUT,      PROP_TIMEOUT,      0, &mnTimeout,      getCppuType( &mnTimeout )      );
+    registerProperty( STR_EPSILONLEVEL, PROP_EPSILONLEVEL, 0, &mnEpsilonLevel, getCppuType( &mnEpsilonLevel ) );
+    registerProperty( STR_LIMITBBDEPTH, PROP_LIMITBBDEPTH, 0, &mbLimitBBDepth, getCppuType( &mbLimitBBDepth ) );
+}
+
+SolverComponent::~SolverComponent()
+{
+}
+
+IMPLEMENT_FORWARD_XINTERFACE2( SolverComponent, SolverComponent_Base, OPropertyContainer )
+IMPLEMENT_FORWARD_XTYPEPROVIDER2( SolverComponent, SolverComponent_Base, OPropertyContainer )
+
+cppu::IPropertyArrayHelper* SolverComponent::createArrayHelper() const
+{
+    uno::Sequence<beans::Property> aProps;
+    describeProperties( aProps );
+    return new cppu::OPropertyArrayHelper( aProps );
+}
+
+cppu::IPropertyArrayHelper& SAL_CALL SolverComponent::getInfoHelper()
+{
+    return *getArrayHelper();
+}
+
+uno::Reference<beans::XPropertySetInfo> SAL_CALL SolverComponent::getPropertySetInfo() throw(uno::RuntimeException, std::exception)
+{
+    return createPropertySetInfo( getInfoHelper() );
+}
+
+// XSolverDescription
+
+OUString SAL_CALL SolverComponent::getComponentDescription() throw (uno::RuntimeException, std::exception)
+{
+    return SolverComponent::GetResourceString( RID_SOLVER_COMPONENT );
+}
+
+OUString SAL_CALL SolverComponent::getStatusDescription() throw (uno::RuntimeException, std::exception)
+{
+    return maStatus;
+}
+
+OUString SAL_CALL SolverComponent::getPropertyDescription( const OUString& rPropertyName ) throw (uno::RuntimeException, std::exception)
+{
+    sal_uInt32 nResId = 0;
+    sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
+    switch (nHandle)
+    {
+        case PROP_NONNEGATIVE:
+            nResId = RID_PROPERTY_NONNEGATIVE;
+            break;
+        case PROP_INTEGER:
+            nResId = RID_PROPERTY_INTEGER;
+            break;
+        case PROP_TIMEOUT:
+            nResId = RID_PROPERTY_TIMEOUT;
+            break;
+        case PROP_EPSILONLEVEL:
+            nResId = RID_PROPERTY_EPSILONLEVEL;
+            break;
+        case PROP_LIMITBBDEPTH:
+            nResId = RID_PROPERTY_LIMITBBDEPTH;
+            break;
+        default:
+            {
+                // unknown - leave empty
+            }
+    }
+    OUString aRet;
+    if ( nResId )
+        aRet = SolverComponent::GetResourceString( nResId );
+    return aRet;
+}
+
+// XSolver: settings
+
+uno::Reference<sheet::XSpreadsheetDocument> SAL_CALL SolverComponent::getDocument() throw(uno::RuntimeException, std::exception)
+{
+    return mxDoc;
+}
+
+void SAL_CALL SolverComponent::setDocument( const uno::Reference<sheet::XSpreadsheetDocument>& _document )
+                                throw(uno::RuntimeException, std::exception)
+{
+    mxDoc = _document;
+}
+
+table::CellAddress SAL_CALL SolverComponent::getObjective() throw(uno::RuntimeException, std::exception)
+{
+    return maObjective;
+}
+
+void SAL_CALL SolverComponent::setObjective( const table::CellAddress& _objective ) throw(uno::RuntimeException, std::exception)
+{
+    maObjective = _objective;
+}
+
+uno::Sequence<table::CellAddress> SAL_CALL SolverComponent::getVariables() throw(uno::RuntimeException, std::exception)
+{
+    return maVariables;
+}
+
+void SAL_CALL SolverComponent::setVariables( const uno::Sequence<table::CellAddress>& _variables )
+                                throw(uno::RuntimeException, std::exception)
+{
+    maVariables = _variables;
+}
+
+uno::Sequence<sheet::SolverConstraint> SAL_CALL SolverComponent::getConstraints() throw(uno::RuntimeException, std::exception)
+{
+    return maConstraints;
+}
+
+void SAL_CALL SolverComponent::setConstraints( const uno::Sequence<sheet::SolverConstraint>& _constraints )
+                                throw(uno::RuntimeException, std::exception)
+{
+    maConstraints = _constraints;
+}
+
+sal_Bool SAL_CALL SolverComponent::getMaximize() throw(uno::RuntimeException, std::exception)
+{
+    return mbMaximize;
+}
+
+void SAL_CALL SolverComponent::setMaximize( sal_Bool _maximize ) throw(uno::RuntimeException, std::exception)
+{
+    mbMaximize = _maximize;
+}
+
+// XSolver: get results
+
+sal_Bool SAL_CALL SolverComponent::getSuccess() throw(uno::RuntimeException, std::exception)
+{
+    return mbSuccess;
+}
+
+double SAL_CALL SolverComponent::getResultValue() throw(uno::RuntimeException, std::exception)
+{
+    return mfResultValue;
+}
+
+uno::Sequence<double> SAL_CALL SolverComponent::getSolution() throw(uno::RuntimeException, std::exception)
+{
+    return maSolution;
+}
+
+// XServiceInfo
+
+sal_Bool SAL_CALL SolverComponent::supportsService( const OUString& rServiceName ) throw(uno::RuntimeException, std::exception)
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+uno::Sequence<OUString> SAL_CALL SolverComponent::getSupportedServiceNames() throw(uno::RuntimeException, std::exception)
+{
+    uno::Sequence< OUString > aServiceNames( 1 );
+    aServiceNames[ 0 ] = "com.sun.star.sheet.Solver";
+    return aServiceNames;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sccomp/source/solver/solver.hxx → sccomp/source/solver/SolverComponent.hxx

@@ -22,13 +22,38 @@
 
 #include <com/sun/star/sheet/XSolver.hpp>
 #include <com/sun/star/sheet/XSolverDescription.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+#include <com/sun/star/table/XCell.hpp>
 #include <com/sun/star/lang/XServiceInfo.hpp>
-#include <com/sun/star/uno/XComponentContext.hpp>
 #include <cppuhelper/implbase3.hxx>
 #include <comphelper/broadcasthelper.hxx>
 #include <comphelper/propertycontainer.hxx>
 #include <comphelper/proparrhlp.hxx>
 
+#include <boost/unordered_map.hpp>
+
+class ResMgr;
+
+// hash map for the coefficients of a dependent cell (objective or constraint)
+// The size of each vector is the number of columns (variable cells) plus one, first entry is initial value.
+
+struct ScSolverCellHash
+{
+    size_t operator()( const css::table::CellAddress& rAddress ) const;
+};
+
+inline bool AddressEqual( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 )
+{
+    return rAddr1.Sheet == rAddr2.Sheet && rAddr1.Column == rAddr2.Column && rAddr1.Row == rAddr2.Row;
+}
+
+struct ScSolverCellEqual
+{
+    bool operator()( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 ) const;
+};
+
+typedef boost::unordered_map< css::table::CellAddress, std::vector<double>, ScSolverCellHash, ScSolverCellEqual > ScSolverCellHashMap;
+
 typedef cppu::WeakImplHelper3<
                 com::sun::star::sheet::XSolver,
                 com::sun::star::sheet::XSolverDescription,
@@ -40,6 +65,9 @@ class SolverComponent : public comphelper::OMutexAndBroadcastHelper,
                         public comphelper::OPropertyArrayUsageHelper< SolverComponent >,
                         public SolverComponent_Base
 {
+protected:
+    static ResMgr* pSolverResMgr;
+
     // settings
     com::sun::star::uno::Reference< com::sun::star::sheet::XSpreadsheetDocument > mxDoc;
     com::sun::star::table::CellAddress                                            maObjective;
@@ -58,9 +86,19 @@ class SolverComponent : public comphelper::OMutexAndBroadcastHelper,
     com::sun::star::uno::Sequence< double >                                       maSolution;
     OUString                                                                 maStatus;
 
+    static OUString GetResourceString( sal_uInt32 nId );
+    static css::uno::Reference<css::table::XCell> GetCell(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos );
+    static void SetValue(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos, double fValue );
+    static double GetValue(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos );
+
 public:
-                            SolverComponent( const com::sun::star::uno::Reference<
-                                    com::sun::star::uno::XComponentContext >& rxMSF );
+                            SolverComponent();
     virtual                 ~SolverComponent();
 
     DECLARE_XINTERFACE()
@@ -98,7 +136,7 @@ public:
     virtual ::com::sun::star::uno::Sequence< double > SAL_CALL getSolution()
                                 throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
 
-    virtual void SAL_CALL solve() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
+    virtual void SAL_CALL solve() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE = 0;
 
                             // XSolverDescription
     virtual OUString SAL_CALL getComponentDescription() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
@@ -108,7 +146,7 @@ public:
 
                             // XServiceInfo
     virtual OUString SAL_CALL getImplementationName()
-                                throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
+                                throw(::com::sun::star::uno::RuntimeException, std::exception) = 0;
     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName )
                                 throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     virtual ::com::sun::star::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames()

sccomp/source/solver/coinmpsolver.component

@@ -7,9 +7,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  -->
 
-<component loader="com.sun.star.loader.SharedLibrary" prefix="coinmp"
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
     xmlns="http://openoffice.org/2010/uno-components">
-  <implementation name="com.sun.star.comp.Calc.CoinMPSolver">
+  <implementation name="com.sun.star.comp.Calc.CoinMPSolver"
+      constructor="com_sun_star_comp_Calc_CoinMPSolver_get_implementation">
     <service name="com.sun.star.sheet.Solver"/>
   </implementation>
 </component>

sccomp/source/solver/solver.component → sccomp/source/solver/lpsolvesolver.component

@@ -18,8 +18,9 @@
  -->
 
 <component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
-    prefix="solver" xmlns="http://openoffice.org/2010/uno-components">
-  <implementation name="com.sun.star.comp.Calc.Solver">
+    xmlns="http://openoffice.org/2010/uno-components">
+  <implementation name="com.sun.star.comp.Calc.LpsolveSolver"
+      constructor="com_sun_star_comp_Calc_LpsolveSolver_get_implementation">
     <service name="com.sun.star.sheet.Solver"/>
   </implementation>
 </component>