From 940b4d1848e8c70ab7642901a68594e8016caffc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:51:28 +0200 Subject: Adding upstream version 1:7.0.4. Signed-off-by: Daniel Baumann --- slideshow/source/engine/expressionnodefactory.cxx | 239 ++++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 slideshow/source/engine/expressionnodefactory.cxx (limited to 'slideshow/source/engine/expressionnodefactory.cxx') diff --git a/slideshow/source/engine/expressionnodefactory.cxx b/slideshow/source/engine/expressionnodefactory.cxx new file mode 100644 index 000000000..0b4136f34 --- /dev/null +++ b/slideshow/source/engine/expressionnodefactory.cxx @@ -0,0 +1,239 @@ +/* -*- 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 + +#include + + +/* Implementation of ExpressionNodeFactory class */ + +namespace slideshow::internal +{ + namespace + { + class ConstantValueExpression : public ExpressionNode + { + public: + explicit ConstantValueExpression( double rValue ) : + maValue( rValue ) + { + } + + virtual double operator()( double /*t*/ ) const override + { + return maValue; + } + + virtual bool isConstant() const override + { + return true; + } + + private: + double maValue; + }; + + class TValueExpression : public ExpressionNode + { + public: + TValueExpression() + { + } + + virtual double operator()( double t ) const override + { + return t; + } + + virtual bool isConstant() const override + { + return false; + } + }; + + /** Base class for following binary functions (*+-/) + + Does not pay off to have all this as a template, since + we'd have to hold the functor as a member (+33% object + size). + */ + class BinaryExpressionBase : public ExpressionNode + { + public: + BinaryExpressionBase( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + mpFirstArg( rFirstArg ), + mpSecondArg( rSecondArg ) + { + } + + virtual bool isConstant() const override + { + return + mpFirstArg->isConstant() && + mpSecondArg->isConstant(); + } + + protected: + std::shared_ptr mpFirstArg; + std::shared_ptr mpSecondArg; + }; + + class PlusExpression : public BinaryExpressionBase + { + public: + PlusExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return (*mpFirstArg)(t) + (*mpSecondArg)(t); + } + }; + + class MinusExpression : public BinaryExpressionBase + { + public: + MinusExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return (*mpFirstArg)(t) - (*mpSecondArg)(t); + } + }; + + class MultipliesExpression : public BinaryExpressionBase + { + public: + MultipliesExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return (*mpFirstArg)(t) * (*mpSecondArg)(t); + } + }; + + class DividesExpression : public BinaryExpressionBase + { + public: + DividesExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return (*mpFirstArg)(t) / (*mpSecondArg)(t); + } + }; + + class MinExpression : public BinaryExpressionBase + { + public: + MinExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return ::std::min( (*mpFirstArg)(t), (*mpSecondArg)(t) ); + } + }; + + class MaxExpression : public BinaryExpressionBase + { + public: + MaxExpression( const std::shared_ptr& rFirstArg, + const std::shared_ptr& rSecondArg ) : + BinaryExpressionBase( rFirstArg, rSecondArg ) + { + } + + virtual double operator()( double t ) const override + { + return ::std::max( (*mpFirstArg)(t), (*mpSecondArg)(t) ); + } + }; + } + + std::shared_ptr ExpressionNodeFactory::createConstantValueExpression( double rConstantValue ) + { + return std::make_shared(rConstantValue); + } + + std::shared_ptr ExpressionNodeFactory::createValueTExpression() + { + return std::make_shared(); + } + + std::shared_ptr ExpressionNodeFactory::createPlusExpression( const std::shared_ptr& rLHS, + const std::shared_ptr& rRHS ) + { + return std::make_shared(rLHS, rRHS); + } + + std::shared_ptr ExpressionNodeFactory::createMinusExpression( const std::shared_ptr& rLHS, + const std::shared_ptr& rRHS ) + { + return std::make_shared(rLHS, rRHS); + } + + std::shared_ptr ExpressionNodeFactory::createMultipliesExpression( const std::shared_ptr& rLHS, + const std::shared_ptr& rRHS ) + { + return std::make_shared(rLHS, rRHS); + } + + std::shared_ptr ExpressionNodeFactory::createDividesExpression( const std::shared_ptr& rLHS, + const std::shared_ptr& rRHS ) + { + return std::make_shared(rLHS, rRHS); + } + + std::shared_ptr ExpressionNodeFactory::createMinExpression ( const std::shared_ptr& rOuterFunction, + const std::shared_ptr& rInnerFunction ) + { + return std::make_shared(rOuterFunction, rInnerFunction); + } + + std::shared_ptr ExpressionNodeFactory::createMaxExpression ( const std::shared_ptr& rOuterFunction, + const std::shared_ptr& rInnerFunction ) + { + return std::make_shared(rOuterFunction, rInnerFunction); + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3