slideshow/source/engine/expressionnodefactory.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <expressionnodefactory.hxx>
  22
  23 #include <algorithm>
  24 #include <utility>
  25
  26
  27 /* Implementation of ExpressionNodeFactory class */
  28
  29 namespace slideshow::internal
  30 {
  31         namespace
  32         {
  33             class ConstantValueExpression : public ExpressionNode
  34             {
  35             public:
  36                 explicit ConstantValueExpression( double rValue ) :
  37                     maValue( rValue )
  38                 {
  39                 }
  40
  41                 virtual double operator()( double /*t*/ ) const override
  42                 {
  43                     return maValue;
  44                 }
  45
  46                 virtual bool isConstant() const override
  47                 {
  48                     return true;
  49                 }
  50
  51             private:
  52                 double  maValue;
  53             };
  54
  55             class TValueExpression : public ExpressionNode
  56             {
  57             public:
  58                 TValueExpression()
  59                 {
  60                 }
  61
  62                 virtual double operator()( double t ) const override
  63                 {
  64                     return t;
  65                 }
  66
  67                 virtual bool isConstant() const override
  68                 {
  69                     return false;
  70                 }
  71             };
  72
  73             /** Base class for following binary functions (*+-/)
  74
  75                 Does not pay off to have all this as a template, since
  76                 we'd have to hold the functor as a member (+33% object
  77                 size).
  78              */
  79             class BinaryExpressionBase : public ExpressionNode
  80             {
  81             public:
  82                 BinaryExpressionBase( std::shared_ptr<ExpressionNode> pFirstArg,
  83                                       std::shared_ptr<ExpressionNode> pSecondArg ) :
  84                     mpFirstArg(std::move( pFirstArg )),
  85                     mpSecondArg(std::move( pSecondArg ))
  86                 {
  87                 }
  88
  89                 virtual bool isConstant() const override
  90                 {
  91                     return
  92                         mpFirstArg->isConstant() &&
  93                         mpSecondArg->isConstant();
  94                 }
  95
  96             protected:
  97                 std::shared_ptr<ExpressionNode> mpFirstArg;
  98                 std::shared_ptr<ExpressionNode> mpSecondArg;
  99             };
 100
 101             class PlusExpression : public BinaryExpressionBase
 102             {
 103             public:
 104                 PlusExpression( const std::shared_ptr<ExpressionNode>&  rFirstArg,
 105                                 const std::shared_ptr<ExpressionNode>&  rSecondArg ) :
 106                     BinaryExpressionBase( rFirstArg, rSecondArg )
 107                 {
 108                 }
 109
 110                 virtual double operator()( double t ) const override
 111                 {
 112                     return (*mpFirstArg)(t) + (*mpSecondArg)(t);
 113                 }
 114             };
 115
 116             class MinusExpression : public BinaryExpressionBase
 117             {
 118             public:
 119                 MinusExpression( const std::shared_ptr<ExpressionNode>& rFirstArg,
 120                                  const std::shared_ptr<ExpressionNode>& rSecondArg ) :
 121                     BinaryExpressionBase( rFirstArg, rSecondArg )
 122                 {
 123                 }
 124
 125                 virtual double operator()( double t ) const override
 126                 {
 127                     return (*mpFirstArg)(t) - (*mpSecondArg)(t);
 128                 }
 129             };
 130
 131             class MultipliesExpression : public BinaryExpressionBase
 132             {
 133             public:
 134                 MultipliesExpression( const std::shared_ptr<ExpressionNode>&    rFirstArg,
 135                                       const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
 136                     BinaryExpressionBase( rFirstArg, rSecondArg )
 137                 {
 138                 }
 139
 140                 virtual double operator()( double t ) const override
 141                 {
 142                     return (*mpFirstArg)(t) * (*mpSecondArg)(t);
 143                 }
 144             };
 145
 146             class DividesExpression : public BinaryExpressionBase
 147             {
 148             public:
 149                 DividesExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 150                                    const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 151                     BinaryExpressionBase( rFirstArg, rSecondArg )
 152                 {
 153                 }
 154
 155                 virtual double operator()( double t ) const override
 156                 {
 157                     return (*mpFirstArg)(t) / (*mpSecondArg)(t);
 158                 }
 159             };
 160
 161             class MinExpression : public BinaryExpressionBase
 162             {
 163             public:
 164                 MinExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 165                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 166                     BinaryExpressionBase( rFirstArg, rSecondArg )
 167                 {
 168                 }
 169
 170                 virtual double operator()( double t ) const override
 171                 {
 172                     return ::std::min( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 173                 }
 174             };
 175
 176             class MaxExpression : public BinaryExpressionBase
 177             {
 178             public:
 179                 MaxExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 180                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 181                     BinaryExpressionBase( rFirstArg, rSecondArg )
 182                 {
 183                 }
 184
 185                 virtual double operator()( double t ) const override
 186                 {
 187                     return ::std::max( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 188                 }
 189             };
 190         }
 191
 192         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createConstantValueExpression( double rConstantValue )
 193         {
 194             return std::make_shared<ConstantValueExpression>(rConstantValue);
 195         }
 196
 197         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createValueTExpression()
 198         {
 199             return std::make_shared<TValueExpression>();
 200         }
 201
 202         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createPlusExpression( const std::shared_ptr<ExpressionNode>& rLHS,
 203                                                                              const std::shared_ptr<ExpressionNode>& rRHS )
 204         {
 205             return std::make_shared<PlusExpression>(rLHS, rRHS);
 206         }
 207
 208         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinusExpression( const std::shared_ptr<ExpressionNode>&    rLHS,
 209                                                                               const std::shared_ptr<ExpressionNode>&    rRHS )
 210         {
 211             return std::make_shared<MinusExpression>(rLHS, rRHS);
 212         }
 213
 214         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
 215                                                                                    const std::shared_ptr<ExpressionNode>&   rRHS )
 216         {
 217             return std::make_shared<MultipliesExpression>(rLHS, rRHS);
 218         }
 219
 220         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createDividesExpression( const std::shared_ptr<ExpressionNode>&  rLHS,
 221                                                                                 const std::shared_ptr<ExpressionNode>&  rRHS )
 222         {
 223             return std::make_shared<DividesExpression>(rLHS, rRHS);
 224         }
 225
 226         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 227                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 228         {
 229             return std::make_shared<MinExpression>(rOuterFunction, rInnerFunction);
 230         }
 231
 232         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMaxExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 233                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 234         {
 235             return std::make_shared<MaxExpression>(rOuterFunction, rInnerFunction);
 236         }
 237
 238 }
 239
 240 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */