CFixedPointManip.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <imath/CDoubleManip.h>
 
 
namespace imath
{
 
 
class CFixedPointManip: public CDoubleManip
{
public:
       typedef CDoubleManip BaseClass;
 
       enum RoundingType
       {
              RT_NORMAL,
              RT_FLOOR,
              RT_CEIL,
              RT_LAST = RT_CEIL + 1
       };
 
       CFixedPointManip(int precision = 1, RoundingType roundingType = RT_NORMAL);
 
       void SetPrecision(int precision);
 
       RoundingType GetRoundingType() const;
 
       void SetRoundingType(RoundingType roundingType);
 
       // reimplemented (imath::IDoubleManip)
       virtual int GetPrecision() const override;
 
       // reimplemented (imath::TIValueManip)
       virtual double GetRounded(const double& value) const override;
       virtual bool AreValuesEqual(const double& value1, const double& value2) const override;
       virtual bool IsSmaller(const double& value1, const double& value2) const override;
       virtual bool IsSmallerEqual(const double& value1, const double& value2) const override;
       virtual double GetSmallerValue(const double& value) const override;
       virtual double GetBiggerValue(const double& value) const override;
       virtual QString GetString(const double& value) const override;
       virtual bool GetParsed(const QString& text, double& result) const override;
 
protected:
       typedef int (*RoundingFuntionPtr)(qreal value);
 
       virtual qint32 GetInternalValue(double value) const;
       virtual double GetNormalValue(qint32 intValue) const;
 
       QString GetString(const double& value, int precision) const;
 
private:
       int m_precision;
       RoundingType m_roundingType;
 
       static RoundingFuntionPtr m_roundingFuntionsPtr[RT_LAST + 1];
 
       double m_scaleToIntFactor;
};
 
 
// inline methods
 
inline CFixedPointManip::RoundingType CFixedPointManip::GetRoundingType() const
{
       return m_roundingType;
}
 
 
// reimplemented (imath::TIValueManip)
 
inline double CFixedPointManip::GetRounded(const double& value) const
{
       return GetNormalValue(GetInternalValue(value));
}
 
 
inline bool CFixedPointManip::AreValuesEqual(const double& value1, const double& value2) const
{
       return GetInternalValue(value1) == GetInternalValue(value2);
}
 
 
inline bool CFixedPointManip::IsSmaller(const double& value1, const double& value2) const
{
       return GetInternalValue(value1) < GetInternalValue(value2);
}
 
 
inline bool CFixedPointManip::IsSmallerEqual(const double& value1, const double& value2) const
{
       return GetInternalValue(value1) <= GetInternalValue(value2);
}
 
 
inline double CFixedPointManip::GetSmallerValue(const double& value) const
{
       return GetNormalValue(GetInternalValue(value) - 1);
}
 
 
inline double CFixedPointManip::GetBiggerValue(const double& value) const
{
       return GetNormalValue(GetInternalValue(value) + 1);
}
 
 
// protected methods
 
inline qint32 CFixedPointManip::GetInternalValue(double value) const
{
       RoundingFuntionPtr function = m_roundingFuntionsPtr[m_roundingType];
 
       return qint32(function(value * m_scaleToIntFactor));
}
 
 
inline double CFixedPointManip::GetNormalValue(qint32 intValue) const
{
       return intValue / m_scaleToIntFactor;
}
 
 
} // namespace imath