comparison base/RangeMapper.h @ 1038:cc27f35aa75c cxx11

Introducing the signed 64-bit frame index type, and fixing build failures from inclusion of -Wconversion with -Werror. Not finished yet.

     /**
      * Return the position that maps to the given value, rounding to
      * the nearest position and clamping to the minimum and maximum
      * extents of the mapper's positional range.
      */
-    virtual int getPositionForValue(float value) const = 0;
+    virtual int getPositionForValue(double value) const = 0;
 
     /**
      * Return the position that maps to the given value, rounding to
      * the nearest position, without clamping. That is, whatever
      * mapping function is in use will be projected even outside the
      * minimum and maximum extents of the mapper's positional
      * range. (The mapping outside that range is not guaranteed to be
      * exact, except if the mapper is a linear one.)
      */
-    virtual int getPositionForValueUnclamped(float value) const = 0;
+    virtual int getPositionForValueUnclamped(double value) const = 0;
 
     /**
      * Return the value mapped from the given position, clamping to
      * the minimum and maximum extents of the mapper's value range.
      */
-    virtual float getValueForPosition(int position) const = 0;
+    virtual double getValueForPosition(int position) const = 0;
 
     /**
      * Return the value mapped from the given positionq, without
      * clamping. That is, whatever mapping function is in use will be
      * projected even outside the minimum and maximum extents of the
      * mapper's value range. (The mapping outside that range is not
      * guaranteed to be exact, except if the mapper is a linear one.)
      */
-    virtual float getValueForPositionUnclamped(int position) const = 0;
+    virtual double getValueForPositionUnclamped(int position) const = 0;
 
     /**
      * Get the unit of the mapper's value range.
      */
     virtual QString getUnit() const { return ""; }

      * minpos->maxpos. minval and minpos must be less than maxval and
      * maxpos respectively. If inverted is true, the range will be
      * mapped "backwards" (minval to maxpos and maxval to minpos).
      */
     LinearRangeMapper(int minpos, int maxpos,
-                      float minval, float maxval,
+                      double minval, double maxval,
                       QString unit = "", bool inverted = false);
     
-    virtual int getPositionForValue(float value) const;
-    virtual int getPositionForValueUnclamped(float value) const;
-
-    virtual float getValueForPosition(int position) const;
-    virtual float getValueForPositionUnclamped(int position) const;
+    virtual int getPositionForValue(double value) const;
+    virtual int getPositionForValueUnclamped(double value) const;
+
+    virtual double getValueForPosition(int position) const;
+    virtual double getValueForPositionUnclamped(int position) const;
 
     virtual QString getUnit() const { return m_unit; }
 
 protected:
     int m_minpos;
     int m_maxpos;
-    float m_minval;
-    float m_maxval;
+    double m_minval;
+    double m_maxval;
     QString m_unit;
     bool m_inverted;
 };
 
 class LogRangeMapper : public RangeMapper

      * minpos must be less than maxval and maxpos respectively. If
      * inverted is true, the range will be mapped "backwards" (minval
      * to maxpos and maxval to minpos).
      */
     LogRangeMapper(int minpos, int maxpos,
-                   float minval, float maxval,
+                   double minval, double maxval,
                    QString m_unit = "", bool inverted = false);
 
-    static void convertRatioMinLog(float ratio, float minlog,
+    static void convertRatioMinLog(double ratio, double minlog,
                                    int minpos, int maxpos,
-                                   float &minval, float &maxval);
+                                   double &minval, double &maxval);
 
     static void convertMinMax(int minpos, int maxpos,
-                              float minval, float maxval,
-                              float &ratio, float &minlog);
-
-    virtual int getPositionForValue(float value) const;
-    virtual int getPositionForValueUnclamped(float value) const;
-
-    virtual float getValueForPosition(int position) const;
-    virtual float getValueForPositionUnclamped(int position) const;
+                              double minval, double maxval,
+                              double &ratio, double &minlog);
+
+    virtual int getPositionForValue(double value) const;
+    virtual int getPositionForValueUnclamped(double value) const;
+
+    virtual double getValueForPosition(int position) const;
+    virtual double getValueForPositionUnclamped(int position) const;
 
     virtual QString getUnit() const { return m_unit; }
 
 protected:
     int m_minpos;
     int m_maxpos;
-    float m_ratio;
-    float m_minlog;
-    float m_maxlog;
+    double m_ratio;
+    double m_minlog;
+    double m_maxlog;
     QString m_unit;
     bool m_inverted;
 };
 
 class InterpolatingRangeMapper : public RangeMapper
 {
 public:
-    typedef std::map<float, int> CoordMap;
+    typedef std::map<double, int> CoordMap;
 
     /**
      * Given a series of (value, position) coordinate mappings,
      * construct a range mapper that maps arbitrary values, in the
      * range between minimum and maximum of the provided values, onto

      * this is not the case.
      */
     InterpolatingRangeMapper(CoordMap pointMappings,
                              QString unit);
 
-    virtual int getPositionForValue(float value) const;
-    virtual int getPositionForValueUnclamped(float value) const;
-
-    virtual float getValueForPosition(int position) const;
-    virtual float getValueForPositionUnclamped(int position) const;
+    virtual int getPositionForValue(double value) const;
+    virtual int getPositionForValueUnclamped(double value) const;
+
+    virtual double getValueForPosition(int position) const;
+    virtual double getValueForPositionUnclamped(int position) const;
 
     virtual QString getUnit() const { return m_unit; }
 
 protected:
     CoordMap m_mappings;
-    std::map<int, float> m_reverse;
+    std::map<int, double> m_reverse;
     QString m_unit;
 
     template <typename T>
-    float interpolate(T *mapping, float v) const;
+    double interpolate(T *mapping, double v) const;
 };
 
 class AutoRangeMapper : public RangeMapper
 {
 public:

         Interpolating,
         StraightLine,
         Logarithmic,
     };
 
-    typedef std::map<float, int> CoordMap;
+    typedef std::map<double, int> CoordMap;
 
     /**
      * Given a series of (value, position) coordinate mappings,
      * construct a range mapper that maps arbitrary values, in the
      * range between minimum and maximum of the provided values, onto

     /**
      * Return the mapping type in use.
      */
     MappingType getType() const { return m_type; }
 
-    virtual int getPositionForValue(float value) const;
-    virtual int getPositionForValueUnclamped(float value) const;
-
-    virtual float getValueForPosition(int position) const;
-    virtual float getValueForPositionUnclamped(int position) const;
+    virtual int getPositionForValue(double value) const;
+    virtual int getPositionForValueUnclamped(double value) const;
+
+    virtual double getValueForPosition(int position) const;
+    virtual double getValueForPositionUnclamped(int position) const;
 
     virtual QString getUnit() const { return m_unit; }
 
 protected:
     MappingType m_type;