src/Autopilot/inputvalue.hxx

   1 // inputvalue.hxx - provide input to autopilot components
   2 //
   3 // Written by Torsten Dreyer
   4 // Copyright (C) 2010  Torsten Dreyer - Torsten (at) t3r (dot) de
   5 //
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 //
  20
  21 #ifndef _INPUTVALUE_HXX
  22 #define _INPUTVALUE_HXX 1
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28
  29 #include <simgear/structure/SGExpression.hxx>
  30
  31 namespace FGXMLAutopilot {
  32
  33 typedef SGSharedPtr<class InputValue> InputValue_ptr;
  34 typedef SGSharedPtr<class PeriodicalValue> PeriodicalValue_ptr;
  35
  36 /**
  37  * @brief Model a periodical value like angular values
  38  *
  39  * Most common use for periodical values are angular values.
  40  * If y = f(x) = f(x + n*period), this is a periodical function
  41  */
  42 class PeriodicalValue : public SGReferenced {
  43 private:
  44      InputValue_ptr minPeriod; // The minimum value of the period
  45      InputValue_ptr maxPeriod; // The maximum value of the period
  46 public:
  47      PeriodicalValue( SGPropertyNode_ptr node );
  48      double normalize( double value );
  49 };
  50
  51 /**
  52  * @brief A input value for analog autopilot components
  53  *
  54  * Input values may be constants, property values, transformed with a scale
  55  * and/or offset, clamped to min/max values, be periodical, bound to
  56  * conditions or evaluated from expressions.
  57  */
  58 class InputValue : public SGReferenced {
  59 private:
  60      double             _value;    // The value as a constant or initializer for the property
  61      bool               _abs;      // return absolute value
  62      SGPropertyNode_ptr _property; // The name of the property containing the value
  63      InputValue_ptr _offset;   // A fixed offset, defaults to zero
  64      InputValue_ptr _scale;    // A constant scaling factor defaults to one
  65      InputValue_ptr _min;      // A minimum clip defaults to no clipping
  66      InputValue_ptr _max;      // A maximum clip defaults to no clipping
  67      PeriodicalValue_ptr  _periodical; //
  68      SGSharedPtr<const SGCondition> _condition;
  69      SGSharedPtr<SGExpressiond> _expression;  ///< expression to generate the value
  70
  71 public:
  72     InputValue( SGPropertyNode_ptr node = NULL, double value = 0.0, double offset = 0.0, double scale = 1.0 );
  73
  74     void parse( SGPropertyNode_ptr, double value = 0.0, double offset = 0.0, double scale = 1.0 );
  75
  76     /* get the value of this input, apply scale and offset and clipping */
  77     double get_value() const;
  78
  79     /* set the input value after applying offset and scale */
  80     void set_value( double value );
  81
  82     inline double get_scale() const {
  83       return _scale == NULL ? 1.0 : _scale->get_value();
  84     }
  85
  86     inline double get_offset() const {
  87       return _offset == NULL ? 0.0 : _offset->get_value();
  88     }
  89
  90     inline bool is_enabled() const {
  91       return _condition == NULL ? true : _condition->test();
  92     }
  93
  94 };
  95
  96 /**
  97  * @brief A chained list of InputValues
  98  *
  99  * Many compoments support InputValueLists as input. Each InputValue may be bound to
 100  * a condition. This list supports the get_value() function to retrieve the value
 101  * of the first InputValue in this list that has a condition evaluating to true.
 102  */
 103 class InputValueList : public std::vector<InputValue_ptr> {
 104   public:
 105     InputValueList( double def = 0.0 ) : _def(def) { }
 106
 107     InputValue_ptr get_active() const {
 108       for (const_iterator it = begin(); it != end(); ++it) {
 109         if( (*it)->is_enabled() )
 110           return *it;
 111       }
 112       return NULL;
 113     }
 114
 115     double get_value() const {
 116       InputValue_ptr input = get_active();
 117       return input == NULL ? _def : input->get_value();
 118     }
 119   private:
 120
 121     double _def;
 122
 123 };
 124
 125 }
 126
 127 #endif