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
  25
  26 /* Implementation of ExpressionNodeFactory class */
  27
  28 namespace slideshow::internal
  29 {
  30         namespace
  31         {
  32             class ConstantValueExpression : public ExpressionNode
  33             {
  34             public:
  35                 explicit ConstantValueExpression( double rValue ) :
  36                     maValue( rValue )
  37                 {
  38                 }
  39
  40                 virtual double operator()( double /*t*/ ) const override
  41                 {
  42                     return maValue;
  43                 }
  44
  45                 virtual bool isConstant() const override
  46                 {
  47                     return true;
  48                 }
  49
  50             private:
  51                 double  maValue;
  52             };
  53
  54             class TValueExpression : public ExpressionNode
  55             {
  56             public:
  57                 TValueExpression()
  58                 {
  59                 }
  60
  61                 virtual double operator()( double t ) const override
  62                 {
  63                     return t;
  64                 }
  65
  66                 virtual bool isConstant() const override
  67                 {
  68                     return false;
  69                 }
  70             };
  71
  72             /** Base class for following binary functions (*+-/)
  73
  74                 Does not pay off to have all this as a template, since
  75                 we'd have to hold the functor as a member (+33% object
  76                 size).
  77              */
  78             class BinaryExpressionBase : public ExpressionNode
  79             {
  80             public:
  81                 BinaryExpressionBase( const std::shared_ptr<ExpressionNode>&    rFirstArg,
  82                                       const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
  83                     mpFirstArg( rFirstArg ),
  84                     mpSecondArg( rSecondArg )
  85                 {
  86                 }
  87
  88                 virtual bool isConstant() const override
  89                 {
  90                     return
  91                         mpFirstArg->isConstant() &&
  92                         mpSecondArg->isConstant();
  93                 }
  94
  95             protected:
  96                 std::shared_ptr<ExpressionNode> mpFirstArg;
  97                 std::shared_ptr<ExpressionNode> mpSecondArg;
  98             };
  99
 100             class PlusExpression : public BinaryExpressionBase
 101             {
 102             public:
 103                 PlusExpression( const std::shared_ptr<ExpressionNode>&  rFirstArg,
 104                                 const std::shared_ptr<ExpressionNode>&  rSecondArg ) :
 105                     BinaryExpressionBase( rFirstArg, rSecondArg )
 106                 {
 107                 }
 108
 109                 virtual double operator()( double t ) const override
 110                 {
 111                     return (*mpFirstArg)(t) + (*mpSecondArg)(t);
 112                 }
 113             };
 114
 115             class MinusExpression : public BinaryExpressionBase
 116             {
 117             public:
 118                 MinusExpression( const std::shared_ptr<ExpressionNode>& rFirstArg,
 119                                  const std::shared_ptr<ExpressionNode>& rSecondArg ) :
 120                     BinaryExpressionBase( rFirstArg, rSecondArg )
 121                 {
 122                 }
 123
 124                 virtual double operator()( double t ) const override
 125                 {
 126                     return (*mpFirstArg)(t) - (*mpSecondArg)(t);
 127                 }
 128             };
 129
 130             class MultipliesExpression : public BinaryExpressionBase
 131             {
 132             public:
 133                 MultipliesExpression( const std::shared_ptr<ExpressionNode>&    rFirstArg,
 134                                       const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
 135                     BinaryExpressionBase( rFirstArg, rSecondArg )
 136                 {
 137                 }
 138
 139                 virtual double operator()( double t ) const override
 140                 {
 141                     return (*mpFirstArg)(t) * (*mpSecondArg)(t);
 142                 }
 143             };
 144
 145             class DividesExpression : public BinaryExpressionBase
 146             {
 147             public:
 148                 DividesExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 149                                    const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 150                     BinaryExpressionBase( rFirstArg, rSecondArg )
 151                 {
 152                 }
 153
 154                 virtual double operator()( double t ) const override
 155                 {
 156                     return (*mpFirstArg)(t) / (*mpSecondArg)(t);
 157                 }
 158             };
 159
 160             class MinExpression : public BinaryExpressionBase
 161             {
 162             public:
 163                 MinExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 164                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 165                     BinaryExpressionBase( rFirstArg, rSecondArg )
 166                 {
 167                 }
 168
 169                 virtual double operator()( double t ) const override
 170                 {
 171                     return ::std::min( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 172                 }
 173             };
 174
 175             class MaxExpression : public BinaryExpressionBase
 176             {
 177             public:
 178                 MaxExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 179                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 180                     BinaryExpressionBase( rFirstArg, rSecondArg )
 181                 {
 182                 }
 183
 184                 virtual double operator()( double t ) const override
 185                 {
 186                     return ::std::max( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 187                 }
 188             };
 189         }
 190
 191         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createConstantValueExpression( double rConstantValue )
 192         {
 193             return std::make_shared<ConstantValueExpression>(rConstantValue);
 194         }
 195
 196         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createValueTExpression()
 197         {
 198             return std::make_shared<TValueExpression>();
 199         }
 200
 201         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createPlusExpression( const std::shared_ptr<ExpressionNode>& rLHS,
 202                                                                              const std::shared_ptr<ExpressionNode>& rRHS )
 203         {
 204             return std::make_shared<PlusExpression>(rLHS, rRHS);
 205         }
 206
 207         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinusExpression( const std::shared_ptr<ExpressionNode>&    rLHS,
 208                                                                               const std::shared_ptr<ExpressionNode>&    rRHS )
 209         {
 210             return std::make_shared<MinusExpression>(rLHS, rRHS);
 211         }
 212
 213         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
 214                                                                                    const std::shared_ptr<ExpressionNode>&   rRHS )
 215         {
 216             return std::make_shared<MultipliesExpression>(rLHS, rRHS);
 217         }
 218
 219         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createDividesExpression( const std::shared_ptr<ExpressionNode>&  rLHS,
 220                                                                                 const std::shared_ptr<ExpressionNode>&  rRHS )
 221         {
 222             return std::make_shared<DividesExpression>(rLHS, rRHS);
 223         }
 224
 225         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 226                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 227         {
 228             return std::make_shared<MinExpression>(rOuterFunction, rInnerFunction);
 229         }
 230
 231         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMaxExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 232                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 233         {
 234             return std::make_shared<MaxExpression>(rOuterFunction, rInnerFunction);
 235         }
 236
 237 }
 238
 239 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */