File indexing completed on 2024-04-28 16:21:23

 /* This file is part of the KDE project
    Copyright (C) 2003,2004 Ariya Hidayat <ariya@kde.org>
    Copyright (C) 2005 Tomas Mecir <mecirt@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; only
    version 2 of the License.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 // Local
 #include "Function.h"
 
 #include "Value.h"
 
 using namespace Calligra::Sheets;
 
 class Q_DECL_HIDDEN Function::Private
 {
 public:
     QString name;
     QString alternateName;
     FunctionPtr ptr;
     int paramMin, paramMax;
     bool acceptArray;
     bool ne;   // need FunctionExtra* when called ?
 };
 
 Function::Function(const QString& name, FunctionPtr ptr)
         : d(new Private)
 {
     d->name = name;
     d->ptr = ptr;
     d->acceptArray = false;
     d->paramMin = 1;
     d->paramMax = 1;
     d->ne = false;
 }
 
 Function::~Function()
 {
     delete d;
 }
 
 QString Function::name() const
 {
     return d->name;
 }
 
 QString Function::alternateName() const
 {
     return d->alternateName;
 }
 
 void Function::setAlternateName(const QString &name)
 {
     d->alternateName = name;
 }
 
 void Function::setParamCount(int min, int max)
 {
     d->paramMin = min;
     d->paramMax = (max == 0) ? min : max;
 }
 
 bool Function::paramCountOkay(int count)
 {
     // less than needed
     if (count < d->paramMin) return false;
     // no upper limit
     if (d->paramMax == -1) return true;
     // more than needed
     if (count > d->paramMax) return false;
     // okay otherwise
     return true;
 }
 
 void Function::setAcceptArray(bool accept)
 {
     d->acceptArray = accept;
 }
 
 bool Function::needsExtra()
 {
     return d->ne;
 }
 void Function::setNeedsExtra(bool extra)
 {
     d->ne = extra;
 }
 
 Value Function::exec(valVector args, ValueCalc *calc, FuncExtra *extra)
 {
     // check number of parameters
     if (!paramCountOkay(args.count()))
         return Value::errorVALUE();
 
     if (extra)
         extra->function = this;
 
     // do we need to perform array expansion ?
     bool mustExpandArray = false;
     if (!d->acceptArray)
         for (int i = 0; i < args.count(); ++i) {
             if (args[i].isArray())
                 mustExpandArray = true;
         }
 
     if (!d->ptr) return Value::errorVALUE();
 
     // perform the actual array expansion if need be
 
     if (mustExpandArray) {
         // compute number of rows/cols of the result
         int rows = 0;
         int cols = 0;
         for (int i = 0; i < args.count(); ++i) {
             int x = 1;
             if (extra) x = extra->ranges[i].rows();
             if (x > rows) rows = x;
             if (extra) x = extra->ranges[i].columns();
             if (x > cols) cols = x;
         }
         // allocate the resulting array
         Value res(Value::Array);
         // perform the actual computation for each element of the array
         for (int row = 0; row < rows; ++row)
             for (int col = 0; col < cols; ++col) {
                 // fill in the parameter vector
                 valVector vals(args.count());
                 FuncExtra extra2 = *extra;
                 for (int i = 0; i < args.count(); ++i) {
                     int r = extra->ranges[i].rows();
                     int c = extra->ranges[i].columns();
                     vals[i] = args[i].isArray() ?
                               args[i].element(col % c, row % r) : args[i];
 
                     // adjust the FuncExtra structure to refer to the correct cells
                     extra2.ranges[i].col1 += col;
                     extra2.ranges[i].row1 += row;
                     extra2.ranges[i].col2 = extra2.ranges[i].col1;
                     extra2.ranges[i].row2 = extra2.ranges[i].row1;
                 }
                 // execute the function on each element
                 res.setElement(col, row, exec(vals, calc, &extra2));
             }
         return res;
     } else
         // call the function
         return (*d->ptr)(args, calc, extra);
 }
 
 FunctionCaller::FunctionCaller(FunctionPtr ptr, const valVector &args, ValueCalc *calc, FuncExtra *extra)
     : m_ptr(ptr), m_args(args), m_calc(calc), m_extra(extra)
 {
 }
 
 Value FunctionCaller::exec()
 {
     return (*m_ptr)(m_args, m_calc, m_extra);
 }
 
 Value FunctionCaller::exec(const valVector &args)
 {
     return (*m_ptr)(args, m_calc, m_extra);
 }